memory_pressure_set();
else
memory_pressure_clr();
- return;
}
#endif
wi->wi_scheduled = 1; /* LBUG future schedule attempts */
spin_unlock(&sched->ws_lock);
-
- return;
}
EXPORT_SYMBOL(cfs_wi_exit);
LASSERT (!list_empty(&wi->wi_list));
spin_unlock(&sched->ws_lock);
- return;
}
EXPORT_SYMBOL(cfs_wi_schedule);
if (!already_live) {
wake_up_all(&dev->gnd_waitq);
}
- return;
}
void kgnilnd_schedule_device_timer(unsigned long arg)
GNIDBG_SMSG_CREDS(D_NET, conn);
kgnilnd_schedule_conn(conn);
-
- return;
}
void
kmem_cache_free(kgnilnd_data.kgn_rx_cache, rx);
CDEBUG(D_MALLOC, "slab-freed 'rx': %lu at %p.\n",
sizeof(*rx), rx);
-
- return;
}
int
}
}
}
-
- return;
}
void
CDEBUG(D_NET, "peer_ni %s %p, alive %lld secs ago\n",
libcfs_nid2str(nid), peer_ni,
last_alive ? now - last_alive : -1);
- return;
}
static void
out:
if (list_empty(&kiblnd_data.kib_devs))
kiblnd_base_shutdown();
- return;
}
static int
ksocknal_launch_all_connections_locked(peer_ni);
write_unlock_bh(glock);
- return;
}
static void
}
read_unlock(&ksocknal_data.ksnd_global_lock);
- return;
}
void
sock->sk->sk_user_data = conn;
sock->sk->sk_data_ready = ksocknal_data_ready;
sock->sk->sk_write_space = ksocknal_write_space;
- return;
}
void
__swab64s(&stat->ns_nid);
__swab32s(&stat->ns_status);
}
- return;
}
int
lnet_clean_local_ni_recoveryq();
lnet_clean_peer_ni_recoveryq();
lnet_clean_resendqs();
-
- return;
}
void
add_device_randomness(&ni->ni_nid, sizeof(ni->ni_nid));
seeded = 1;
- return;
}
/* NB expects LNET_LOCK held */
atomic_inc(&sn->sn_brw_errors);
rpc->crpc_status = -EBADMSG;
}
-
- return;
}
static void
lstcon_rpc_stat_failure(stat, 0),
lstcon_rpc_stat_total(stat, 0),
stat->trs_rpc_errno, stat->trs_fwk_errno);
-
- return;
}
int
lstcon_rpc_trans_name(trans->tas_opc), count);
LIBCFS_FREE(trans, sizeof(*trans));
-
- return;
}
int
if (stat->trs_fwk_errno == 0)
stat->trs_fwk_errno = rc;
-
- return;
}
int
list_add_tail(&ndl->ndl_hlink, &new->grp_ndl_hash[idx]);
list_add_tail(&ndl->ndl_link, &new->grp_ndl_list);
new->grp_nnode++;
-
- return;
}
static void
sn->sn_timer_active = 1;
timer->stt_expires = ktime_get_real_seconds()+ sn->sn_timeout;
stt_add_timer(timer);
- return;
}
static int
if (rpc->srpc_bulk != NULL)
sfw_free_pages(rpc);
- return;
}
static void
* some buffers behind, but never mind... */
srpc_service_remove_buffers(tsc->tsc_srv_service,
sfw_test_buffers(tsi));
- return;
}
static void
clean:
sfw_unload_test(tsi);
LIBCFS_FREE(tsi, sizeof(*tsi));
- return;
}
static void
}
LIBCFS_FREE(tsb, sizeof(*tsb));
- return;
}
static void
LIBCFS_FREE(sn, sizeof(*sn));
atomic_dec(&sfw_data.fw_nzombies);
- return;
}
static void
}
LBUG();
- return;
}
static int
spin_unlock(&sfw_data.fw_lock);
sfw_destroy_session(sn);
- return;
}
static void
}
sfw_test_unit_done(tsu);
- return;
}
int
}
LBUG ();
- return;
}
void
spin_lock(&rpc->crpc_lock);
srpc_abort_rpc(rpc, -EINTR);
spin_unlock(&rpc->crpc_lock);
- return;
}
void
srpc_post_rpc(rpc);
spin_unlock(&rpc->crpc_lock);
- return;
}
static struct srpc_service sfw_services[] = {
list_del(&tsc->tsc_list);
LIBCFS_FREE(tsc, sizeof(*tsc));
}
-
- return;
}
CDEBUG(D_NET, "%d reply in %llu nsec\n", reply->pnr_seq,
(u64)((ts.tv_sec - reqst->pnr_time_sec) * NSEC_PER_SEC +
(ts.tv_nsec - reqst->pnr_time_nsec)));
- return;
}
static int
}
LIBCFS_FREE(bk, offsetof(struct srpc_bulk, bk_iovs[bk->bk_niov]));
- return;
}
struct srpc_bulk *
}
spin_unlock(&scd->scd_lock);
- return;
}
/* handles an incoming RPC */
timer->stt_func = srpc_client_rpc_expired;
timer->stt_expires = ktime_get_real_seconds() + rpc->crpc_timeout;
stt_add_timer(timer);
- return;
}
/*
spin_unlock(&rpc->crpc_lock);
(*rpc->crpc_done)(rpc);
- return;
}
/* sends an outgoing RPC */
rpc->crpc_aborted = 1;
rpc->crpc_status = why;
swi_schedule_workitem(&rpc->crpc_wi);
- return;
}
/* called with rpc->crpc_lock held */
srpc_add_client_rpc_timer(rpc);
swi_schedule_workitem(&rpc->crpc_wi);
- return;
}
case SRPC_STATE_NI_INIT:
LNetNIFini();
}
-
- return;
}
} else {
(*rpc->crpc_fini) (rpc);
}
-
- return;
}
static inline void
rpc->crpc_reqstmsg.msg_magic = SRPC_MSG_MAGIC;
rpc->crpc_reqstmsg.msg_version = SRPC_MSG_VERSION;
rpc->crpc_reqstmsg.msg_type = srpc_service2request(service);
- return;
}
static inline const char *
df->tv_sec = tv1->tv_sec - 1 - tv2->tv_sec;
df->tv_usec = tv1->tv_usec + 1000000 - tv2->tv_usec;
-
- return;
}
static void
if (op != 0)
lprocfs_counter_incr(srv_stats, op);
-
- return;
}
/* resource.c - internal */
prev->mode_link = &req->l_sl_mode;
prev->policy_link = &req->l_sl_policy;
EXIT;
- return;
}
/**
ras->ras_stride_length = stride_gap + ras->ras_consecutive_bytes;
RAS_CDEBUG(ras);
- return;
}
static unsigned long
ras->ras_request_index++;
ras->ras_last_read_end = pos + PAGE_SIZE - 1;
spin_unlock(&ras->ras_lock);
- return;
}
int ll_writepage(struct page *vmpage, struct writeback_control *wbc)
mutex_lock(&lov->lov_lock);
atomic_inc(&lov->lov_refcount);
mutex_unlock(&lov->lov_lock);
- return;
}
static void __lov_del_obd(struct obd_device *obd, struct lov_tgt_desc *tgt);
lov_pool_putref(iter->pool);
OBD_FREE_PTR(iter);
}
- return;
}
static int pool_proc_show(struct seq_file *s, void *v)
llog_ctxt_put(aai->aai_ctxt);
EXIT;
- return;
}
static const struct seq_operations mdt_hsm_actions_debugfs_ops = {
struct ptlrpc_request *req = mdt_info_req(mti);
mdt_req_from_lrd(req, mti->mti_reply_data);
- return;
}
/**
rc = dt_xattr_set(env, o, &vbuf, xname, 0, th);
if (rc < 0)
CDEBUG(D_INODE, "Can't set version, rc %d\n", rc);
- return;
}
EXPORT_SYMBOL(dt_version_set);
atomic_read(&obd->obd_refcount));
}
read_unlock(&obd_dev_lock);
- return;
}
/* Search for a client OBD connected to tgt_uuid. If grp_uuid is
print_lustre_cfg(lcfg);
EXIT;
- return;
}
/* used only for compatibility with old on-disk cfg_marker data */
}
EXIT;
- return;
}
/* should never happen, only local_oid_storage_fini should
* drop refcount to zero */
LBUG();
- return;
}
/* after Lustre 2.3 release there may be old file to store last generated FID
lprocfs_free_stats(&client_stat->nid_ldlm_stats);
OBD_FREE_PTR(client_stat);
- return;
}
void lprocfs_free_per_client_stats(struct obd_device *obd)
if (rc)
CERROR("%s: sync returns %d\n", dbgcksum_file_name, rc);
filp_close(filp, NULL);
- return;
}
static int
descr = obj->oo_dir->od_container.ic_descr;
osd_quota_swab((char *)rec, descr->id_rec_size);
-#else
- return;
#endif
}
OBD_FREE(osd_seq, sizeof(*osd_seq));
}
write_unlock(&osl->osl_seq_list_lock);
-
- return;
}
/**
dispose_ctx_list_kr(&freelist);
EXIT;
- return;
}
static
/* request takes one export refcount */
req->rq_export = class_export_get(export);
class_export_rpc_inc(export);
-
- return;
}
/**
dt_obd_name(dt), reply, index, 0);
object_update_result_insert(reply, NULL, 0, index, 0);
- return;
}
typedef void (*out_reconstruct_t)(const struct lu_env *env,
if (rc)
CERROR("%s: sync returns %d\n", dbgcksum_file_name, rc);
filp_close(filp, NULL);
- return;
}
static int check_read_checksum(struct niobuf_local *local_nb, int npages,
{
/* don't exit on SIGHUP */
printerr(1, "Received SIGHUP... Ignoring.\n");
- return;
}
static void
}
out:
close(fd);
- return;
}
/* We couldn't find some subdirectories, but we keep the client
* around in case we get a notification on the directory when the
* subdirectories are created. */
- return;
}
void
sk_free_cred(skc);
cred->lc_mech_cred = NULL;
free(cred->lc_mech_token.value);
- return;
}
/**
for (i = 0; i < MAX_MGSNIDS; i++)
config->skc_mgsnids[i] = htobe64(config->skc_mgsnids[i]);
-
- return;
}
/**
for (i = 0; i < MAX_MGSNIDS; i++)
config->skc_mgsnids[i] = be64toh(config->skc_mgsnids[i]);
-
- return;
}
/**
dup2(tempfd, 2);
closeall(3);
}
-
- return;
}
static void
{
/* don't exit on SIGHUP */
printerr(1, "Received SIGHUP... Ignoring.\n");
- return;
}
static void
out_free:
if (json_items != NULL)
llapi_json_destroy_list(&json_items);
-
- return;
}
/** Register a copytool
free(llog_buf);
if (recs_buf != NULL)
free(recs_buf);
- return;
}
void print_llog_header(struct llog_log_hdr *llog_buf)
/* Add the other info you want to view here */
printf("-----------------------\n");
- return;
}
static void print_1_cfg(struct lustre_cfg *lcfg)
for (i = 0; i < lcfg->lcfg_bufcount; i++)
printf("%d:%.*s ", i, lcfg->lcfg_buflens[i],
(char*)lustre_cfg_buf(lcfg, i));
- return;
}
static char *lustre_cfg_string(struct lustre_cfg *lcfg, __u32 index)
printf("setup ");
print_1_cfg(lcfg);
}
-
- return;
}
void print_lustre_cfg(struct lustre_cfg *lcfg, int *skip)
printf("unsupported cmd_code = %x\n",cmd);
}
printf("\n");
- return;
}
static void print_hsm_action(struct llog_agent_req_rec *larr)
/* Open-by-FID path is <mntpt>/.lustre/fid/[SEQ:OID:VER] */
snprintf(buf, bufsize, "%s/%s/fid/%s", mntpt, dot_lustre_name,
fidstr);
- return;
}
/* Read the symlink information into 'info->link' */
snprintf(backupfile, sizeof(backupfile), "%s.old", statuslog);
(void) rename(statuslog, backupfile);
logbackedup = 1;
-
- return;
}
/* Save replication parameters to a statuslog. */
"\t\t\texit\n"
"\t\t--quiet\n",
(int)sizeof(((struct lustre_disk_data *)0)->ldd_userdata));
- return;
}
/* ==================== Lustre config functions =============*/
printf("Total: total %ju threads %d sec %f %f/second\n",
(uintmax_t)total, total_threads, secs, total / secs);
-
- return;
}
static void shmem_snap(int total_threads, int live_threads)
execvp(cmd[0], cmd);
report("failed to execvp(\'%s %s\')",cmd[0],cmd[1]);
}
- return;
}
/*****************************************************************************
DEBUGMSGTL(("lsnmpd", "%s\n", buf));
fprintf(stderr, "%s\n", buf);
- return;
}