* This feature is commonly referred to as lru_resize.
*/
struct ldlm_pool {
- /** Pool proc directory. */
- struct proc_dir_entry *pl_proc_dir;
+ /** Pool debugfs directory. */
+ struct dentry *pl_debugfs_entry;
/** Pool name, must be long enough to hold compound proc entry name. */
char pl_name[100];
/** Lock for protecting SLV/CLV updates. */
/** Client side original connect flags supported by server. */
__u64 ns_orig_connect_flags;
- /* namespace proc dir entry */
- struct proc_dir_entry *ns_proc_dir_entry;
+ /* namespace debugfs dir entry */
+ struct dentry *ns_debugfs_entry;
/**
* Position in global namespace list linking all namespaces on
enum ldlm_side client);
void ldlm_namespace_get(struct ldlm_namespace *ns);
void ldlm_namespace_put(struct ldlm_namespace *ns);
-int ldlm_proc_setup(void);
-#ifdef CONFIG_PROC_FS
-void ldlm_proc_cleanup(void);
+
+int ldlm_debugfs_setup(void);
+void ldlm_debugfs_cleanup(void);
static inline void ldlm_svc_get_eopc(const struct ldlm_request *dlm_req,
struct lprocfs_stats *srv_stats)
return;
}
-#else
-static inline void ldlm_proc_cleanup(void) {}
-static inline void ldlm_svc_get_eopc(const struct ldlm_request *dlm_req,
- struct lprocfs_stats *srv_stats) {}
-#endif
/* resource.c - internal */
struct ldlm_resource *ldlm_resource_get(struct ldlm_namespace *ns,
int srv_nthrs_cpt_init;
/** limit of threads number for each partition */
int srv_nthrs_cpt_limit;
- /** Root of /proc dir tree for this service */
- struct proc_dir_entry *srv_procroot;
+ /** Root of debugfs dir tree for this service */
+ struct dentry *srv_debugfs_entry;
/** Pointer to statistic data for this service */
struct lprocfs_stats *srv_stats;
/** # hp per lp reqs to handle */
struct ptlrpc_service *ptlrpc_register_service(
struct ptlrpc_service_conf *conf,
struct kset *parent,
- struct proc_dir_entry *proc_entry);
+ struct dentry *debugfs_entry);
void ptlrpc_stop_all_threads(struct ptlrpc_service *svc);
int ptlrpc_start_threads(struct ptlrpc_service *svc);
struct dentry *obd_debugfs_entry;
struct proc_dir_entry *obd_proc_entry;
struct proc_dir_entry *obd_proc_exports_entry;
- struct proc_dir_entry *obd_svc_procroot;
+ struct dentry *obd_svc_debugfs_entry;
struct lprocfs_stats *obd_svc_stats;
struct attribute_group obd_attrs_group;
struct attribute **obd_attrs;
void l_check_ns_lock(struct ldlm_namespace *ns);
void l_check_no_ns_lock(struct ldlm_namespace *ns);
-extern struct proc_dir_entry *ldlm_svc_proc_dir;
+extern struct dentry *ldlm_svc_debugfs_dir;
struct ldlm_state {
struct ptlrpc_service *ldlm_cb_service;
struct __##var##__dummy_write {; } /* semicolon catcher */
static inline void
-ldlm_add_var(struct lprocfs_vars *vars, struct proc_dir_entry *proc_dir,
+ldlm_add_var(struct lprocfs_vars *vars, struct dentry *debugfs_entry,
const char *name, void *data, const struct file_operations *ops)
{
snprintf((char *)vars->name, MAX_STRING_SIZE, "%s", name);
vars->data = data;
vars->fops = ops;
- lprocfs_add_vars(proc_dir, vars, NULL);
+ ldebugfs_add_vars(debugfs_entry, vars, NULL);
}
static inline int is_granted_or_cancelled(struct ldlm_lock *lock)
if (!ldlm_svc_kset)
GOTO(out, -ENOMEM);
-#ifdef CONFIG_PROC_FS
- rc = ldlm_proc_setup();
+ rc = ldlm_debugfs_setup();
if (rc != 0)
GOTO(out, rc);
-#endif /* CONFIG_PROC_FS */
memset(&conf, 0, sizeof(conf));
conf = (typeof(conf)) {
};
ldlm_state->ldlm_cb_service = \
ptlrpc_register_service(&conf, ldlm_svc_kset,
- ldlm_svc_proc_dir);
+ ldlm_svc_debugfs_dir);
if (IS_ERR(ldlm_state->ldlm_cb_service)) {
CERROR("failed to start service\n");
rc = PTR_ERR(ldlm_state->ldlm_cb_service);
};
ldlm_state->ldlm_cancel_service = \
ptlrpc_register_service(&conf, ldlm_svc_kset,
- ldlm_svc_proc_dir);
+ ldlm_svc_debugfs_dir);
if (IS_ERR(ldlm_state->ldlm_cancel_service)) {
CERROR("failed to start service\n");
rc = PTR_ERR(ldlm_state->ldlm_cancel_service);
kobject_put(ldlm_kobj);
}
- ldlm_proc_cleanup();
+ ldlm_debugfs_cleanup();
#ifdef HAVE_SERVER_SUPPORT
if (expired_lock_thread_state != ELT_STOPPED) {
granted, limit);
return 0;
}
-LPROC_SEQ_FOPS_RO(lprocfs_pool_state);
+
+LDEBUGFS_SEQ_FOPS_RO(lprocfs_pool_state);
static ssize_t grant_speed_show(struct kobject *kobj, struct attribute *attr,
char *buf)
return err;
}
-static int ldlm_pool_proc_init(struct ldlm_pool *pl)
+static int ldlm_pool_debugfs_init(struct ldlm_pool *pl)
{
struct ldlm_namespace *ns = ldlm_pl2ns(pl);
- struct proc_dir_entry *parent_ns_proc;
+ struct dentry *debugfs_ns_parent;
struct lprocfs_vars pool_vars[2];
char *var_name = NULL;
int rc = 0;
if (!var_name)
RETURN(-ENOMEM);
- parent_ns_proc = ns->ns_proc_dir_entry;
- if (parent_ns_proc == NULL) {
- CERROR("%s: proc entry is not initialized\n",
+ debugfs_ns_parent = ns->ns_debugfs_entry;
+ if (IS_ERR_OR_NULL(debugfs_ns_parent)) {
+ CERROR("%s: debugfs entry is not initialized\n",
ldlm_ns_name(ns));
GOTO(out_free_name, rc = -EINVAL);
}
- pl->pl_proc_dir = lprocfs_register("pool", parent_ns_proc,
- NULL, NULL);
- if (IS_ERR(pl->pl_proc_dir)) {
- rc = PTR_ERR(pl->pl_proc_dir);
- pl->pl_proc_dir = NULL;
- CERROR("%s: cannot create 'pool' proc entry: rc = %d\n",
+ pl->pl_debugfs_entry = ldebugfs_register("pool", debugfs_ns_parent,
+ NULL, NULL);
+ if (IS_ERR(pl->pl_debugfs_entry)) {
+ rc = PTR_ERR(pl->pl_debugfs_entry);
+ pl->pl_debugfs_entry = NULL;
+ CERROR("%s: cannot create 'pool' debugfs entry: rc = %d\n",
ldlm_ns_name(ns), rc);
GOTO(out_free_name, rc);
}
memset(pool_vars, 0, sizeof(pool_vars));
pool_vars[0].name = var_name;
- ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "state", pl,
+ ldlm_add_var(&pool_vars[0], pl->pl_debugfs_entry, "state", pl,
&lprocfs_pool_state_fops);
pl->pl_stats = lprocfs_alloc_stats(LDLM_POOL_LAST_STAT -
lprocfs_counter_init(pl->pl_stats, LDLM_POOL_TIMING_STAT,
LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV,
"recalc_timing", "sec");
- rc = lprocfs_register_stats(pl->pl_proc_dir, "stats", pl->pl_stats);
+ rc = ldebugfs_register_stats(pl->pl_debugfs_entry, "stats",
+ pl->pl_stats);
EXIT;
out_free_name:
wait_for_completion(&pl->pl_kobj_unregister);
}
-static void ldlm_pool_proc_fini(struct ldlm_pool *pl)
+static void ldlm_pool_debugfs_fini(struct ldlm_pool *pl)
{
if (pl->pl_stats != NULL) {
lprocfs_free_stats(&pl->pl_stats);
pl->pl_stats = NULL;
}
- if (pl->pl_proc_dir != NULL) {
- lprocfs_remove(&pl->pl_proc_dir);
- pl->pl_proc_dir = NULL;
+ if (pl->pl_debugfs_entry != NULL) {
+ ldebugfs_remove(&pl->pl_debugfs_entry);
+ pl->pl_debugfs_entry = NULL;
}
}
pl->pl_recalc_period = LDLM_POOL_CLI_DEF_RECALC_PERIOD;
}
pl->pl_client_lock_volume = 0;
- rc = ldlm_pool_proc_init(pl);
+ rc = ldlm_pool_debugfs_init(pl);
if (rc)
RETURN(rc);
{
ENTRY;
ldlm_pool_sysfs_fini(pl);
- ldlm_pool_proc_fini(pl);
+ ldlm_pool_debugfs_fini(pl);
/*
* Pool should not be used after this point. We can't free it here as
la = ktime_to_ns(ktime_sub(cur, lock->l_last_used)) / NSEC_PER_SEC;
lv = lvf * la * unused;
- /* Inform pool about current CLV to see it via proc. */
+ /* Inform pool about current CLV to see it via debugfs. */
ldlm_pool_set_clv(pl, lv);
/* Stop when SLV is not yet come from server or lv is smaller than
}
/**
- * Callback function for proc used policy. Makes decision whether to keep
+ * Callback function for debugfs used policy. Makes decision whether to keep
* \a lock in LRU for current \a LRU size \a unused, added in current scan \a
* added and number of locks to be preferably canceled \a count.
*
/* Client namespaces that don't have any locks in them */
LIST_HEAD(ldlm_cli_inactive_namespace_list);
-static struct proc_dir_entry *ldlm_type_proc_dir;
-static struct proc_dir_entry *ldlm_ns_proc_dir;
-struct proc_dir_entry *ldlm_svc_proc_dir;
+static struct dentry *ldlm_debugfs_dir;
+static struct dentry *ldlm_ns_debugfs_dir;
+struct dentry *ldlm_svc_debugfs_dir;
/* during debug dump certain amount of granted locks for one resource to avoid
* DDOS. */
static unsigned int ldlm_dump_granted_max = 256;
-#ifdef CONFIG_PROC_FS
-static ssize_t
-lprocfs_dump_ns_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t ldebugfs_dump_ns_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
ldlm_dump_all_namespaces(LDLM_NAMESPACE_SERVER, D_DLMTRACE);
ldlm_dump_all_namespaces(LDLM_NAMESPACE_CLIENT, D_DLMTRACE);
RETURN(count);
}
-LPROC_SEQ_FOPS_WR_ONLY(ldlm, dump_ns);
+
+LDEBUGFS_FOPS_WR_ONLY(ldlm, dump_ns);
static int ldlm_rw_uint_seq_show(struct seq_file *m, void *v)
{
(unsigned int *)seq->private);
}
-LPROC_SEQ_FOPS(ldlm_rw_uint);
+LDEBUGFS_SEQ_FOPS(ldlm_rw_uint);
#ifdef HAVE_SERVER_SUPPORT
static int seq_watermark_open(struct inode *inode, struct file *file)
{
- return single_open(file, seq_watermark_show, PDE_DATA(inode));
+ return single_open(file, seq_watermark_show, inode->i_private);
}
static const struct file_operations ldlm_watermark_fops = {
static int seq_granted_open(struct inode *inode, struct file *file)
{
- return single_open(file, seq_granted_show, PDE_DATA(inode));
+ return single_open(file, seq_granted_show, inode->i_private);
}
static const struct file_operations ldlm_granted_fops = {
#endif /* HAVE_SERVER_SUPPORT */
-int ldlm_proc_setup(void)
-{
- int rc;
- struct lprocfs_vars list[] = {
- { .name = "dump_namespaces",
- .fops = &ldlm_dump_ns_fops,
- .proc_mode = 0222 },
- { .name = "dump_granted_max",
- .fops = &ldlm_rw_uint_fops,
- .data = &ldlm_dump_granted_max },
+static struct lprocfs_vars ldlm_debugfs_list[] = {
+ { .name = "dump_namespaces",
+ .fops = &ldlm_dump_ns_fops,
+ .proc_mode = 0222 },
+ { .name = "dump_granted_max",
+ .fops = &ldlm_rw_uint_fops,
+ .data = &ldlm_dump_granted_max },
#ifdef HAVE_SERVER_SUPPORT
- { .name = "lock_reclaim_threshold_mb",
- .fops = &ldlm_watermark_fops,
- .data = &ldlm_reclaim_threshold_mb },
- { .name = "lock_limit_mb",
- .fops = &ldlm_watermark_fops,
- .data = &ldlm_lock_limit_mb },
- { .name = "lock_granted_count",
- .fops = &ldlm_granted_fops,
- .data = &ldlm_granted_total },
+ { .name = "lock_reclaim_threshold_mb",
+ .fops = &ldlm_watermark_fops,
+ .data = &ldlm_reclaim_threshold_mb },
+ { .name = "lock_limit_mb",
+ .fops = &ldlm_watermark_fops,
+ .data = &ldlm_lock_limit_mb },
+ { .name = "lock_granted_count",
+ .fops = &ldlm_granted_fops,
+ .data = &ldlm_granted_total },
#endif
- { NULL }};
- ENTRY;
- LASSERT(ldlm_ns_proc_dir == NULL);
+ { 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);
+int ldlm_debugfs_setup(void)
+{
+ int rc;
+
+ ENTRY;
+ ldlm_debugfs_dir = ldebugfs_register(OBD_LDLM_DEVICENAME,
+ debugfs_lustre_root,
+ NULL, NULL);
+ if (IS_ERR_OR_NULL(ldlm_debugfs_dir)) {
+ CERROR("LDebugFS failed in ldlm-init\n");
+ rc = ldlm_debugfs_dir ? PTR_ERR(ldlm_debugfs_dir) : -ENOMEM;
GOTO(err, rc);
}
- ldlm_ns_proc_dir = lprocfs_register("namespaces",
- ldlm_type_proc_dir,
- NULL, NULL);
- if (IS_ERR(ldlm_ns_proc_dir)) {
+ ldlm_ns_debugfs_dir = ldebugfs_register("namespaces",
+ ldlm_debugfs_dir,
+ NULL, NULL);
+ if (IS_ERR_OR_NULL(ldlm_ns_debugfs_dir)) {
CERROR("LProcFS failed in ldlm-init\n");
- rc = PTR_ERR(ldlm_ns_proc_dir);
+ rc = ldlm_ns_debugfs_dir ? PTR_ERR(ldlm_ns_debugfs_dir)
+ : -ENOMEM;
GOTO(err_type, rc);
}
- ldlm_svc_proc_dir = lprocfs_register("services",
- ldlm_type_proc_dir,
- NULL, NULL);
- if (IS_ERR(ldlm_svc_proc_dir)) {
+ ldlm_svc_debugfs_dir = ldebugfs_register("services",
+ ldlm_debugfs_dir,
+ NULL, NULL);
+ if (IS_ERR_OR_NULL(ldlm_svc_debugfs_dir)) {
CERROR("LProcFS failed in ldlm-init\n");
- rc = PTR_ERR(ldlm_svc_proc_dir);
+ rc = ldlm_svc_debugfs_dir ? PTR_ERR(ldlm_svc_debugfs_dir)
+ : -ENOMEM;
GOTO(err_ns, rc);
}
- rc = lprocfs_add_vars(ldlm_type_proc_dir, list, NULL);
+ rc = ldebugfs_add_vars(ldlm_debugfs_dir, ldlm_debugfs_list, NULL);
if (rc != 0) {
CERROR("LProcFS failed in ldlm-init\n");
GOTO(err_svc, rc);
RETURN(0);
err_svc:
- lprocfs_remove(&ldlm_svc_proc_dir);
+ ldebugfs_remove(&ldlm_svc_debugfs_dir);
err_ns:
- lprocfs_remove(&ldlm_ns_proc_dir);
+ ldebugfs_remove(&ldlm_ns_debugfs_dir);
err_type:
- lprocfs_remove(&ldlm_type_proc_dir);
+ ldebugfs_remove(&ldlm_debugfs_dir);
err:
- ldlm_svc_proc_dir = NULL;
- RETURN(rc);
+ ldlm_svc_debugfs_dir = NULL;
+ ldlm_ns_debugfs_dir = NULL;
+ ldlm_debugfs_dir = NULL;
+ RETURN(rc);
}
-void ldlm_proc_cleanup(void)
+void ldlm_debugfs_cleanup(void)
{
- if (ldlm_svc_proc_dir)
- lprocfs_remove(&ldlm_svc_proc_dir);
+ if (!IS_ERR_OR_NULL(ldlm_svc_debugfs_dir))
+ ldebugfs_remove(&ldlm_svc_debugfs_dir);
- if (ldlm_ns_proc_dir)
- lprocfs_remove(&ldlm_ns_proc_dir);
+ if (!IS_ERR_OR_NULL(ldlm_ns_debugfs_dir))
+ ldebugfs_remove(&ldlm_ns_debugfs_dir);
- if (ldlm_type_proc_dir)
- lprocfs_remove(&ldlm_type_proc_dir);
+ if (!IS_ERR_OR_NULL(ldlm_debugfs_dir))
+ ldebugfs_remove(&ldlm_debugfs_dir);
+
+ ldlm_svc_debugfs_dir = NULL;
+ ldlm_ns_debugfs_dir = NULL;
+ ldlm_debugfs_dir = NULL;
}
static ssize_t resource_count_show(struct kobject *kobj, struct attribute *attr,
.release = ldlm_ns_release,
};
-static void ldlm_namespace_proc_unregister(struct ldlm_namespace *ns)
+static void ldlm_namespace_debugfs_unregister(struct ldlm_namespace *ns)
{
- if (ns->ns_proc_dir_entry == NULL)
+ if (IS_ERR_OR_NULL(ns->ns_debugfs_entry))
CERROR("dlm namespace %s has no procfs dir?\n",
ldlm_ns_name(ns));
else
- lprocfs_remove(&ns->ns_proc_dir_entry);
+ ldebugfs_remove(&ns->ns_debugfs_entry);
if (ns->ns_stats != NULL)
lprocfs_free_stats(&ns->ns_stats);
return err;
}
-static int ldlm_namespace_proc_register(struct ldlm_namespace *ns)
+static int ldlm_namespace_debugfs_register(struct ldlm_namespace *ns)
{
- struct proc_dir_entry *ns_pde;
+ struct dentry *ns_entry;
- LASSERT(ns != NULL);
- LASSERT(ns->ns_rs_hash != NULL);
-
- if (ns->ns_proc_dir_entry != NULL) {
- ns_pde = ns->ns_proc_dir_entry;
+ if (!IS_ERR_OR_NULL(ns->ns_debugfs_entry)) {
+ ns_entry = ns->ns_debugfs_entry;
} else {
- ns_pde = proc_mkdir(ldlm_ns_name(ns), ldlm_ns_proc_dir);
- if (ns_pde == NULL)
+ ns_entry = debugfs_create_dir(ldlm_ns_name(ns),
+ ldlm_ns_debugfs_dir);
+ if (!ns_entry)
return -ENOMEM;
- ns->ns_proc_dir_entry = ns_pde;
+ ns->ns_debugfs_entry = ns_entry;
}
return 0;
}
#undef MAX_STRING_SIZE
-#else /* CONFIG_PROC_FS */
-
-#define ldlm_namespace_proc_unregister(ns) ({;})
-#define ldlm_namespace_proc_register(ns) ({0;})
-
-#endif /* CONFIG_PROC_FS */
static unsigned ldlm_res_hop_hash(struct cfs_hash *hs,
const void *key, unsigned mask)
GOTO(out_hash, rc);
}
- rc = ldlm_namespace_proc_register(ns);
+ rc = ldlm_namespace_debugfs_register(ns);
if (rc) {
CERROR("Can't initialize ns proc, rc %d\n", rc);
GOTO(out_sysfs, rc);
ldlm_namespace_register(ns, client);
RETURN(ns);
out_proc:
- ldlm_namespace_proc_unregister(ns);
+ ldlm_namespace_debugfs_unregister(ns);
out_sysfs:
ldlm_namespace_sysfs_unregister(ns);
ldlm_namespace_cleanup(ns, 0);
* Removing it after @dir may cause oops. */
ldlm_pool_fini(&ns->ns_pool);
- ldlm_namespace_proc_unregister(ns);
+ ldlm_namespace_debugfs_unregister(ns);
ldlm_namespace_sysfs_unregister(ns);
cfs_hash_putref(ns->ns_rs_hash);
/* Namespace \a ns should be not on list at this time, otherwise
{
static struct ptlrpc_service_conf conf;
struct obd_device *obd = m->mds_md_dev.md_lu_dev.ld_obd;
- struct proc_dir_entry *procfs_entry;
int rc = 0;
ENTRY;
- procfs_entry = obd->obd_proc_entry;
- LASSERT(procfs_entry != NULL);
-
conf = (typeof(conf)) {
.psc_name = LUSTRE_MDT_NAME,
.psc_watchdog_factor = MDT_SERVICE_WATCHDOG_FACTOR,
},
};
m->mds_regular_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- procfs_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(m->mds_regular_service)) {
rc = PTR_ERR(m->mds_regular_service);
CERROR("failed to start regular mdt service: %d\n", rc);
},
};
m->mds_readpage_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- procfs_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(m->mds_readpage_service)) {
rc = PTR_ERR(m->mds_readpage_service);
CERROR("failed to start readpage service: %d\n", rc);
},
};
m->mds_setattr_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- procfs_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(m->mds_setattr_service)) {
rc = PTR_ERR(m->mds_setattr_service);
CERROR("failed to start setattr service: %d\n", rc);
},
};
m->mds_out_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- procfs_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(m->mds_out_service)) {
rc = PTR_ERR(m->mds_out_service);
CERROR("failed to start out service: %d\n", rc);
},
};
m->mds_mdsc_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- procfs_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(m->mds_mdsc_service)) {
rc = PTR_ERR(m->mds_mdsc_service);
CERROR("failed to start seq controller service: %d\n", rc);
},
};
m->mds_mdss_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- procfs_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(m->mds_mdss_service)) {
rc = PTR_ERR(m->mds_mdss_service);
CERROR("failed to start metadata seq server service: %d\n", rc);
},
};
m->mds_fld_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- procfs_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(m->mds_fld_service)) {
rc = PTR_ERR(m->mds_fld_service);
CERROR("failed to start fld service: %d\n", rc);
},
};
m->mds_io_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- procfs_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(m->mds_io_service)) {
rc = PTR_ERR(m->mds_io_service);
CERROR("failed to start MDT I/O service: %d\n", rc);
int mds_mod_init(void)
{
- return class_register_type(&mds_obd_device_ops, NULL, true, NULL,
+ return class_register_type(&mds_obd_device_ops, NULL, false, NULL,
LUSTRE_MDS_NAME, &mds_device_type);
}
/* Start the service threads */
mgs->mgs_service = ptlrpc_register_service(&conf, &obd->obd_kset,
- obd->obd_proc_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(mgs->mgs_service)) {
rc = PTR_ERR(mgs->mgs_service);
CERROR("failed to start mgs service: %d\n", rc);
return rc;
}
- rc = class_register_type(&lwp_obd_device_ops, NULL, true, NULL,
+ rc = class_register_type(&lwp_obd_device_ops, NULL, false, NULL,
LUSTRE_LWP_NAME, &lwp_device_type);
if (rc != 0) {
class_unregister_type(LUSTRE_OSP_NAME);
};
ost->ost_service = ptlrpc_register_service(&svc_conf,
&obd->obd_kset,
- obd->obd_proc_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(ost->ost_service)) {
rc = PTR_ERR(ost->ost_service);
CERROR("failed to start service: %d\n", rc);
};
ost->ost_create_service = ptlrpc_register_service(&svc_conf,
&obd->obd_kset,
- obd->obd_proc_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(ost->ost_create_service)) {
rc = PTR_ERR(ost->ost_create_service);
CERROR("failed to start OST create service: %d\n", rc);
};
ost->ost_io_service = ptlrpc_register_service(&svc_conf,
&obd->obd_kset,
- obd->obd_proc_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(ost->ost_io_service)) {
rc = PTR_ERR(ost->ost_io_service);
CERROR("failed to start OST I/O service: %d\n", rc);
};
ost->ost_seq_service = ptlrpc_register_service(&svc_conf,
&obd->obd_kset,
- obd->obd_proc_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(ost->ost_seq_service)) {
rc = PTR_ERR(ost->ost_seq_service);
CERROR("failed to start OST seq service: %d\n", rc);
};
ost->ost_out_service = ptlrpc_register_service(&svc_conf,
&obd->obd_kset,
- obd->obd_proc_entry);
+ obd->obd_debugfs_entry);
if (IS_ERR(ost->ost_out_service)) {
rc = PTR_ERR(ost->ost_out_service);
CERROR("failed to start out service: %d\n", rc);
ENTRY;
- rc = class_register_type(&ost_obd_ops, NULL, true, NULL,
+ rc = class_register_type(&ost_obd_ops, NULL, false, NULL,
LUSTRE_OSS_NAME, NULL);
RETURN(rc);
return ll_eopcode_table[opcode].opname;
}
-#ifdef CONFIG_PROC_FS
-static void ptlrpc_lprocfs_register(struct proc_dir_entry *root, char *dir,
- char *name, struct proc_dir_entry **procroot_ret,
- struct lprocfs_stats **stats_ret)
+static void
+ptlrpc_ldebugfs_register(struct dentry *root, char *dir, char *name,
+ struct dentry **debugfs_root_ret,
+ struct lprocfs_stats **stats_ret)
{
- struct proc_dir_entry *svc_procroot;
+ 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(*procroot_ret == NULL);
- LASSERT(*stats_ret == NULL);
+ LASSERT(!*debugfs_root_ret);
+ LASSERT(!*stats_ret);
- svc_stats = lprocfs_alloc_stats(EXTRA_MAX_OPCODES+LUSTRE_MAX_OPCODES,0);
- if (svc_stats == NULL)
+ svc_stats = lprocfs_alloc_stats(EXTRA_MAX_OPCODES + LUSTRE_MAX_OPCODES,
+ 0);
+ if (!svc_stats)
return;
if (dir) {
- svc_procroot = lprocfs_register(dir, root, NULL, NULL);
- if (IS_ERR(svc_procroot)) {
+ svc_debugfs_entry = ldebugfs_register(dir, root, NULL, NULL);
+ if (IS_ERR(svc_debugfs_entry)) {
lprocfs_free_stats(&svc_stats);
return;
}
} else {
- svc_procroot = root;
+ svc_debugfs_entry = root;
}
lprocfs_counter_init(svc_stats, PTLRPC_REQWAIT_CNTR,
for (i = 0; i < EXTRA_LAST_OPC; i++) {
char *units;
- switch(i) {
+ switch (i) {
case BRW_WRITE_BYTES:
case BRW_READ_BYTES:
units = "bytes";
ll_opcode2str(opcode), "usec");
}
- rc = lprocfs_register_stats(svc_procroot, name, svc_stats);
+ rc = ldebugfs_register_stats(svc_debugfs_entry, name, svc_stats);
if (rc < 0) {
if (dir)
- lprocfs_remove(&svc_procroot);
+ ldebugfs_remove(&svc_debugfs_entry);
lprocfs_free_stats(&svc_stats);
} else {
if (dir)
- *procroot_ret = svc_procroot;
+ *debugfs_root_ret = svc_debugfs_entry;
*stats_ret = svc_stats;
}
}
seq_printf(m, "%d\n", total);
return 0;
}
-LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_req_history_len);
+
+
+LDEBUGFS_SEQ_FOPS_RO(ptlrpc_lprocfs_req_history_len);
static int
ptlrpc_lprocfs_req_history_max_seq_show(struct seq_file *m, void *n)
return count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_req_history_max);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_req_history_max);
static int
ptlrpc_lprocfs_req_buffers_max_seq_show(struct seq_file *m, void *n)
return count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_req_buffers_max);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_req_buffers_max);
static ssize_t threads_min_show(struct kobject *kobj, struct attribute *attr,
char *buf)
RETURN(rc < 0 ? rc : count);
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs);
/** @} nrs */
return rc;
seqf = file->private_data;
- seqf->private = PDE_DATA(inode);
+ seqf->private = inode->i_private;
return 0;
}
return 0;
}
-LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_timeouts);
+
+LDEBUGFS_SEQ_FOPS_RO(ptlrpc_lprocfs_timeouts);
static ssize_t high_priority_ratio_show(struct kobject *kobj,
struct attribute *attr,
&parent->kobj, "%s", svc->srv_name);
}
-void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry,
- struct ptlrpc_service *svc)
+void ptlrpc_ldebugfs_register_service(struct dentry *entry,
+ struct ptlrpc_service *svc)
{
struct lprocfs_vars lproc_vars[] = {
{ .name = "req_buffer_history_len",
int rc;
- ptlrpc_lprocfs_register(entry, svc->srv_name,
- "stats", &svc->srv_procroot,
- &svc->srv_stats);
- if (svc->srv_procroot == NULL)
+ ptlrpc_ldebugfs_register(entry, svc->srv_name, "stats",
+ &svc->srv_debugfs_entry, &svc->srv_stats);
+ if (IS_ERR_OR_NULL(svc->srv_debugfs_entry))
return;
- lprocfs_add_vars(svc->srv_procroot, lproc_vars, NULL);
+ ldebugfs_add_vars(svc->srv_debugfs_entry, lproc_vars, NULL);
- rc = lprocfs_seq_create(svc->srv_procroot, "req_history",
- 0400, &req_history_fops, svc);
+ rc = ldebugfs_seq_create(svc->srv_debugfs_entry, "req_history",
+ 0400, &req_history_fops, svc);
if (rc)
CWARN("Error adding the req_history file\n");
}
void ptlrpc_lprocfs_register_obd(struct obd_device *obddev)
{
- ptlrpc_lprocfs_register(obddev->obd_proc_entry, NULL, "stats",
- &obddev->obd_svc_procroot,
- &obddev->obd_svc_stats);
+ ptlrpc_ldebugfs_register(obddev->obd_debugfs_entry, NULL, "stats",
+ &obddev->obd_svc_debugfs_entry,
+ &obddev->obd_svc_stats);
}
EXPORT_SYMBOL(ptlrpc_lprocfs_register_obd);
void ptlrpc_lprocfs_unregister_service(struct ptlrpc_service *svc)
{
- if (svc->srv_procroot != NULL)
- lprocfs_remove(&svc->srv_procroot);
+ if (!IS_ERR_OR_NULL(svc->srv_debugfs_entry))
+ ldebugfs_remove(&svc->srv_debugfs_entry);
if (svc->srv_stats)
lprocfs_free_stats(&svc->srv_stats);
*/
lprocfs_obd_cleanup(obd);
- if (obd->obd_svc_procroot)
- lprocfs_remove(&obd->obd_svc_procroot);
+ if (!IS_ERR_OR_NULL(obd->obd_svc_debugfs_entry))
+ ldebugfs_remove(&obd->obd_svc_debugfs_entry);
if (obd->obd_svc_stats)
lprocfs_free_stats(&obd->obd_svc_stats);
return count;
}
EXPORT_SYMBOL(lprocfs_pinger_recov_seq_write);
-
-#endif /* CONFIG_PROC_FS */
libcfs_id2str(req->rq_peer), nrq->nr_u.crr.cr_round);
}
-#ifdef CONFIG_PROC_FS
-
/**
- * lprocfs interface
+ * debugfs interface
*/
/**
return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_crrn_quantum);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_crrn_quantum);
/**
* Initializes a CRR-N policy's lprocfs interface for service \a svc
{ NULL }
};
- if (svc->srv_procroot == NULL)
+ if (IS_ERR_OR_NULL(svc->srv_debugfs_entry))
return 0;
- return lprocfs_add_vars(svc->srv_procroot, nrs_crrn_lprocfs_vars, NULL);
-}
-
-/**
- * Cleans up a CRR-N policy's lprocfs interface for service \a svc
- *
- * \param[in] svc the service
- */
-static void nrs_crrn_lprocfs_fini(struct ptlrpc_service *svc)
-{
- if (svc->srv_procroot == NULL)
- return;
-
- lprocfs_remove_proc_entry("nrs_crrn_quantum", svc->srv_procroot);
+ return ldebugfs_add_vars(svc->srv_debugfs_entry, nrs_crrn_lprocfs_vars, NULL);
}
-#endif /* CONFIG_PROC_FS */
-
/**
* CRR-N policy operations
*/
.op_req_enqueue = nrs_crrn_req_add,
.op_req_dequeue = nrs_crrn_req_del,
.op_req_stop = nrs_crrn_req_stop,
-#ifdef CONFIG_PROC_FS
.op_lprocfs_init = nrs_crrn_lprocfs_init,
- .op_lprocfs_fini = nrs_crrn_lprocfs_fini,
-#endif
};
/**
}
/**
- * lprocfs interface
+ * debugfs interface
*/
-#ifdef CONFIG_PROC_FS
-
/* nrs_delay_min and nrs_delay_max are bounded by these values */
#define LPROCFS_NRS_DELAY_LOWER_BOUND 0
#define LPROCFS_NRS_DELAY_UPPER_BOUND 65535
svc, NRS_POL_NAME_DELAY,
NRS_CTL_DELAY_WR_MIN, false);
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_delay_min);
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_delay_min);
/**
* Retrieves the value of the maximum delay for delay policy instances on both
svc, NRS_POL_NAME_DELAY,
NRS_CTL_DELAY_WR_MAX, false);
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_delay_max);
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_delay_max);
/**
* Retrieves the value of the percentage of requests which should be delayed
svc, NRS_POL_NAME_DELAY,
NRS_CTL_DELAY_WR_PCT, false);
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_delay_pct);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_delay_pct);
static int nrs_delay_lprocfs_init(struct ptlrpc_service *svc)
{
{ NULL }
};
- if (svc->srv_procroot == NULL)
+ if (IS_ERR_OR_NULL(svc->srv_debugfs_entry))
return 0;
- return lprocfs_add_vars(svc->srv_procroot, nrs_delay_lprocfs_vars,
- NULL);
+ return ldebugfs_add_vars(svc->srv_debugfs_entry, nrs_delay_lprocfs_vars,
+ NULL);
}
-static void nrs_delay_lprocfs_fini(struct ptlrpc_service *svc)
-{
- if (svc->srv_procroot == NULL)
- return;
-
- lprocfs_remove_proc_entry("nrs_delay_min", svc->srv_procroot);
- lprocfs_remove_proc_entry("nrs_delay_max", svc->srv_procroot);
- lprocfs_remove_proc_entry("nrs_delay_pct", svc->srv_procroot);
-}
-
-#endif /* CONFIG_PROC_FS */
-
/**
* Delay policy operations
*/
.op_req_enqueue = nrs_delay_req_add,
.op_req_dequeue = nrs_delay_req_del,
.op_req_stop = nrs_delay_req_stop,
-#ifdef CONFIG_PROC_FS
.op_lprocfs_init = nrs_delay_lprocfs_init,
- .op_lprocfs_fini = nrs_delay_lprocfs_fini,
-#endif
};
/**
}
/**
- * lprocfs interface
+ * debugfs interface
*/
-#ifdef CONFIG_PROC_FS
-
/**
* This allows to bundle the policy name into the lprocfs_vars::data pointer
* so that lprocfs read/write functions can be used by both the ORR and TRR
return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_quantum);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_quantum);
#define LPROCFS_NRS_OFF_NAME_REG "reg_offset_type:"
#define LPROCFS_NRS_OFF_NAME_HP "hp_offset_type:"
return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_offset_type);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_offset_type);
#define NRS_LPROCFS_REQ_SUPP_NAME_REG "reg_supported:"
#define NRS_LPROCFS_REQ_SUPP_NAME_HP "hp_supported:"
return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_supported);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_supported);
static int nrs_orr_lprocfs_init(struct ptlrpc_service *svc)
{
{ NULL }
};
- if (svc->srv_procroot == NULL)
+ if (IS_ERR_OR_NULL(svc->srv_debugfs_entry))
return 0;
lprocfs_orr_data.svc = svc;
for (i = 0; i < ARRAY_SIZE(nrs_orr_lprocfs_vars); i++)
nrs_orr_lprocfs_vars[i].data = &lprocfs_orr_data;
- return lprocfs_add_vars(svc->srv_procroot, nrs_orr_lprocfs_vars, NULL);
-}
-
-static void nrs_orr_lprocfs_fini(struct ptlrpc_service *svc)
-{
- if (svc->srv_procroot == NULL)
- return;
-
- lprocfs_remove_proc_entry("nrs_orr_quantum", svc->srv_procroot);
- lprocfs_remove_proc_entry("nrs_orr_offset_type", svc->srv_procroot);
- lprocfs_remove_proc_entry("nrs_orr_supported", svc->srv_procroot);
+ return ldebugfs_add_vars(svc->srv_debugfs_entry, nrs_orr_lprocfs_vars,
+ NULL);
}
-#endif /* CONFIG_PROC_FS */
-
static const struct ptlrpc_nrs_pol_ops nrs_orr_ops = {
.op_policy_init = nrs_orr_init,
.op_policy_start = nrs_orr_start,
.op_req_enqueue = nrs_orr_req_add,
.op_req_dequeue = nrs_orr_req_del,
.op_req_stop = nrs_orr_req_stop,
-#ifdef CONFIG_PROC_FS
.op_lprocfs_init = nrs_orr_lprocfs_init,
- .op_lprocfs_fini = nrs_orr_lprocfs_fini,
-#endif
};
struct ptlrpc_nrs_pol_conf nrs_conf_orr = {
*
* TRR reuses much of the functions and data structures of ORR
*/
-
-#ifdef CONFIG_PROC_FS
-
static int nrs_trr_lprocfs_init(struct ptlrpc_service *svc)
{
int i;
{ NULL }
};
- if (svc->srv_procroot == NULL)
+ if (IS_ERR_OR_NULL(svc->srv_debugfs_entry))
return 0;
lprocfs_trr_data.svc = svc;
for (i = 0; i < ARRAY_SIZE(nrs_trr_lprocfs_vars); i++)
nrs_trr_lprocfs_vars[i].data = &lprocfs_trr_data;
- return lprocfs_add_vars(svc->srv_procroot, nrs_trr_lprocfs_vars, NULL);
+ return ldebugfs_add_vars(svc->srv_debugfs_entry, nrs_trr_lprocfs_vars,
+ NULL);
}
-static void nrs_trr_lprocfs_fini(struct ptlrpc_service *svc)
-{
- if (svc->srv_procroot == NULL)
- return;
-
- lprocfs_remove_proc_entry("nrs_trr_quantum", svc->srv_procroot);
- lprocfs_remove_proc_entry("nrs_trr_offset_type", svc->srv_procroot);
- lprocfs_remove_proc_entry("nrs_trr_supported", svc->srv_procroot);
-}
-
-#endif /* CONFIG_PROC_FS */
-
/**
* Reuse much of the ORR functionality for TRR.
*/
.op_req_enqueue = nrs_orr_req_add,
.op_req_dequeue = nrs_orr_req_del,
.op_req_stop = nrs_orr_req_stop,
-#ifdef CONFIG_PROC_FS
.op_lprocfs_init = nrs_trr_lprocfs_init,
- .op_lprocfs_fini = nrs_trr_lprocfs_fini,
-#endif
};
struct ptlrpc_nrs_pol_conf nrs_conf_trr = {
nrq->nr_u.tbf.tr_sequence);
}
-#ifdef CONFIG_PROC_FS
-
/**
- * lprocfs interface
+ * debugfs interface
*/
/**
out:
return rc ? rc : count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_tbf_rule);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_tbf_rule);
/**
* Initializes a TBF policy's lprocfs interface for service \a svc
{ NULL }
};
- if (svc->srv_procroot == NULL)
+ if (IS_ERR_OR_NULL(svc->srv_debugfs_entry))
return 0;
- return lprocfs_add_vars(svc->srv_procroot, nrs_tbf_lprocfs_vars, NULL);
+ return ldebugfs_add_vars(svc->srv_debugfs_entry, nrs_tbf_lprocfs_vars,
+ NULL);
}
/**
- * Cleans up a TBF policy's lprocfs interface for service \a svc
- *
- * \param[in] svc the service
- */
-static void nrs_tbf_lprocfs_fini(struct ptlrpc_service *svc)
-{
- if (svc->srv_procroot == NULL)
- return;
-
- lprocfs_remove_proc_entry("nrs_tbf_rule", svc->srv_procroot);
-}
-
-#endif /* CONFIG_PROC_FS */
-
-/**
* TBF policy operations
*/
static const struct ptlrpc_nrs_pol_ops nrs_tbf_ops = {
.op_req_enqueue = nrs_tbf_req_add,
.op_req_dequeue = nrs_tbf_req_del,
.op_req_stop = nrs_tbf_req_stop,
-#ifdef CONFIG_PROC_FS
.op_lprocfs_init = nrs_tbf_lprocfs_init,
- .op_lprocfs_fini = nrs_tbf_lprocfs_fini,
-#endif
};
/**
struct ptlrpc_service *svc);
void ptlrpc_sysfs_unregister_service(struct ptlrpc_service *svc);
+void ptlrpc_ldebugfs_register_service(struct dentry *debugfs_entry,
+ struct ptlrpc_service *svc);
#ifdef CONFIG_PROC_FS
-void ptlrpc_lprocfs_register_service(struct proc_dir_entry *proc_entry,
- struct ptlrpc_service *svc);
void ptlrpc_lprocfs_unregister_service(struct ptlrpc_service *svc);
void ptlrpc_lprocfs_rpc_sent(struct ptlrpc_request *req, long amount);
void ptlrpc_lprocfs_do_request_stat (struct ptlrpc_request *req,
long q_usec, long work_usec);
#else
-#define ptlrpc_lprocfs_register_service(params...) do{}while(0)
#define ptlrpc_lprocfs_unregister_service(params...) do{}while(0)
#define ptlrpc_lprocfs_rpc_sent(params...) do{}while(0)
#define ptlrpc_lprocfs_do_request_stat(params...) do{}while(0)
struct ptlrpc_service *
ptlrpc_register_service(struct ptlrpc_service_conf *conf,
struct kset *parent,
- struct proc_dir_entry *proc_entry)
+ struct dentry *debugfs_entry)
{
struct ptlrpc_service_cpt_conf *cconf = &conf->psc_cpt;
struct ptlrpc_service *service;
GOTO(failed, rc);
}
- if (proc_entry != NULL)
- ptlrpc_lprocfs_register_service(proc_entry, service);
+ if (debugfs_entry != NULL)
+ ptlrpc_ldebugfs_register_service(debugfs_entry, service);
rc = ptlrpc_service_nrs_setup(service);
if (rc != 0)
git://git.whamcloud.com / fs / lustre-release.git / commitdiff