static int seq_client_proc_init(struct lu_client_seq *seq)
{
#ifdef CONFIG_PROC_FS
int rc;
ENTRY;
seq->lcs_proc_dir = lprocfs_register(seq->lcs_name, seq_type_proc_dir,
NULL, NULL);
if (IS_ERR(seq->lcs_proc_dir)) {
CERROR("%s: LProcFS failed in seq-init\n",
seq->lcs_name);
rc = PTR_ERR(seq->lcs_proc_dir);
RETURN(rc);
}
rc = lprocfs_add_vars(seq->lcs_proc_dir, seq_client_proc_list, seq);
if (rc) {
CERROR("%s: Can't init sequence manager "
"proc, rc %d\n", seq->lcs_name, rc);
GOTO(out_cleanup, rc);
}
RETURN(0);
out_cleanup:
seq_client_proc_fini(seq);
return rc;
#else /* !CONFIG_PROC_FS */
return 0;
#endif /* CONFIG_PROC_FS */
}
static int seq_client_proc_init(struct lu_client_seq *seq)
{
#if defined (CONFIG_PROC_FS)
int rc;
seq->lcs_proc_dir = lprocfs_register(seq->lcs_name,
seq_type_proc_dir,
NULL, NULL);
if (IS_ERR(seq->lcs_proc_dir)) {
CERROR("%s: LProcFS failed in seq-init\n",
seq->lcs_name);
rc = PTR_ERR(seq->lcs_proc_dir);
return rc;
}
rc = lprocfs_add_vars(seq->lcs_proc_dir,
seq_client_proc_list, seq);
if (rc) {
CERROR("%s: Can't init sequence manager proc, rc %d\n",
seq->lcs_name, rc);
goto out_cleanup;
}
return 0;
out_cleanup:
seq_client_proc_fini(seq);
return rc;
#else /* CONFIG_PROC_FS */
return 0;
#endif
}
static int seq_server_proc_init(struct lu_server_seq *seq)
{
int rc;
ENTRY;
seq->lss_proc_dir = lprocfs_register(seq->lss_name,
seq_type_proc_dir,
NULL, NULL);
if (IS_ERR(seq->lss_proc_dir)) {
rc = PTR_ERR(seq->lss_proc_dir);
RETURN(rc);
}
rc = lprocfs_add_vars(seq->lss_proc_dir,
seq_server_proc_list, seq);
if (rc) {
CERROR("%s: Can't init sequence manager "
"proc, rc %d\n", seq->lss_name, rc);
GOTO(out_cleanup, rc);
}
RETURN(0);
out_cleanup:
seq_server_proc_fini(seq);
return rc;
}
int ldlm_proc_setup(void)
{
int rc;
struct lprocfs_vars list[] = {
{ "dump_namespaces", &ldlm_dump_ns_fops, 0, 0222 },
{ "dump_granted_max", &ldlm_rw_uint_fops,
&ldlm_dump_granted_max },
{ "cancel_unused_locks_before_replay", &ldlm_rw_uint_fops,
&ldlm_cancel_unused_locks_before_replay },
{ NULL }};
ENTRY;
LASSERT(ldlm_ns_proc_dir == NULL);
ldlm_type_proc_dir = lprocfs_register(OBD_LDLM_DEVICENAME,
proc_lustre_root,
NULL, NULL);
if (IS_ERR(ldlm_type_proc_dir)) {
CERROR("LProcFS failed in ldlm-init\n");
rc = PTR_ERR(ldlm_type_proc_dir);
GOTO(err, rc);
}
ldlm_ns_proc_dir = lprocfs_register("namespaces",
ldlm_type_proc_dir,
NULL, NULL);
if (IS_ERR(ldlm_ns_proc_dir)) {
CERROR("LProcFS failed in ldlm-init\n");
rc = PTR_ERR(ldlm_ns_proc_dir);
GOTO(err_type, rc);
}
ldlm_svc_proc_dir = lprocfs_register("services",
ldlm_type_proc_dir,
NULL, NULL);
if (IS_ERR(ldlm_svc_proc_dir)) {
CERROR("LProcFS failed in ldlm-init\n");
rc = PTR_ERR(ldlm_svc_proc_dir);
GOTO(err_ns, rc);
}
rc = lprocfs_add_vars(ldlm_type_proc_dir, list, NULL);
RETURN(0);
err_ns:
lprocfs_remove(&ldlm_ns_proc_dir);
err_type:
lprocfs_remove(&ldlm_type_proc_dir);
err:
ldlm_svc_proc_dir = NULL;
ldlm_type_proc_dir = NULL;
ldlm_ns_proc_dir = NULL;
RETURN(rc);
}
void osp_lprocfs_init(struct osp_device *osp)
{
struct obd_device *obd = osp->opd_obd;
struct proc_dir_entry *osc_proc_dir;
int rc;
obd->obd_proc_entry = lprocfs_register(obd->obd_name,
obd->obd_type->typ_procroot,
lprocfs_osp_osd_vars,
&osp->opd_dt_dev);
if (IS_ERR(obd->obd_proc_entry)) {
CERROR("%s: can't register in lprocfs: %ld\n",
obd->obd_name, PTR_ERR(obd->obd_proc_entry));
obd->obd_proc_entry = NULL;
return;
}
rc = lprocfs_add_vars(obd->obd_proc_entry, lprocfs_osp_obd_vars, obd);
if (rc) {
CERROR("%s: can't register in lprocfs: %ld\n",
obd->obd_name, PTR_ERR(obd->obd_proc_entry));
return;
}
ptlrpc_lprocfs_register_obd(obd);
/* for compatibility we link old procfs's OSC entries to osp ones */
if (!osp->opd_connect_mdt) {
osc_proc_dir = lprocfs_srch(proc_lustre_root, "osc");
if (osc_proc_dir) {
cfs_proc_dir_entry_t *symlink = NULL;
char *name;
OBD_ALLOC(name, strlen(obd->obd_name) + 1);
if (name == NULL)
return;
strcpy(name, obd->obd_name);
if (strstr(name, "osc"))
symlink = lprocfs_add_symlink(name,
osc_proc_dir, "../osp/%s",
obd->obd_name);
OBD_FREE(name, strlen(obd->obd_name) + 1);
osp->opd_symlink = symlink;
}
}
}
static int seq_server_proc_init(struct lu_server_seq *seq)
{
#ifdef CONFIG_PROC_FS
int rc;
ENTRY;
seq->lss_proc_dir = lprocfs_register(seq->lss_name,
seq_type_proc_dir,
NULL, NULL);
if (IS_ERR(seq->lss_proc_dir)) {
rc = PTR_ERR(seq->lss_proc_dir);
RETURN(rc);
}
rc = lprocfs_add_vars(seq->lss_proc_dir, seq_server_proc_list, seq);
if (rc) {
CERROR("%s: Can't init sequence manager "
"proc, rc %d\n", seq->lss_name, rc);
GOTO(out_cleanup, rc);
}
if (seq->lss_type == LUSTRE_SEQ_CONTROLLER) {
rc = lprocfs_seq_create(seq->lss_proc_dir, "fldb", 0644,
&seq_fld_proc_seq_fops, seq);
if (rc) {
CERROR("%s: Can't create fldb for sequence manager "
"proc: rc = %d\n", seq->lss_name, rc);
GOTO(out_cleanup, rc);
}
}
RETURN(0);
out_cleanup:
seq_server_proc_fini(seq);
return rc;
#else /* !CONFIG_PROC_FS */
return 0;
#endif /* CONFIG_PROC_FS */
}
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;
}
