int ldlm_namespace_proc_register(struct ldlm_namespace *ns)
{
struct lprocfs_vars lock_vars[2];
char lock_name[MAX_STRING_SIZE + 1];
proc_dir_entry_t *ns_pde;
LASSERT(ns != NULL);
LASSERT(ns->ns_rs_hash != NULL);
if (ns->ns_proc_dir_entry != NULL) {
ns_pde = ns->ns_proc_dir_entry;
} else {
ns_pde = proc_mkdir(ldlm_ns_name(ns), ldlm_ns_proc_dir);
if (ns_pde == NULL)
return -ENOMEM;
ns->ns_proc_dir_entry = ns_pde;
}
ns->ns_stats = lprocfs_alloc_stats(LDLM_NSS_LAST, 0);
if (ns->ns_stats == NULL)
return -ENOMEM;
lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS,
LPROCFS_CNTR_AVGMINMAX, "locks", "locks");
lock_name[MAX_STRING_SIZE] = '\0';
memset(lock_vars, 0, sizeof(lock_vars));
lock_vars[0].name = lock_name;
LDLM_NS_ADD_VAR("resource_count", ns, &lprocfs_ns_resources_fops);
LDLM_NS_ADD_VAR("lock_count", ns, &lprocfs_ns_locks_fops);
if (ns_is_client(ns)) {
LDLM_NS_ADD_VAR("lock_unused_count", &ns->ns_nr_unused,
&ldlm_uint_fops);
LDLM_NS_ADD_VAR("lru_size", ns, &lprocfs_lru_size_fops);
LDLM_NS_ADD_VAR("lru_max_age", &ns->ns_max_age,
&ldlm_rw_uint_fops);
LDLM_NS_ADD_VAR("early_lock_cancel", ns, &lprocfs_elc_fops);
} else {
LDLM_NS_ADD_VAR("ctime_age_limit", &ns->ns_ctime_age_limit,
&ldlm_rw_uint_fops);
LDLM_NS_ADD_VAR("lock_timeouts", &ns->ns_timeouts,
&ldlm_uint_fops);
LDLM_NS_ADD_VAR("max_nolock_bytes", &ns->ns_max_nolock_size,
&ldlm_rw_uint_fops);
LDLM_NS_ADD_VAR("contention_seconds", &ns->ns_contention_time,
&ldlm_rw_uint_fops);
LDLM_NS_ADD_VAR("contended_locks", &ns->ns_contended_locks,
&ldlm_rw_uint_fops);
LDLM_NS_ADD_VAR("max_parallel_ast", &ns->ns_max_parallel_ast,
&ldlm_rw_uint_fops);
}
return 0;
}
static int osd_stats_init(struct osd_device *osd)
{
int result;
ENTRY;
osd->od_stats = lprocfs_alloc_stats(LPROC_OSD_LAST, 0);
if (osd->od_stats != NULL) {
result = lprocfs_register_stats(osd->od_proc_entry, "stats",
osd->od_stats);
if (result)
GOTO(out, result);
lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE,
LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV,
"get_page", "usec");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_NO_PAGE,
LPROCFS_CNTR_AVGMINMAX,
"get_page_failures", "num");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_ACCESS,
LPROCFS_CNTR_AVGMINMAX,
"cache_access", "pages");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_HIT,
LPROCFS_CNTR_AVGMINMAX,
"cache_hit", "pages");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_MISS,
LPROCFS_CNTR_AVGMINMAX,
"cache_miss", "pages");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_COPY_IO,
LPROCFS_CNTR_AVGMINMAX,
"copy", "pages");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_ZEROCOPY_IO,
LPROCFS_CNTR_AVGMINMAX,
"zerocopy", "pages");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_TAIL_IO,
LPROCFS_CNTR_AVGMINMAX,
"tail", "pages");
#ifdef OSD_THANDLE_STATS
lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_STARTING,
LPROCFS_CNTR_AVGMINMAX,
"thandle_starting", "usec");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_OPEN,
LPROCFS_CNTR_AVGMINMAX,
"thandle_open", "usec");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_CLOSING,
LPROCFS_CNTR_AVGMINMAX,
"thandle_closing", "usec");
#endif
result = lprocfs_seq_create(osd->od_proc_entry, "brw_stats",
0644, &osd_brw_stats_fops, osd);
} else {
result = -ENOMEM;
}
out:
RETURN(result);
}
static int osd_stats_init(struct osd_device *osd)
{
int i, result;
ENTRY;
for (i = 0; i < BRW_LAST; i++)
spin_lock_init(&osd->od_brw_stats.hist[i].oh_lock);
osd->od_stats = lprocfs_alloc_stats(LPROC_OSD_LAST, 0);
if (osd->od_stats != NULL) {
result = lprocfs_register_stats(osd->od_proc_entry, "stats",
osd->od_stats);
if (result)
GOTO(out, result);
lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE,
LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV,
"get_page", "usec");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_NO_PAGE,
LPROCFS_CNTR_AVGMINMAX,
"get_page_failures", "num");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_ACCESS,
LPROCFS_CNTR_AVGMINMAX,
"cache_access", "pages");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_HIT,
LPROCFS_CNTR_AVGMINMAX,
"cache_hit", "pages");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_MISS,
LPROCFS_CNTR_AVGMINMAX,
"cache_miss", "pages");
#if OSD_THANDLE_STATS
lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_STARTING,
LPROCFS_CNTR_AVGMINMAX,
"thandle starting", "usec");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_OPEN,
LPROCFS_CNTR_AVGMINMAX,
"thandle open", "usec");
lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_CLOSING,
LPROCFS_CNTR_AVGMINMAX,
"thandle closing", "usec");
#endif
result = lprocfs_seq_create(osd->od_proc_entry, "brw_stats",
0644, &osd_brw_stats_fops, osd);
} else
result = -ENOMEM;
out:
RETURN(result);
}
int mdt_export_stats_init(struct obd_device *obd,
struct obd_export *exp,
void *localdata)
{
lnet_nid_t *client_nid = localdata;
int rc, newnid;
ENTRY;
LASSERT(!obd->obd_uses_nid_stats);
rc = lprocfs_exp_setup(exp, client_nid, &newnid);
if (rc) {
/* Mask error for already created
* /proc entries */
if (rc == -EALREADY)
rc = 0;
RETURN(rc);
}
if (newnid) {
struct nid_stat *tmp = exp->exp_nid_stats;
tmp->nid_stats = lprocfs_alloc_stats(LPROC_MDT_LAST,
LPROCFS_STATS_FLAG_NOPERCPU);
if (tmp->nid_stats == NULL)
RETURN(-ENOMEM);
mdt_stats_counter_init(tmp->nid_stats);
rc = lprocfs_register_stats(tmp->nid_proc, "stats",
tmp->nid_stats);
if (rc)
GOTO(clean, rc);
rc = lprocfs_nid_ldlm_stats_init(tmp);
if (rc)
GOTO(clean, rc);
rc = lprocfs_seq_create(tmp->nid_proc, "open_files",
0444, &mdt_open_files_seq_fops, tmp);
if (rc) {
CWARN("%s: error adding the open_files file: rc = %d\n",
obd->obd_name, rc);
GOTO(clean, rc);
}
}
RETURN(0);
clean:
return rc;
}
/**
* Initialize OFD per-export statistics.
*
* This function sets up procfs entries for various OFD export counters. These
* counters are for per-client statistics tracked on the server.
*
* \param[in] ofd OFD device
* \param[in] exp OBD export
* \param[in] client_nid NID of client
*
* \retval 0 if successful
* \retval negative value on error
*/
static int ofd_export_stats_init(struct ofd_device *ofd,
struct obd_export *exp,
lnet_nid_t *client_nid)
{
struct obd_device *obd = ofd_obd(ofd);
struct nid_stat *stats;
int rc;
ENTRY;
LASSERT(obd->obd_uses_nid_stats);
if (obd_uuid_equals(&exp->exp_client_uuid, &obd->obd_uuid))
/* Self-export gets no proc entry */
RETURN(0);
rc = lprocfs_exp_setup(exp, client_nid);
if (rc != 0)
/* Mask error for already created /proc entries */
RETURN(rc == -EALREADY ? 0 : rc);
stats = exp->exp_nid_stats;
stats->nid_stats = lprocfs_alloc_stats(NUM_OBD_STATS +
LPROC_OFD_STATS_LAST,
LPROCFS_STATS_FLAG_NOPERCPU);
if (stats->nid_stats == NULL)
RETURN(-ENOMEM);
lprocfs_init_ops_stats(LPROC_OFD_STATS_LAST, stats->nid_stats);
ofd_stats_counter_init(stats->nid_stats);
rc = lprocfs_register_stats(stats->nid_proc, "stats", stats->nid_stats);
if (rc != 0) {
lprocfs_free_stats(&stats->nid_stats);
GOTO(out, rc);
}
rc = lprocfs_nid_ldlm_stats_init(stats);
if (rc != 0)
GOTO(out, rc);
out:
RETURN(rc);
}
static int ldlm_namespace_sysfs_register(struct ldlm_namespace *ns)
{
int err;
ns->ns_kobj.kset = ldlm_ns_kset;
init_completion(&ns->ns_kobj_unregister);
err = kobject_init_and_add(&ns->ns_kobj, &ldlm_ns_ktype, NULL,
"%s", ldlm_ns_name(ns));
ns->ns_stats = lprocfs_alloc_stats(LDLM_NSS_LAST, 0);
if (!ns->ns_stats) {
kobject_put(&ns->ns_kobj);
return -ENOMEM;
}
lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS,
LPROCFS_CNTR_AVGMINMAX, "locks", "locks");
return err;
}
/**
* Initialize MDT per-export statistics.
*
* This function sets up procfs entries for various MDT export counters. These
* counters are for per-client statistics tracked on the server.
*
* \param[in] obd OBD device
* \param[in] exp OBD export
* \param[in] localdata NID of client
*
* \retval 0 if successful
* \retval negative value on error
*/
int mdt_export_stats_init(struct obd_device *obd, struct obd_export *exp,
void *localdata)
{
lnet_nid_t *client_nid = localdata;
struct nid_stat *stats;
int rc;
ENTRY;
rc = lprocfs_exp_setup(exp, client_nid);
if (rc != 0)
/* Mask error for already created /proc entries */
RETURN(rc == -EALREADY ? 0 : rc);
stats = exp->exp_nid_stats;
stats->nid_stats = lprocfs_alloc_stats(LPROC_MDT_LAST,
LPROCFS_STATS_FLAG_NOPERCPU);
if (stats->nid_stats == NULL)
RETURN(-ENOMEM);
mdt_stats_counter_init(stats->nid_stats);
rc = lprocfs_register_stats(stats->nid_proc, "stats", stats->nid_stats);
if (rc != 0) {
lprocfs_free_stats(&stats->nid_stats);
GOTO(out, rc);
}
rc = lprocfs_nid_ldlm_stats_init(stats);
if (rc != 0)
GOTO(out, rc);
rc = lprocfs_seq_create(stats->nid_proc, "open_files",
0444, &mdt_open_files_seq_fops, stats);
if (rc != 0) {
CWARN("%s: error adding the open_files file: rc = %d\n",
obd->obd_name, rc);
GOTO(out, rc);
}
out:
RETURN(rc);
}
int mgs_export_stats_init(struct obd_device *obd, struct obd_export *exp,
void *localdata)
{
lnet_nid_t *client_nid = localdata;
int rc, newnid;
ENTRY;
rc = lprocfs_exp_setup(exp, client_nid, &newnid);
if (rc) {
/* Mask error for already created
* /proc entries */
if (rc == -EALREADY)
rc = 0;
RETURN(rc);
}
if (newnid) {
struct nid_stat *tmp = exp->exp_nid_stats;
int num_stats = 0;
num_stats = (sizeof(*obd->obd_type->typ_dt_ops) / sizeof(void *)) +
LPROC_MGS_LAST - 1;
tmp->nid_stats = lprocfs_alloc_stats(num_stats,
LPROCFS_STATS_FLAG_NOPERCPU);
if (tmp->nid_stats == NULL)
return -ENOMEM;
lprocfs_init_ops_stats(LPROC_MGS_LAST, tmp->nid_stats);
mgs_stats_counter_init(tmp->nid_stats);
rc = lprocfs_register_stats(tmp->nid_proc, "stats",
tmp->nid_stats);
if (rc)
GOTO(clean, rc);
rc = lprocfs_nid_ldlm_stats_init(tmp);
if (rc)
GOTO(clean, rc);
}
RETURN(0);
clean:
return rc;
}
int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats)
{
struct lprocfs_stats *stats;
unsigned int num_stats;
int rc, i;
LASSERT(obd->obd_stats == NULL);
LASSERT(obd->obd_proc_entry != NULL);
LASSERT(obd->obd_cntr_base == 0);
num_stats = NUM_OBD_STATS + num_private_stats;
stats = lprocfs_alloc_stats(num_stats, 0);
if (stats == NULL)
return -ENOMEM;
lprocfs_init_ops_stats(num_private_stats, stats);
for (i = num_private_stats; i < num_stats; i++) {
/* If this LBUGs, it is likely that an obd
* operation was added to struct obd_ops in
* <obd.h>, and that the corresponding line item
* LPROCFS_OBD_OP_INIT(.., .., opname)
* is missing from the list above. */
LASSERTF(stats->ls_cnt_header[i].lc_name != NULL,
"Missing obd_stat initializer obd_op "
"operation at offset %d.\n", i - num_private_stats);
}
rc = lprocfs_register_stats(obd->obd_proc_entry, "stats", stats);
if (rc < 0) {
lprocfs_free_stats(&stats);
} else {
obd->obd_stats = stats;
obd->obd_cntr_base = num_private_stats;
}
return rc;
}
int lquota_proc_setup(struct obd_device *obd, int is_master)
{
struct lustre_quota_ctxt *qctxt = &obd->u.obt.obt_qctxt;
int rc = 0;
ENTRY;
LASSERT(lquota_type_proc_dir && obd);
qctxt->lqc_proc_dir = lprocfs_register(obd->obd_name,
lquota_type_proc_dir,
lprocfs_quota_common_vars, obd);
if (IS_ERR(qctxt->lqc_proc_dir)) {
rc = PTR_ERR(qctxt->lqc_proc_dir);
CERROR("%s: error %d setting up lprocfs\n",
obd->obd_name, rc);
qctxt->lqc_proc_dir = NULL;
GOTO(out, rc);
}
if (is_master) {
rc = lprocfs_add_vars(qctxt->lqc_proc_dir,
lprocfs_quota_master_vars, obd);
if (rc) {
CERROR("%s: error %d setting up lprocfs for "
"quota master\n", obd->obd_name, rc);
GOTO(out_free_proc, rc);
}
}
qctxt->lqc_stats = lprocfs_alloc_stats(LQUOTA_LAST_STAT -
LQUOTA_FIRST_STAT, 0);
if (!qctxt->lqc_stats)
GOTO(out_free_proc, rc = -ENOMEM);
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_SYNC_ACQ,
LPROCFS_CNTR_AVGMINMAX, "sync_acq_req", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_SYNC_REL,
LPROCFS_CNTR_AVGMINMAX, "sync_rel_req", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_ASYNC_ACQ,
LPROCFS_CNTR_AVGMINMAX, "async_acq_req", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_ASYNC_REL,
LPROCFS_CNTR_AVGMINMAX, "async_rel_req", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_WAIT_FOR_CHK_BLK,
LPROCFS_CNTR_AVGMINMAX,
"wait_for_blk_quota(lquota_chkquota)", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_WAIT_FOR_CHK_INO,
LPROCFS_CNTR_AVGMINMAX,
"wait_for_ino_quota(lquota_chkquota)", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_WAIT_FOR_COMMIT_BLK,
LPROCFS_CNTR_AVGMINMAX,
"wait_for_blk_quota(lquota_pending_commit)",
"us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_WAIT_FOR_COMMIT_INO,
LPROCFS_CNTR_AVGMINMAX,
"wait_for_ino_quota(lquota_pending_commit)",
"us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_WAIT_PENDING_BLK_QUOTA,
LPROCFS_CNTR_AVGMINMAX,
"wait_for_pending_blk_quota_req"
"(qctxt_wait_pending_dqacq)", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_WAIT_PENDING_INO_QUOTA,
LPROCFS_CNTR_AVGMINMAX,
"wait_for_pending_ino_quota_req"
"(qctxt_wait_pending_dqacq)", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_NOWAIT_PENDING_BLK_QUOTA,
LPROCFS_CNTR_AVGMINMAX,
"nowait_for_pending_blk_quota_req"
"(qctxt_wait_pending_dqacq)", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_NOWAIT_PENDING_INO_QUOTA,
LPROCFS_CNTR_AVGMINMAX,
"nowait_for_pending_ino_quota_req"
"(qctxt_wait_pending_dqacq)", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_QUOTA_CTL,
LPROCFS_CNTR_AVGMINMAX, "quota_ctl", "us");
lprocfs_counter_init(qctxt->lqc_stats, LQUOTA_ADJUST_QUNIT,
LPROCFS_CNTR_AVGMINMAX, "adjust_qunit", "us");
lprocfs_register_stats(qctxt->lqc_proc_dir, "stats", qctxt->lqc_stats);
RETURN(rc);
out_free_proc:
lprocfs_remove(&qctxt->lqc_proc_dir);
out:
RETURN(rc);
}
int ldlm_namespace_proc_register(struct ldlm_namespace *ns)
{
struct lprocfs_vars lock_vars[2];
char lock_name[MAX_STRING_SIZE + 1];
LASSERT(ns != NULL);
LASSERT(ns->ns_rs_hash != NULL);
ns->ns_stats = lprocfs_alloc_stats(LDLM_NSS_LAST, 0);
if (ns->ns_stats == NULL)
return -ENOMEM;
lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS,
LPROCFS_CNTR_AVGMINMAX, "locks", "locks");
lock_name[MAX_STRING_SIZE] = '\0';
memset(lock_vars, 0, sizeof(lock_vars));
lock_vars[0].name = lock_name;
snprintf(lock_name, MAX_STRING_SIZE, "%s/resource_count",
ldlm_ns_name(ns));
lock_vars[0].data = ns;
lock_vars[0].read_fptr = lprocfs_rd_ns_resources;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_count",
ldlm_ns_name(ns));
lock_vars[0].data = ns;
lock_vars[0].read_fptr = lprocfs_rd_ns_locks;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
if (ns_is_client(ns)) {
snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_unused_count",
ldlm_ns_name(ns));
lock_vars[0].data = &ns->ns_nr_unused;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/lru_size",
ldlm_ns_name(ns));
lock_vars[0].data = ns;
lock_vars[0].read_fptr = lprocfs_rd_lru_size;
lock_vars[0].write_fptr = lprocfs_wr_lru_size;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/lru_max_age",
ldlm_ns_name(ns));
lock_vars[0].data = &ns->ns_max_age;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lock_vars[0].write_fptr = lprocfs_wr_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/early_lock_cancel",
ldlm_ns_name(ns));
lock_vars[0].data = ns;
lock_vars[0].read_fptr = lprocfs_rd_elc;
lock_vars[0].write_fptr = lprocfs_wr_elc;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
} else {
snprintf(lock_name, MAX_STRING_SIZE, "%s/ctime_age_limit",
ldlm_ns_name(ns));
lock_vars[0].data = &ns->ns_ctime_age_limit;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lock_vars[0].write_fptr = lprocfs_wr_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_timeouts",
ldlm_ns_name(ns));
lock_vars[0].data = &ns->ns_timeouts;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/max_nolock_bytes",
ldlm_ns_name(ns));
lock_vars[0].data = &ns->ns_max_nolock_size;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lock_vars[0].write_fptr = lprocfs_wr_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/contention_seconds",
ldlm_ns_name(ns));
lock_vars[0].data = &ns->ns_contention_time;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lock_vars[0].write_fptr = lprocfs_wr_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/contended_locks",
ldlm_ns_name(ns));
lock_vars[0].data = &ns->ns_contended_locks;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lock_vars[0].write_fptr = lprocfs_wr_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
snprintf(lock_name, MAX_STRING_SIZE, "%s/max_parallel_ast",
ldlm_ns_name(ns));
lock_vars[0].data = &ns->ns_max_parallel_ast;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lock_vars[0].write_fptr = lprocfs_wr_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
}
return 0;
}
static void
ptlrpc_ldebugfs_register(struct dentry *root, char *dir,
char *name,
struct dentry **debugfs_root_ret,
struct lprocfs_stats **stats_ret)
{
struct dentry *svc_debugfs_entry;
struct lprocfs_stats *svc_stats;
int i, rc;
unsigned int svc_counter_config = LPROCFS_CNTR_AVGMINMAX |
LPROCFS_CNTR_STDDEV;
LASSERT(!*debugfs_root_ret);
LASSERT(!*stats_ret);
svc_stats = lprocfs_alloc_stats(EXTRA_MAX_OPCODES+LUSTRE_MAX_OPCODES,
0);
if (!svc_stats)
return;
if (dir) {
svc_debugfs_entry = ldebugfs_register(dir, root, NULL, NULL);
if (IS_ERR(svc_debugfs_entry)) {
lprocfs_free_stats(&svc_stats);
return;
}
} else {
svc_debugfs_entry = root;
}
lprocfs_counter_init(svc_stats, PTLRPC_REQWAIT_CNTR,
svc_counter_config, "req_waittime", "usec");
lprocfs_counter_init(svc_stats, PTLRPC_REQQDEPTH_CNTR,
svc_counter_config, "req_qdepth", "reqs");
lprocfs_counter_init(svc_stats, PTLRPC_REQACTIVE_CNTR,
svc_counter_config, "req_active", "reqs");
lprocfs_counter_init(svc_stats, PTLRPC_TIMEOUT,
svc_counter_config, "req_timeout", "sec");
lprocfs_counter_init(svc_stats, PTLRPC_REQBUF_AVAIL_CNTR,
svc_counter_config, "reqbuf_avail", "bufs");
for (i = 0; i < EXTRA_LAST_OPC; i++) {
char *units;
switch (i) {
case BRW_WRITE_BYTES:
case BRW_READ_BYTES:
units = "bytes";
break;
default:
units = "reqs";
break;
}
lprocfs_counter_init(svc_stats, PTLRPC_LAST_CNTR + i,
svc_counter_config,
ll_eopcode2str(i), units);
}
for (i = 0; i < LUSTRE_MAX_OPCODES; i++) {
__u32 opcode = ll_rpc_opcode_table[i].opcode;
lprocfs_counter_init(svc_stats,
EXTRA_MAX_OPCODES + i, svc_counter_config,
ll_opcode2str(opcode), "usec");
}
rc = ldebugfs_register_stats(svc_debugfs_entry, name, svc_stats);
if (rc < 0) {
if (dir)
ldebugfs_remove(&svc_debugfs_entry);
lprocfs_free_stats(&svc_stats);
} else {
if (dir)
*debugfs_root_ret = svc_debugfs_entry;
*stats_ret = svc_stats;
}
}
