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; } }