int osd_procfs_fini(struct osd_device *osd)
{
if (osd->od_stats)
lprocfs_free_stats(&osd->od_stats);
if (osd->od_proc_entry)
lprocfs_remove(&osd->od_proc_entry);
RETURN(0);
}
static void ldlm_namespace_debugfs_unregister(struct ldlm_namespace *ns)
{
if (IS_ERR_OR_NULL(ns->ns_debugfs_entry))
CERROR("dlm namespace %s has no procfs dir?\n",
ldlm_ns_name(ns));
else
ldebugfs_remove(&ns->ns_debugfs_entry);
if (ns->ns_stats)
lprocfs_free_stats(&ns->ns_stats);
}
int lquota_proc_cleanup(struct lustre_quota_ctxt *qctxt)
{
if (!qctxt || !qctxt->lqc_proc_dir)
return -EINVAL;
if (qctxt->lqc_stats != NULL)
lprocfs_free_stats(&qctxt->lqc_stats);
lprocfs_remove(&qctxt->lqc_proc_dir);
return 0;
}
void ldlm_namespace_proc_unregister(struct ldlm_namespace *ns)
{
if (ns->ns_proc_dir_entry == NULL)
CERROR("dlm namespace %s has no procfs dir?\n",
ldlm_ns_name(ns));
else
lprocfs_remove(&ns->ns_proc_dir_entry);
if (ns->ns_stats != NULL)
lprocfs_free_stats(&ns->ns_stats);
}
static void lprocfs_free_client_stats(struct nid_stat *client_stat)
{
CDEBUG(D_CONFIG, "stat %p - data %p/%p\n", client_stat,
client_stat->nid_proc, client_stat->nid_stats);
LASSERTF(atomic_read(&client_stat->nid_exp_ref_count) == 0,
"nid %s:count %d\n", libcfs_nid2str(client_stat->nid),
atomic_read(&client_stat->nid_exp_ref_count));
if (client_stat->nid_proc)
lprocfs_remove(&client_stat->nid_proc);
if (client_stat->nid_stats)
lprocfs_free_stats(&client_stat->nid_stats);
if (client_stat->nid_ldlm_stats)
lprocfs_free_stats(&client_stat->nid_ldlm_stats);
OBD_FREE_PTR(client_stat);
return;
}
int osd_procfs_fini(struct osd_device *osd)
{
ENTRY;
if (osd->od_stats)
lprocfs_free_stats(&osd->od_stats);
if (osd->od_proc_entry) {
lprocfs_remove(&osd->od_proc_entry);
osd->od_proc_entry = NULL;
}
RETURN(0);
}
void ldlm_namespace_proc_unregister(struct ldlm_namespace *ns)
{
struct proc_dir_entry *dir;
dir = lprocfs_srch(ldlm_ns_proc_dir, ldlm_ns_name(ns));
if (dir == NULL) {
CERROR("dlm namespace %s has no procfs dir?\n",
ldlm_ns_name(ns));
} else {
lprocfs_remove(&dir);
}
if (ns->ns_stats != NULL)
lprocfs_free_stats(&ns->ns_stats);
}
/**
* 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);
}
/**
* 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 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;
}
void lprocfs_free_obd_stats(struct obd_device *obd)
{
if (obd->obd_stats)
lprocfs_free_stats(&obd->obd_stats);
}
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;
}
}
