int lfsck_query(const struct lu_env *env, struct dt_device *key,
struct lfsck_request *lr);
-int lfsck_get_speed(struct dt_device *key, void *buf, int len);
+int lfsck_get_speed(struct seq_file *m, struct dt_device *key);
int lfsck_set_speed(struct dt_device *key, int val);
-int lfsck_get_windows(struct dt_device *key, void *buf, int len);
+int lfsck_get_windows(struct seq_file *m, struct dt_device *key);
int lfsck_set_windows(struct dt_device *key, int val);
-int lfsck_dump(struct dt_device *key, void *buf, int len, enum lfsck_type type);
+int lfsck_dump(struct seq_file *m, struct dt_device *key, enum lfsck_type type);
static inline void lfsck_pack_rfa(struct lfsck_request *lr,
const struct lu_fid *fid)
int (*lfsck_dump)(const struct lu_env *env,
struct lfsck_component *com,
- char *buf,
- int len);
+ struct seq_file *m);
int (*lfsck_double_scan)(const struct lu_env *env,
struct lfsck_component *com);
struct lfsck_component *com);
void lfsck_instance_cleanup(const struct lu_env *env,
struct lfsck_instance *lfsck);
-int lfsck_bits_dump(char **buf, int *len, int bits, const char *names[],
+int lfsck_bits_dump(struct seq_file *m, int bits, const char *names[],
const char *prefix);
-int lfsck_time_dump(char **buf, int *len, __u64 time, const char *prefix);
-int lfsck_pos_dump(char **buf, int *len, struct lfsck_position *pos,
+int lfsck_time_dump(struct seq_file *m, __u64 time, const char *prefix);
+int lfsck_pos_dump(struct seq_file *m, struct lfsck_position *pos,
const char *prefix);
void lfsck_pos_fill(const struct lu_env *env, struct lfsck_instance *lfsck,
struct lfsck_position *pos, bool init);
return ERR_PTR(-ENOMEM);
}
- rb_init_node(&lrn->lrn_node);
+ RB_CLEAR_NODE(&lrn->lrn_node);
lrn->lrn_seq = fid_seq(fid);
lrn->lrn_first_oid = fid_oid(fid) & ~LFSCK_RBTREE_BITMAP_MASK;
atomic_set(&lrn->lrn_known_count, 0);
}
static int lfsck_layout_dump(const struct lu_env *env,
- struct lfsck_component *com, char *buf, int len)
+ struct lfsck_component *com, struct seq_file *m)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct lfsck_layout *lo = com->lc_file_ram;
- int save = len;
- int ret = -ENOSPC;
int rc;
down_read(&com->lc_sem);
- rc = snprintf(buf, len,
- "name: lfsck_layout\n"
+ seq_printf(m, "name: lfsck_layout\n"
"magic: %#x\n"
"version: %d\n"
"status: %s\n",
lo->ll_magic,
bk->lb_version,
lfsck_status2names(lo->ll_status));
- if (rc <= 0)
- goto out;
- buf += rc;
- len -= rc;
- rc = lfsck_bits_dump(&buf, &len, lo->ll_flags, lfsck_flags_names,
- "flags");
+ rc = lfsck_bits_dump(m, lo->ll_flags, lfsck_flags_names, "flags");
if (rc < 0)
goto out;
- rc = lfsck_bits_dump(&buf, &len, bk->lb_param, lfsck_param_names,
- "param");
+ rc = lfsck_bits_dump(m, bk->lb_param, lfsck_param_names, "param");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, lo->ll_time_last_complete,
+ rc = lfsck_time_dump(m, lo->ll_time_last_complete,
"time_since_last_completed");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, lo->ll_time_latest_start,
+ rc = lfsck_time_dump(m, lo->ll_time_latest_start,
"time_since_latest_start");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, lo->ll_time_last_checkpoint,
+ rc = lfsck_time_dump(m, lo->ll_time_last_checkpoint,
"time_since_last_checkpoint");
if (rc < 0)
goto out;
- rc = snprintf(buf, len,
- "latest_start_position: "LPU64"\n"
+ seq_printf(m, "latest_start_position: "LPU64"\n"
"last_checkpoint_position: "LPU64"\n"
"first_failure_position: "LPU64"\n",
lo->ll_pos_latest_start,
lo->ll_pos_last_checkpoint,
lo->ll_pos_first_inconsistent);
- if (rc <= 0)
- goto out;
- buf += rc;
- len -= rc;
-
- rc = snprintf(buf, len,
- "success_count: %u\n"
+ seq_printf(m, "success_count: %u\n"
"repaired_dangling: "LPU64"\n"
"repaired_unmatched_pair: "LPU64"\n"
"repaired_multiple_referenced: "LPU64"\n"
lo->ll_objs_skipped,
lo->ll_objs_failed_phase1,
lo->ll_objs_failed_phase2);
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
if (lo->ll_status == LS_SCANNING_PHASE1) {
__u64 pos;
do_div(new_checked, duration);
if (rtime != 0)
do_div(speed, rtime);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
+ seq_printf(m, "checked_phase1: "LPU64"\n"
"checked_phase2: "LPU64"\n"
"run_time_phase1: %u seconds\n"
"run_time_phase2: %u seconds\n"
lo->ll_run_time_phase2,
speed,
new_checked);
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
LASSERT(lfsck->li_di_oit != NULL);
pos = iops->store(env, lfsck->li_di_oit);
if (!lfsck->li_current_oit_processed)
pos--;
- rc = snprintf(buf, len, "current_position: "LPU64"\n", pos);
- if (rc <= 0)
- goto out;
+ seq_printf(m, "current_position: "LPU64"\n", pos);
- buf += rc;
- len -= rc;
} else if (lo->ll_status == LS_SCANNING_PHASE2) {
cfs_duration_t duration = cfs_time_current() -
lfsck->li_time_last_checkpoint;
do_div(speed1, lo->ll_run_time_phase1);
if (rtime != 0)
do_div(speed2, rtime);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
- "checked_phase2: "LPU64"\n"
- "run_time_phase1: %u seconds\n"
- "run_time_phase2: %u seconds\n"
- "average_speed_phase1: "LPU64" items/sec\n"
- "average_speed_phase2: "LPU64" items/sec\n"
- "real-time_speed_phase1: N/A\n"
- "real-time_speed_phase2: "LPU64" items/sec\n"
- "current_position: "DFID"\n",
- lo->ll_objs_checked_phase1,
- checked,
- lo->ll_run_time_phase1,
- rtime,
- speed1,
- speed2,
- new_checked,
- PFID(&com->lc_fid_latest_scanned_phase2));
+ rc = seq_printf(m, "checked_phase1: "LPU64"\n"
+ "checked_phase2: "LPU64"\n"
+ "run_time_phase1: %u seconds\n"
+ "run_time_phase2: %u seconds\n"
+ "average_speed_phase1: "LPU64" items/sec\n"
+ "average_speed_phase2: "LPU64" items/sec\n"
+ "real-time_speed_phase1: N/A\n"
+ "real-time_speed_phase2: "LPU64" items/sec\n"
+ "current_position: "DFID"\n",
+ lo->ll_objs_checked_phase1,
+ checked,
+ lo->ll_run_time_phase1,
+ rtime,
+ speed1,
+ speed2,
+ new_checked,
+ PFID(&com->lc_fid_latest_scanned_phase2));
if (rc <= 0)
goto out;
- buf += rc;
- len -= rc;
} else {
__u64 speed1 = lo->ll_objs_checked_phase1;
__u64 speed2 = lo->ll_objs_checked_phase2;
do_div(speed1, lo->ll_run_time_phase1);
if (lo->ll_run_time_phase2 != 0)
do_div(speed2, lo->ll_run_time_phase2);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
- "checked_phase2: "LPU64"\n"
- "run_time_phase1: %u seconds\n"
- "run_time_phase2: %u seconds\n"
- "average_speed_phase1: "LPU64" items/sec\n"
- "average_speed_phase2: "LPU64" objs/sec\n"
- "real-time_speed_phase1: N/A\n"
- "real-time_speed_phase2: N/A\n"
- "current_position: N/A\n",
- lo->ll_objs_checked_phase1,
- lo->ll_objs_checked_phase2,
- lo->ll_run_time_phase1,
- lo->ll_run_time_phase2,
- speed1,
- speed2);
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
+ seq_printf(m, "checked_phase1: "LPU64"\n"
+ "checked_phase2: "LPU64"\n"
+ "run_time_phase1: %u seconds\n"
+ "run_time_phase2: %u seconds\n"
+ "average_speed_phase1: "LPU64" items/sec\n"
+ "average_speed_phase2: "LPU64" objs/sec\n"
+ "real-time_speed_phase1: N/A\n"
+ "real-time_speed_phase2: N/A\n"
+ "current_position: N/A\n",
+ lo->ll_objs_checked_phase1,
+ lo->ll_objs_checked_phase2,
+ lo->ll_run_time_phase1,
+ lo->ll_run_time_phase2,
+ speed1,
+ speed2);
}
- ret = save - len;
-
out:
up_read(&com->lc_sem);
- return ret;
+ return rc;
}
static int lfsck_layout_master_double_scan(const struct lu_env *env,
return 0;
}
-int lfsck_bits_dump(char **buf, int *len, int bits, const char *names[],
+int lfsck_bits_dump(struct seq_file *m, int bits, const char *names[],
const char *prefix)
{
- int save = *len;
int flag;
- int rc;
int i;
bool newline = (bits != 0 ? false : true);
- rc = snprintf(*buf, *len, "%s:%c", prefix, newline ? '\n' : ' ');
- if (rc <= 0)
- return -ENOSPC;
+ seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
- *buf += rc;
- *len -= rc;
for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
if (flag & bits) {
bits &= ~flag;
if (bits == 0)
newline = true;
- rc = snprintf(*buf, *len, "%s%c", names[i],
- newline ? '\n' : ',');
- if (rc <= 0)
- return -ENOSPC;
-
- *buf += rc;
- *len -= rc;
+ seq_printf(m, "%s%c", names[i],
+ newline ? '\n' : ',');
}
}
}
- if (!newline) {
- rc = snprintf(*buf, *len, "\n");
- if (rc <= 0)
- return -ENOSPC;
-
- *buf += rc;
- *len -= rc;
- }
-
- return save - *len;
+ if (!newline)
+ seq_printf(m, "\n");
+ return 0;
}
-int lfsck_time_dump(char **buf, int *len, __u64 time, const char *prefix)
+int lfsck_time_dump(struct seq_file *m, __u64 time, const char *prefix)
{
- int rc;
-
if (time != 0)
- rc = snprintf(*buf, *len, "%s: "LPU64" seconds\n", prefix,
- cfs_time_current_sec() - time);
+ seq_printf(m, "%s: "LPU64" seconds\n", prefix,
+ cfs_time_current_sec() - time);
else
- rc = snprintf(*buf, *len, "%s: N/A\n", prefix);
- if (rc <= 0)
- return -ENOSPC;
-
- *buf += rc;
- *len -= rc;
- return rc;
+ seq_printf(m, "%s: N/A\n", prefix);
+ return 0;
}
-int lfsck_pos_dump(char **buf, int *len, struct lfsck_position *pos,
+int lfsck_pos_dump(struct seq_file *m, struct lfsck_position *pos,
const char *prefix)
{
- int rc;
-
if (fid_is_zero(&pos->lp_dir_parent)) {
if (pos->lp_oit_cookie == 0)
- rc = snprintf(*buf, *len, "%s: N/A, N/A, N/A\n",
- prefix);
+ seq_printf(m, "%s: N/A, N/A, N/A\n",
+ prefix);
else
- rc = snprintf(*buf, *len, "%s: "LPU64", N/A, N/A\n",
- prefix, pos->lp_oit_cookie);
+ seq_printf(m, "%s: "LPU64", N/A, N/A\n",
+ prefix, pos->lp_oit_cookie);
} else {
- rc = snprintf(*buf, *len, "%s: "LPU64", "DFID", "LPU64"\n",
- prefix, pos->lp_oit_cookie,
- PFID(&pos->lp_dir_parent), pos->lp_dir_cookie);
+ seq_printf(m, "%s: "LPU64", "DFID", "LPU64"\n",
+ prefix, pos->lp_oit_cookie,
+ PFID(&pos->lp_dir_parent), pos->lp_dir_cookie);
}
- if (rc <= 0)
- return -ENOSPC;
-
- *buf += rc;
- *len -= rc;
- return rc;
+ return 0;
}
void lfsck_pos_fill(const struct lu_env *env, struct lfsck_instance *lfsck,
/* external interfaces */
-int lfsck_get_speed(struct dt_device *key, void *buf, int len)
+int lfsck_get_speed(struct seq_file *m, struct dt_device *key)
{
struct lu_env env;
struct lfsck_instance *lfsck;
lfsck = lfsck_instance_find(key, true, false);
if (likely(lfsck != NULL)) {
- rc = snprintf(buf, len, "%u\n",
- lfsck->li_bookmark_ram.lb_speed_limit);
+ seq_printf(m, "%u\n", lfsck->li_bookmark_ram.lb_speed_limit);
lfsck_instance_put(&env, lfsck);
} else {
rc = -ENXIO;
}
EXPORT_SYMBOL(lfsck_set_speed);
-int lfsck_get_windows(struct dt_device *key, void *buf, int len)
+int lfsck_get_windows(struct seq_file *m, struct dt_device *key)
{
struct lu_env env;
struct lfsck_instance *lfsck;
lfsck = lfsck_instance_find(key, true, false);
if (likely(lfsck != NULL)) {
- rc = snprintf(buf, len, "%u\n",
- lfsck->li_bookmark_ram.lb_async_windows);
+ seq_printf(m, "%u\n", lfsck->li_bookmark_ram.lb_async_windows);
lfsck_instance_put(&env, lfsck);
} else {
rc = -ENXIO;
}
EXPORT_SYMBOL(lfsck_set_windows);
-int lfsck_dump(struct dt_device *key, void *buf, int len, enum lfsck_type type)
+int lfsck_dump(struct seq_file *m, struct dt_device *key, enum lfsck_type type)
{
struct lu_env env;
struct lfsck_instance *lfsck;
if (likely(lfsck != NULL)) {
com = lfsck_component_find(lfsck, type);
if (likely(com != NULL)) {
- rc = com->lc_ops->lfsck_dump(&env, com, buf, len);
+ rc = com->lc_ops->lfsck_dump(&env, com, m);
lfsck_component_put(&env, com);
} else {
rc = -ENOTSUPP;
static int
lfsck_namespace_dump(const struct lu_env *env, struct lfsck_component *com,
- char *buf, int len)
+ struct seq_file *m)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct lfsck_namespace *ns = com->lc_file_ram;
- int save = len;
- int ret = -ENOSPC;
int rc;
down_read(&com->lc_sem);
- rc = snprintf(buf, len,
- "name: lfsck_namespace\n"
- "magic: %#x\n"
- "version: %d\n"
- "status: %s\n",
- ns->ln_magic,
- bk->lb_version,
- lfsck_status2names(ns->ln_status));
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
- rc = lfsck_bits_dump(&buf, &len, ns->ln_flags, lfsck_flags_names,
- "flags");
+ seq_printf(m, "name: lfsck_namespace\n"
+ "magic: %#x\n"
+ "version: %d\n"
+ "status: %s\n",
+ ns->ln_magic,
+ bk->lb_version,
+ lfsck_status2names(ns->ln_status));
+
+ rc = lfsck_bits_dump(m, ns->ln_flags, lfsck_flags_names, "flags");
if (rc < 0)
goto out;
- rc = lfsck_bits_dump(&buf, &len, bk->lb_param, lfsck_param_names,
- "param");
+ rc = lfsck_bits_dump(m, bk->lb_param, lfsck_param_names, "param");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_complete,
+ rc = lfsck_time_dump(m, ns->ln_time_last_complete,
"time_since_last_completed");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, ns->ln_time_latest_start,
+ rc = lfsck_time_dump(m, ns->ln_time_latest_start,
"time_since_latest_start");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_checkpoint,
+ rc = lfsck_time_dump(m, ns->ln_time_last_checkpoint,
"time_since_last_checkpoint");
if (rc < 0)
goto out;
- rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_latest_start,
+ rc = lfsck_pos_dump(m, &ns->ln_pos_latest_start,
"latest_start_position");
if (rc < 0)
goto out;
- rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_last_checkpoint,
+ rc = lfsck_pos_dump(m, &ns->ln_pos_last_checkpoint,
"last_checkpoint_position");
if (rc < 0)
goto out;
- rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_first_inconsistent,
+ rc = lfsck_pos_dump(m, &ns->ln_pos_first_inconsistent,
"first_failure_position");
if (rc < 0)
goto out;
do_div(new_checked, duration);
if (rtime != 0)
do_div(speed, rtime);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
+ seq_printf(m, "checked_phase1: "LPU64"\n"
"checked_phase2: "LPU64"\n"
"updated_phase1: "LPU64"\n"
"updated_phase2: "LPU64"\n"
ns->ln_run_time_phase2,
speed,
new_checked);
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
LASSERT(lfsck->li_di_oit != NULL);
pos.lp_dir_cookie = 0;
}
spin_unlock(&lfsck->li_lock);
- rc = lfsck_pos_dump(&buf, &len, &pos, "current_position");
- if (rc <= 0)
- goto out;
+ lfsck_pos_dump(m, &pos, "current_position");
} else if (ns->ln_status == LS_SCANNING_PHASE2) {
cfs_duration_t duration = cfs_time_current() -
lfsck->li_time_last_checkpoint;
do_div(speed1, ns->ln_run_time_phase1);
if (rtime != 0)
do_div(speed2, rtime);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
+ seq_printf(m, "checked_phase1: "LPU64"\n"
"checked_phase2: "LPU64"\n"
"updated_phase1: "LPU64"\n"
"updated_phase2: "LPU64"\n"
speed2,
new_checked,
PFID(&ns->ln_fid_latest_scanned_phase2));
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
} else {
__u64 speed1 = ns->ln_items_checked;
__u64 speed2 = ns->ln_objs_checked_phase2;
do_div(speed1, ns->ln_run_time_phase1);
if (ns->ln_run_time_phase2 != 0)
do_div(speed2, ns->ln_run_time_phase2);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
+ seq_printf(m, "checked_phase1: "LPU64"\n"
"checked_phase2: "LPU64"\n"
"updated_phase1: "LPU64"\n"
"updated_phase2: "LPU64"\n"
ns->ln_run_time_phase2,
speed1,
speed2);
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
}
- ret = save - len;
-
out:
up_read(&com->lc_sem);
- return ret;
+ return 0;
}
static int lfsck_namespace_double_scan_main(void *args)
static struct lu_device *mdd_device_fini(const struct lu_env *env,
struct lu_device *d)
{
- struct mdd_device *mdd = lu2mdd_dev(d);
- int rc;
+ struct mdd_device *mdd = lu2mdd_dev(d);
if (d->ld_site)
lu_dev_del_linkage(d->ld_site, d);
- rc = mdd_procfs_fini(mdd);
- if (rc) {
- CERROR("proc fini error %d \n", rc);
- return ERR_PTR(rc);
- }
+ mdd_procfs_fini(mdd);
return NULL;
}
ENTRY;
switch (cfg->lcfg_command) {
- case LCFG_PARAM: {
- struct lprocfs_static_vars lvars;
-
- lprocfs_mdd_init_vars(&lvars);
- rc = class_process_proc_param(PARAM_MDD, lvars.obd_vars, cfg,m);
- if (rc > 0 || rc == -ENOSYS)
- /* we don't understand; pass it on */
- rc = next->ld_ops->ldo_process_config(env, next, cfg);
- break;
- }
+ case LCFG_PARAM: {
+ struct obd_device *obd = mdd2obd_dev(m);
+
+ rc = class_process_proc_seq_param(PARAM_MDD, obd->obd_vars,
+ cfg, m);
+ if (rc > 0 || rc == -ENOSYS)
+ /* we don't understand; pass it on */
+ rc = next->ld_ops->ldo_process_config(env, next, cfg);
+ break;
+ }
case LCFG_SETUP:
rc = next->ld_ops->ldo_process_config(env, next, cfg);
if (rc)
static int __init mdd_mod_init(void)
{
- struct lprocfs_static_vars lvars;
int rc;
- lprocfs_mdd_init_vars(&lvars);
-
rc = lu_kmem_init(mdd_caches);
if (rc)
return rc;
rc = class_register_type(&mdd_obd_device_ops, NULL, true, NULL,
#ifndef HAVE_ONLY_PROCFS_SEQ
- lvars.module_vars,
+ NULL,
#endif
LUSTRE_MDD_NAME, &mdd_device_type);
if (rc)
struct thandle *);
/* mdd_lproc.c */
-void lprocfs_mdd_init_vars(struct lprocfs_static_vars *lvars);
int mdd_procfs_init(struct mdd_device *mdd, const char *name);
-int mdd_procfs_fini(struct mdd_device *mdd);
+void mdd_procfs_fini(struct mdd_device *mdd);
/* mdd_object.c */
extern struct kmem_cache *mdd_object_kmem;
#include <libcfs/libcfs_string.h>
#include "mdd_internal.h"
-int mdd_procfs_init(struct mdd_device *mdd, const char *name)
-{
- struct lprocfs_static_vars lvars;
- struct obd_type *type;
- int rc;
- ENTRY;
-
- /* at the moment there is no linkage between lu_type
- * and obd_type, so we lookup obd_type this way */
- type = class_search_type(LUSTRE_MDD_NAME);
-
- LASSERT(name != NULL);
- LASSERT(type != NULL);
-
- /* Find the type procroot and add the proc entry for this device */
- lprocfs_mdd_init_vars(&lvars);
- mdd->mdd_proc_entry = lprocfs_register(name, type->typ_procroot,
- lvars.obd_vars, mdd);
- if (IS_ERR(mdd->mdd_proc_entry)) {
- rc = PTR_ERR(mdd->mdd_proc_entry);
- CERROR("Error %d setting up lprocfs for %s\n",
- rc, name);
- mdd->mdd_proc_entry = NULL;
- GOTO(out, rc);
- }
-
- rc = 0;
-
- EXIT;
-out:
- if (rc)
- mdd_procfs_fini(mdd);
- return rc;
-}
-
-int mdd_procfs_fini(struct mdd_device *mdd)
-{
- if (mdd->mdd_proc_entry) {
- lprocfs_remove(&mdd->mdd_proc_entry);
- mdd->mdd_proc_entry = NULL;
- }
- RETURN(0);
-}
-
-static int lprocfs_wr_atime_diff(struct file *file, const char *buffer,
- unsigned long count, void *data)
+static ssize_t
+mdd_atime_diff_seq_write(struct file *file, const char *buffer,
+ size_t count, loff_t *off)
{
- struct mdd_device *mdd = data;
- char kernbuf[20], *end;
- unsigned long diff = 0;
+ struct seq_file *m = file->private_data;
+ struct mdd_device *mdd = m->private;
+ char kernbuf[20], *end;
+ unsigned long diff = 0;
if (count > (sizeof(kernbuf) - 1))
return -EINVAL;
return count;
}
-static int lprocfs_rd_atime_diff(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int mdd_atime_diff_seq_show(struct seq_file *m, void *data)
{
- struct mdd_device *mdd = data;
+ struct mdd_device *mdd = m->private;
- *eof = 1;
- return snprintf(page, count, "%lu\n", mdd->mdd_atime_diff);
+ return seq_printf(m, "%lu\n", mdd->mdd_atime_diff);
}
-
+LPROC_SEQ_FOPS(mdd_atime_diff);
/**** changelogs ****/
-static int lprocfs_rd_changelog_mask(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int mdd_changelog_mask_seq_show(struct seq_file *m, void *data)
{
- struct mdd_device *mdd = data;
- int i = 0, rc = 0;
-
- *eof = 1;
- while (i < CL_LAST) {
- if (mdd->mdd_cl.mc_mask & (1 << i))
- rc += snprintf(page + rc, count - rc, "%s ",
- changelog_type2str(i));
- i++;
- }
- return rc;
+ struct mdd_device *mdd = m->private;
+ int i = 0;
+
+ while (i < CL_LAST) {
+ if (mdd->mdd_cl.mc_mask & (1 << i))
+ seq_printf(m, "%s ", changelog_type2str(i));
+ i++;
+ }
+ return 0;
}
-static int lprocfs_wr_changelog_mask(struct file *file, const char *buffer,
- unsigned long count, void *data)
+static ssize_t
+mdd_changelog_mask_seq_write(struct file *file, const char *buffer,
+ size_t count, loff_t *off)
{
- struct mdd_device *mdd = data;
+ struct seq_file *m = file->private_data;
+ struct mdd_device *mdd = m->private;
char *kernbuf;
int rc;
ENTRY;
OBD_FREE(kernbuf, PAGE_CACHE_SIZE);
return rc;
}
-
-struct cucb_data {
- char *page;
- int count;
- int idx;
-};
+LPROC_SEQ_FOPS(mdd_changelog_mask);
static int lprocfs_changelog_users_cb(const struct lu_env *env,
struct llog_handle *llh,
struct llog_rec_hdr *hdr, void *data)
{
- struct llog_changelog_user_rec *rec;
- struct cucb_data *cucb = (struct cucb_data *)data;
-
- LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
+ struct llog_changelog_user_rec *rec;
+ struct seq_file *m = data;
- rec = (struct llog_changelog_user_rec *)hdr;
+ LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
- cucb->idx += snprintf(cucb->page + cucb->idx, cucb->count - cucb->idx,
- CHANGELOG_USER_PREFIX"%-3d "LPU64"\n",
- rec->cur_id, rec->cur_endrec);
- if (cucb->idx >= cucb->count)
- return -ENOSPC;
+ rec = (struct llog_changelog_user_rec *)hdr;
- return 0;
+ seq_printf(m, CHANGELOG_USER_PREFIX"%-3d "LPU64"\n",
+ rec->cur_id, rec->cur_endrec);
+ return 0;
}
-static int lprocfs_rd_changelog_users(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int mdd_changelog_users_seq_show(struct seq_file *m, void *data)
{
struct lu_env env;
- struct mdd_device *mdd = data;
+ struct mdd_device *mdd = m->private;
struct llog_ctxt *ctxt;
- struct cucb_data cucb;
__u64 cur;
int rc;
- *eof = 1;
-
ctxt = llog_get_context(mdd2obd_dev(mdd),
LLOG_CHANGELOG_USER_ORIG_CTXT);
if (ctxt == NULL)
cur = mdd->mdd_cl.mc_index;
spin_unlock(&mdd->mdd_cl.mc_lock);
- cucb.count = count;
- cucb.page = page;
- cucb.idx = 0;
-
- cucb.idx += snprintf(cucb.page + cucb.idx, cucb.count - cucb.idx,
- "current index: "LPU64"\n", cur);
-
- cucb.idx += snprintf(cucb.page + cucb.idx, cucb.count - cucb.idx,
- "%-5s %s\n", "ID", "index");
+ seq_printf(m, "current index: "LPU64"\n", cur);
+ seq_printf(m, "%-5s %s\n", "ID", "index");
llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb,
- &cucb, 0, 0);
+ m, 0, 0);
lu_env_fini(&env);
llog_ctxt_put(ctxt);
- return cucb.idx;
+ return 0;
}
+LPROC_SEQ_FOPS_RO(mdd_changelog_users);
-static int lprocfs_rd_sync_perm(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int mdd_sync_perm_seq_show(struct seq_file *m, void *data)
{
- struct mdd_device *mdd = data;
+ struct mdd_device *mdd = m->private;
- LASSERT(mdd != NULL);
- return snprintf(page, count, "%d\n", mdd->mdd_sync_permission);
+ LASSERT(mdd != NULL);
+ return seq_printf(m, "%d\n", mdd->mdd_sync_permission);
}
-static int lprocfs_wr_sync_perm(struct file *file, const char *buffer,
- unsigned long count, void *data)
+static ssize_t
+mdd_sync_perm_seq_write(struct file *file, const char *buffer,
+ size_t count, loff_t *off)
{
- struct mdd_device *mdd = data;
+ struct seq_file *m = file->private_data;
+ struct mdd_device *mdd = m->private;
int val, rc;
LASSERT(mdd != NULL);
mdd->mdd_sync_permission = !!val;
return count;
}
+LPROC_SEQ_FOPS(mdd_sync_perm);
-static int lprocfs_rd_lfsck_speed_limit(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int mdd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
{
- struct mdd_device *mdd = data;
+ struct mdd_device *mdd = m->private;
LASSERT(mdd != NULL);
- *eof = 1;
-
- return lfsck_get_speed(mdd->mdd_bottom, page, count);
+ return lfsck_get_speed(m, mdd->mdd_bottom);
}
-static int lprocfs_wr_lfsck_speed_limit(struct file *file, const char *buffer,
- unsigned long count, void *data)
+static ssize_t
+mdd_lfsck_speed_limit_seq_write(struct file *file, const char *buffer,
+ size_t count, loff_t *off)
{
- struct mdd_device *mdd = data;
+ struct seq_file *m = file->private_data;
+ struct mdd_device *mdd = m->private;
__u32 val;
int rc;
rc = lfsck_set_speed(mdd->mdd_bottom, val);
return rc != 0 ? rc : count;
}
+LPROC_SEQ_FOPS(mdd_lfsck_speed_limit);
-static int lprocfs_rd_lfsck_async_windows(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int mdd_lfsck_async_windows_seq_show(struct seq_file *m, void *data)
{
- struct mdd_device *mdd = data;
- int rc;
+ struct mdd_device *mdd = m->private;
LASSERT(mdd != NULL);
- *eof = 1;
-
- rc = lfsck_get_windows(mdd->mdd_bottom, page, count);
-
- return rc != 0 ? rc : count;
+ return lfsck_get_windows(m, mdd->mdd_bottom);
}
-static int lprocfs_wr_lfsck_async_windows(struct file *file, const char *buffer,
- unsigned long count, void *data)
+static ssize_t
+mdd_lfsck_async_windows_seq_write(struct file *file, const char *buffer,
+ size_t count, loff_t *off)
{
- struct mdd_device *mdd = data;
+ struct seq_file *m = file->private_data;
+ struct mdd_device *mdd = m->private;
__u32 val;
int rc;
return rc != 0 ? rc : count;
}
+LPROC_SEQ_FOPS(mdd_lfsck_async_windows);
-static int lprocfs_rd_lfsck_namespace(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
{
- struct mdd_device *mdd = data;
- int rc;
+ struct mdd_device *mdd = m->private;
LASSERT(mdd != NULL);
- *eof = 1;
- rc = lfsck_dump(mdd->mdd_bottom, page, count, LT_NAMESPACE);
- return rc;
+ return lfsck_dump(m, mdd->mdd_bottom, LT_NAMESPACE);
}
+LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace);
-static int lprocfs_rd_lfsck_layout(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
{
- struct mdd_device *mdd = data;
+ struct mdd_device *mdd = m->private;
LASSERT(mdd != NULL);
- *eof = 1;
- return lfsck_dump(mdd->mdd_bottom, page, count, LT_LAYOUT);
+ return lfsck_dump(m, mdd->mdd_bottom, LT_LAYOUT);
}
-
-static struct lprocfs_vars lprocfs_mdd_obd_vars[] = {
- { "atime_diff", lprocfs_rd_atime_diff, lprocfs_wr_atime_diff, 0 },
- { "changelog_mask", lprocfs_rd_changelog_mask,
- lprocfs_wr_changelog_mask, 0 },
- { "changelog_users", lprocfs_rd_changelog_users, 0, 0},
- { "sync_permission", lprocfs_rd_sync_perm, lprocfs_wr_sync_perm, 0 },
- { "lfsck_speed_limit", lprocfs_rd_lfsck_speed_limit,
- lprocfs_wr_lfsck_speed_limit, 0 },
- { "lfsck_async_windows", lprocfs_rd_lfsck_async_windows,
- lprocfs_wr_lfsck_async_windows, 0 },
- { "lfsck_namespace", lprocfs_rd_lfsck_namespace, 0, 0 },
- { "lfsck_layout", lprocfs_rd_lfsck_layout, 0, 0 },
+LPROC_SEQ_FOPS_RO(mdd_lfsck_layout);
+
+static struct lprocfs_seq_vars lprocfs_mdd_obd_vars[] = {
+ { .name = "atime_diff",
+ .fops = &mdd_atime_diff_fops },
+ { .name = "changelog_mask",
+ .fops = &mdd_changelog_mask_fops },
+ { .name = "changelog_users",
+ .fops = &mdd_changelog_users_fops },
+ { .name = "sync_permission",
+ .fops = &mdd_sync_perm_fops },
+ { .name = "lfsck_speed_limit",
+ .fops = &mdd_lfsck_speed_limit_fops },
+ { .name = "lfsck_async_windows",
+ .fops = &mdd_lfsck_async_windows_fops },
+ { .name = "lfsck_namespace",
+ .fops = &mdd_lfsck_namespace_fops },
+ { .name = "lfsck_layout",
+ .fops = &mdd_lfsck_layout_fops },
{ 0 }
};
-static struct lprocfs_vars lprocfs_mdd_module_vars[] = {
- { "num_refs", lprocfs_rd_numrefs, 0, 0 },
- { 0 }
-};
-
-void lprocfs_mdd_init_vars(struct lprocfs_static_vars *lvars)
+int mdd_procfs_init(struct mdd_device *mdd, const char *name)
{
- lvars->module_vars = lprocfs_mdd_module_vars;
- lvars->obd_vars = lprocfs_mdd_obd_vars;
+ struct obd_device *obd = class_name2obd(name);
+ struct obd_type *type;
+ int rc;
+ ENTRY;
+
+ /* at the moment there is no linkage between lu_type
+ * and obd_type, so we lookup obd_type this way */
+ type = class_search_type(LUSTRE_MDD_NAME);
+
+ LASSERT(name != NULL);
+ LASSERT(type != NULL);
+ LASSERT(obd != NULL);
+
+ /* Find the type procroot and add the proc entry for this device */
+ obd->obd_vars = lprocfs_mdd_obd_vars;
+ mdd->mdd_proc_entry = lprocfs_seq_register(name, type->typ_procroot,
+ obd->obd_vars, mdd);
+ if (IS_ERR(mdd->mdd_proc_entry)) {
+ rc = PTR_ERR(mdd->mdd_proc_entry);
+ CERROR("Error %d setting up lprocfs for %s\n",
+ rc, name);
+ mdd->mdd_proc_entry = NULL;
+ GOTO(out, rc);
+ }
+ rc = 0;
+ EXIT;
+out:
+ if (rc)
+ mdd_procfs_fini(mdd);
+ return rc;
}
+void mdd_procfs_fini(struct mdd_device *mdd)
+{
+ if (mdd->mdd_proc_entry)
+ lprocfs_remove(&mdd->mdd_proc_entry);
+}
#ifdef LPROCFS
-static int lprocfs_ofd_rd_seqs(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_seqs_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- *eof = 1;
- return snprintf(page, count, "%u\n", ofd->ofd_seq_count);
+ return seq_printf(m, "%u\n", ofd->ofd_seq_count);
}
+LPROC_SEQ_FOPS_RO(ofd_seqs);
-static int lprocfs_ofd_rd_tot_dirty(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_tot_dirty_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd;
LASSERT(obd != NULL);
ofd = ofd_dev(obd->obd_lu_dev);
- *eof = 1;
- return snprintf(page, count, LPU64"\n", ofd->ofd_tot_dirty);
+ return seq_printf(m, LPU64"\n", ofd->ofd_tot_dirty);
}
+LPROC_SEQ_FOPS_RO(ofd_tot_dirty);
-static int lprocfs_ofd_rd_tot_granted(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_tot_granted_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd;
LASSERT(obd != NULL);
ofd = ofd_dev(obd->obd_lu_dev);
- *eof = 1;
- return snprintf(page, count, LPU64"\n", ofd->ofd_tot_granted);
+ return seq_printf(m, LPU64"\n", ofd->ofd_tot_granted);
}
+LPROC_SEQ_FOPS_RO(ofd_tot_granted);
-static int lprocfs_ofd_rd_tot_pending(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_tot_pending_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd;
LASSERT(obd != NULL);
ofd = ofd_dev(obd->obd_lu_dev);
- *eof = 1;
- return snprintf(page, count, LPU64"\n", ofd->ofd_tot_pending);
+ return seq_printf(m, LPU64"\n", ofd->ofd_tot_pending);
}
+LPROC_SEQ_FOPS_RO(ofd_tot_pending);
-static int lprocfs_ofd_rd_grant_precreate(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_grant_precreate_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct obd_device *obd = m->private;
LASSERT(obd != NULL);
- *eof = 1;
- return snprintf(page, count, "%ld\n",
- obd->obd_self_export->exp_filter_data.fed_grant);
+ return seq_printf(m, "%ld\n",
+ obd->obd_self_export->exp_filter_data.fed_grant);
}
+LPROC_SEQ_FOPS_RO(ofd_grant_precreate);
-static int lprocfs_ofd_rd_grant_ratio(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_grant_ratio_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd;
LASSERT(obd != NULL);
ofd = ofd_dev(obd->obd_lu_dev);
- *eof = 1;
- return snprintf(page, count, "%d%%\n",
- (int) ofd_grant_reserved(ofd, 100));
+ return seq_printf(m, "%d%%\n",
+ (int) ofd_grant_reserved(ofd, 100));
}
-static int lprocfs_ofd_wr_grant_ratio(struct file *file,
- const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_grant_ratio_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
int val;
int rc;
spin_unlock(&ofd->ofd_grant_lock);
return count;
}
+LPROC_SEQ_FOPS(ofd_grant_ratio);
-static int lprocfs_ofd_rd_precreate_batch(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_precreate_batch_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd;
LASSERT(obd != NULL);
ofd = ofd_dev(obd->obd_lu_dev);
- *eof = 1;
- return snprintf(page, count, "%d\n", ofd->ofd_precreate_batch);
+ return seq_printf(m, "%d\n", ofd->ofd_precreate_batch);
}
-static int lprocfs_ofd_wr_precreate_batch(struct file *file,
- const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_precreate_batch_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
int val;
int rc;
spin_unlock(&ofd->ofd_batch_lock);
return count;
}
+LPROC_SEQ_FOPS(ofd_precreate_batch);
-static int lprocfs_ofd_rd_last_id(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_last_id_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd;
struct ofd_seq *oseq = NULL;
int retval = 0, rc;
fid_idif_seq(ostid_id(&oseq->os_oi),
ofd->ofd_lut.lut_lsd.lsd_osd_index) :
ostid_seq(&oseq->os_oi);
- rc = snprintf(page, count, DOSTID"\n", seq,
- ostid_id(&oseq->os_oi));
+ rc = seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
if (rc < 0) {
retval = rc;
break;
}
- page += rc;
- count -= rc;
retval += rc;
}
read_unlock(&ofd->ofd_seq_list_lock);
return retval;
}
+LPROC_SEQ_FOPS_RO(ofd_last_id);
-int lprocfs_ofd_rd_fmd_max_num(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_fmd_max_num_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- int rc;
+ struct obd_device *obd = m->private;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- rc = snprintf(page, count, "%u\n", ofd->ofd_fmd_max_num);
- return rc;
+ return seq_printf(m, "%u\n", ofd->ofd_fmd_max_num);
}
-int lprocfs_ofd_wr_fmd_max_num(struct file *file, const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_fmd_max_num_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
int val;
int rc;
ofd->ofd_fmd_max_num = val;
return count;
}
+LPROC_SEQ_FOPS(ofd_fmd_max_num);
-int lprocfs_ofd_rd_fmd_max_age(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_fmd_max_age_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- int rc;
+ struct obd_device *obd = m->private;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- rc = snprintf(page, count, "%ld\n", ofd->ofd_fmd_max_age / HZ);
- return rc;
+ return seq_printf(m, "%ld\n", ofd->ofd_fmd_max_age / HZ);
}
-int lprocfs_ofd_wr_fmd_max_age(struct file *file, const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_fmd_max_age_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
int val;
int rc;
ofd->ofd_fmd_max_age = val * HZ;
return count;
}
+LPROC_SEQ_FOPS(ofd_fmd_max_age);
-static int lprocfs_ofd_rd_capa(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_capa_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
- int rc;
+ struct obd_device *obd = m->private;
- rc = snprintf(page, count, "capability on: %s\n",
- obd->u.filter.fo_fl_oss_capa ? "oss" : "");
- return rc;
+ return seq_printf(m, "capability on: %s\n",
+ obd->u.filter.fo_fl_oss_capa ? "oss" : "");
}
-static int lprocfs_ofd_wr_capa(struct file *file, const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_capa_seq_write(struct file *file, const char *__user buffer, size_t count,
+ loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
int val, rc;
rc = lprocfs_write_helper(buffer, count, &val);
val ? "enabled" : "disabled");
return count;
}
+LPROC_SEQ_FOPS(ofd_capa);
-static int lprocfs_ofd_rd_capa_count(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_capa_count_seq_show(struct seq_file *m, void *data)
{
- return snprintf(page, count, "%d %d\n",
- capa_count[CAPA_SITE_CLIENT],
- capa_count[CAPA_SITE_SERVER]);
+ return seq_printf(m, "%d %d\n", capa_count[CAPA_SITE_CLIENT],
+ capa_count[CAPA_SITE_SERVER]);
}
+LPROC_SEQ_FOPS_RO(ofd_capa_count);
-int lprocfs_ofd_rd_degraded(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_degraded_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- return snprintf(page, count, "%u\n", ofd->ofd_raid_degraded);
+ return seq_printf(m, "%u\n", ofd->ofd_raid_degraded);
}
-int lprocfs_ofd_wr_degraded(struct file *file, const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_degraded_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
int val, rc;
spin_lock(&ofd->ofd_flags_lock);
ofd->ofd_raid_degraded = !!val;
spin_unlock(&ofd->ofd_flags_lock);
-
return count;
}
+LPROC_SEQ_FOPS(ofd_degraded);
-int lprocfs_ofd_rd_fstype(char *page, char **start, off_t off, int count,
- int *eof, void *data)
+static int ofd_fstype_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
struct lu_device *d;
LASSERT(ofd->ofd_osd);
d = &ofd->ofd_osd->dd_lu_dev;
LASSERT(d->ld_type);
- return snprintf(page, count, "%s\n", d->ld_type->ldt_name);
+ return seq_printf(m, "%s\n", d->ld_type->ldt_name);
}
+LPROC_SEQ_FOPS_RO(ofd_fstype);
-int lprocfs_ofd_rd_syncjournal(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_syncjournal_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- int rc;
- rc = snprintf(page, count, "%u\n", ofd->ofd_syncjournal);
- return rc;
+ return seq_printf(m, "%u\n", ofd->ofd_syncjournal);
}
-int lprocfs_ofd_wr_syncjournal(struct file *file, const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_syncjournal_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
int val;
int rc;
return count;
}
+LPROC_SEQ_FOPS(ofd_syncjournal);
/* This must be longer than the longest string below */
#define SYNC_STATES_MAXLEN 16
"blocking",
"always" };
-int lprocfs_ofd_rd_sync_lock_cancel(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
+ struct obd_device *obd = m->private;
struct lu_target *tgt = obd->u.obt.obt_lut;
- int rc;
- rc = snprintf(page, count, "%s\n",
- sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
- return rc;
+ return seq_printf(m, "%s\n",
+ sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
}
-int lprocfs_ofd_wr_sync_lock_cancel(struct file *file,
- const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct lu_target *tgt = obd->u.obt.obt_lut;
char kernbuf[SYNC_STATES_MAXLEN];
int val = -1;
spin_unlock(&tgt->lut_flags_lock);
return count;
}
+LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
-int lprocfs_ofd_rd_grant_compat_disable(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_grant_compat_disable_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- int rc;
+ struct obd_device *obd = m->private;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- rc = snprintf(page, count, "%u\n", ofd->ofd_grant_compat_disable);
- return rc;
+ return seq_printf(m, "%u\n", ofd->ofd_grant_compat_disable);
}
-int lprocfs_ofd_wr_grant_compat_disable(struct file *file,
- const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_grant_compat_disable_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
int val;
int rc;
return count;
}
+LPROC_SEQ_FOPS(ofd_grant_compat_disable);
-int lprocfs_ofd_rd_soft_sync_limit(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_soft_sync_limit_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- return lprocfs_rd_uint(page, start, off, count, eof,
- &ofd->ofd_soft_sync_limit);
+ return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
}
-int lprocfs_ofd_wr_soft_sync_limit(struct file *file, const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- return lprocfs_wr_uint(file, buffer, count, &ofd->ofd_soft_sync_limit);
+ return lprocfs_uint_seq_write(file, buffer, count,
+ (loff_t *) &ofd->ofd_soft_sync_limit);
}
+LPROC_SEQ_FOPS(ofd_soft_sync_limit);
-static int lprocfs_rd_lfsck_speed_limit(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- *eof = 1;
-
- return lfsck_get_speed(ofd->ofd_osd, page, count);
+ return lfsck_get_speed(m, ofd->ofd_osd);
}
-static int lprocfs_wr_lfsck_speed_limit(struct file *file,
- const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
__u32 val;
int rc;
return rc != 0 ? rc : count;
}
+LPROC_SEQ_FOPS(ofd_lfsck_speed_limit);
-static int lprocfs_rd_lfsck_layout(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
-
- *eof = 1;
+ struct obd_device *obd = m->private;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- return lfsck_dump(ofd->ofd_osd, page, count, LT_LAYOUT);
+ return lfsck_dump(m, ofd->ofd_osd, LT_LAYOUT);
}
+LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
-static int lprocfs_rd_lfsck_verify_pfid(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *obd = data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
-
- *eof = 1;
+ struct obd_device *obd = m->private;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- return snprintf(page, count,
- "switch: %s\ndetected: "LPU64"\nrepaired: "LPU64"\n",
- ofd->ofd_lfsck_verify_pfid ? "on" : "off",
- ofd->ofd_inconsistency_self_detected,
- ofd->ofd_inconsistency_self_repaired);
+ return seq_printf(m,
+ "switch: %s\ndetected: "LPU64"\nrepaired: "LPU64"\n",
+ ofd->ofd_lfsck_verify_pfid ? "on" : "off",
+ ofd->ofd_inconsistency_self_detected,
+ ofd->ofd_inconsistency_self_repaired);
}
-static int lprocfs_wr_lfsck_verify_pfid(struct file *file,
- const char __user *buffer,
- unsigned long count, void *data)
+static ssize_t
+ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct obd_device *obd = data;
+ struct seq_file *m = file->private_data;
+ struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
__u32 val;
int rc;
return count;
}
-
-static struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
- { "uuid", lprocfs_rd_uuid, 0, 0 },
- { "blocksize", lprocfs_rd_blksize, 0, 0 },
- { "kbytestotal", lprocfs_rd_kbytestotal, 0, 0 },
- { "kbytesfree", lprocfs_rd_kbytesfree, 0, 0 },
- { "kbytesavail", lprocfs_rd_kbytesavail, 0, 0 },
- { "filestotal", lprocfs_rd_filestotal, 0, 0 },
- { "filesfree", lprocfs_rd_filesfree, 0, 0 },
- { "seqs_allocated", lprocfs_ofd_rd_seqs, 0, 0 },
- { "fstype", lprocfs_ofd_rd_fstype, 0, 0 },
- { "last_id", lprocfs_ofd_rd_last_id, 0, 0 },
- { "tot_dirty", lprocfs_ofd_rd_tot_dirty, 0, 0 },
- { "tot_pending", lprocfs_ofd_rd_tot_pending, 0, 0 },
- { "tot_granted", lprocfs_ofd_rd_tot_granted, 0, 0 },
- { "grant_precreate", lprocfs_ofd_rd_grant_precreate, 0, 0 },
- { "grant_ratio", lprocfs_ofd_rd_grant_ratio,
- lprocfs_ofd_wr_grant_ratio, 0, 0 },
- { "precreate_batch", lprocfs_ofd_rd_precreate_batch,
- lprocfs_ofd_wr_precreate_batch, 0 },
- { "recovery_status", lprocfs_obd_rd_recovery_status, 0, 0 },
- { "recovery_time_soft", lprocfs_obd_rd_recovery_time_soft,
- lprocfs_obd_wr_recovery_time_soft, 0},
- { "recovery_time_hard", lprocfs_obd_rd_recovery_time_hard,
- lprocfs_obd_wr_recovery_time_hard, 0},
- { "evict_client", 0, lprocfs_wr_evict_client, 0,
- &lprocfs_evict_client_fops},
- { "num_exports", lprocfs_rd_num_exports, 0, 0 },
- { "degraded", lprocfs_ofd_rd_degraded,
- lprocfs_ofd_wr_degraded, 0},
- { "sync_journal", lprocfs_ofd_rd_syncjournal,
- lprocfs_ofd_wr_syncjournal, 0 },
- { "sync_on_lock_cancel", lprocfs_ofd_rd_sync_lock_cancel,
- lprocfs_ofd_wr_sync_lock_cancel, 0 },
- { "instance", lprocfs_target_rd_instance, 0 },
- { "ir_factor", lprocfs_obd_rd_ir_factor,
- lprocfs_obd_wr_ir_factor, 0},
- { "grant_compat_disable", lprocfs_ofd_rd_grant_compat_disable,
- lprocfs_ofd_wr_grant_compat_disable, 0 },
- { "client_cache_count", lprocfs_ofd_rd_fmd_max_num,
- lprocfs_ofd_wr_fmd_max_num, 0 },
- { "client_cache_seconds", lprocfs_ofd_rd_fmd_max_age,
- lprocfs_ofd_wr_fmd_max_age, 0 },
- { "capa", lprocfs_ofd_rd_capa,
- lprocfs_ofd_wr_capa, 0 },
- { "capa_count", lprocfs_ofd_rd_capa_count, 0, 0 },
- { "job_cleanup_interval", lprocfs_rd_job_interval,
- lprocfs_wr_job_interval, 0},
- { "soft_sync_limit", lprocfs_ofd_rd_soft_sync_limit,
- lprocfs_ofd_wr_soft_sync_limit, 0},
- { "lfsck_speed_limit", lprocfs_rd_lfsck_speed_limit,
- lprocfs_wr_lfsck_speed_limit, 0 },
- { "lfsck_layout", lprocfs_rd_lfsck_layout, 0, 0 },
- { "lfsck_verify_pfid", lprocfs_rd_lfsck_verify_pfid,
- lprocfs_wr_lfsck_verify_pfid, 0 },
- { 0 }
-};
-
-static struct lprocfs_vars lprocfs_ofd_module_vars[] = {
- { "num_refs", lprocfs_rd_numrefs, 0, 0 },
+LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
+
+LPROC_SEQ_FOPS_RO_TYPE(ofd, uuid);
+LPROC_SEQ_FOPS_RO_TYPE(ofd, blksize);
+LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytestotal);
+LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesfree);
+LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesavail);
+LPROC_SEQ_FOPS_RO_TYPE(ofd, filestotal);
+LPROC_SEQ_FOPS_RO_TYPE(ofd, filesfree);
+
+LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
+LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_soft);
+LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_hard);
+LPROC_SEQ_FOPS_WO_TYPE(ofd, evict_client);
+LPROC_SEQ_FOPS_RO_TYPE(ofd, num_exports);
+LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
+LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
+LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
+
+struct lprocfs_seq_vars lprocfs_ofd_obd_vars[] = {
+ { .name = "uuid",
+ .fops = &ofd_uuid_fops },
+ { .name = "blocksize",
+ .fops = &ofd_blksize_fops },
+ { .name = "kbytestotal",
+ .fops = &ofd_kbytestotal_fops },
+ { .name = "kbytesfree",
+ .fops = &ofd_kbytesfree_fops },
+ { .name = "kbytesavail",
+ .fops = &ofd_kbytesavail_fops },
+ { .name = "filestotal",
+ .fops = &ofd_filestotal_fops },
+ { .name = "filesfree",
+ .fops = &ofd_filesfree_fops },
+ { .name = "seqs_allocated",
+ .fops = &ofd_seqs_fops },
+ { .name = "fstype",
+ .fops = &ofd_fstype_fops },
+ { .name = "last_id",
+ .fops = &ofd_last_id_fops },
+ { .name = "tot_dirty",
+ .fops = &ofd_tot_dirty_fops },
+ { .name = "tot_pending",
+ .fops = &ofd_tot_pending_fops },
+ { .name = "tot_granted",
+ .fops = &ofd_tot_granted_fops },
+ { .name = "grant_precreate",
+ .fops = &ofd_grant_precreate_fops },
+ { .name = "grant_ratio",
+ .fops = &ofd_grant_ratio_fops },
+ { .name = "precreate_batch",
+ .fops = &ofd_precreate_batch_fops },
+ { .name = "recovery_status",
+ .fops = &ofd_recovery_status_fops },
+ { .name = "recovery_time_soft",
+ .fops = &ofd_recovery_time_soft_fops },
+ { .name = "recovery_time_hard",
+ .fops = &ofd_recovery_time_hard_fops },
+ { .name = "evict_client",
+ .fops = &ofd_evict_client_fops },
+ { .name = "num_exports",
+ .fops = &ofd_num_exports_fops },
+ { .name = "degraded",
+ .fops = &ofd_degraded_fops },
+ { .name = "sync_journal",
+ .fops = &ofd_syncjournal_fops },
+ { .name = "sync_on_lock_cancel",
+ .fops = &ofd_sync_lock_cancel_fops },
+ { .name = "instance",
+ .fops = &ofd_target_instance_fops },
+ { .name = "ir_factor",
+ .fops = &ofd_ir_factor_fops },
+ { .name = "grant_compat_disable",
+ .fops = &ofd_grant_compat_disable_fops },
+ { .name = "client_cache_count",
+ .fops = &ofd_fmd_max_num_fops },
+ { .name = "client_cache_seconds",
+ .fops = &ofd_fmd_max_age_fops },
+ { .name = "capa",
+ .fops = &ofd_capa_fops },
+ { .name = "capa_count",
+ .fops = &ofd_capa_count_fops },
+ { .name = "job_cleanup_interval",
+ .fops = &ofd_job_interval_fops },
+ { .name = "soft_sync_limit",
+ .fops = &ofd_soft_sync_limit_fops },
+ { .name = "lfsck_speed_limit",
+ .fops = &ofd_lfsck_speed_limit_fops },
+ { .name = "lfsck_layout",
+ .fops = &ofd_lfsck_layout_fops },
+ { .name = "lfsck_verify_pfid",
+ .fops = &ofd_lfsck_verify_pfid_fops },
{ 0 }
};
-void lprocfs_ofd_init_vars(struct lprocfs_static_vars *lvars)
-{
- lvars->module_vars = lprocfs_ofd_module_vars;
- lvars->obd_vars = lprocfs_ofd_obd_vars;
-}
-
void ofd_stats_counter_init(struct lprocfs_stats *stats)
{
LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
switch (cfg->lcfg_command) {
case LCFG_PARAM: {
- struct lprocfs_static_vars lvars;
-
+ struct obd_device *obd = ofd_obd(m);
/* For interoperability */
struct cfg_interop_param *ptr = NULL;
struct lustre_cfg *old_cfg = NULL;
break;
}
- lprocfs_ofd_init_vars(&lvars);
- rc = class_process_proc_param(PARAM_OST, lvars.obd_vars, cfg,
+ rc = class_process_proc_seq_param(PARAM_OST, obd->obd_vars, cfg,
d->ld_obd);
if (rc > 0 || rc == -ENOSYS) {
CDEBUG(D_CONFIG, "pass param %s down the stack.\n",
.ldo_prepare = ofd_prepare,
};
+LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);
+
static int ofd_procfs_init(struct ofd_device *ofd)
{
- struct lprocfs_static_vars lvars;
struct obd_device *obd = ofd_obd(ofd);
cfs_proc_dir_entry_t *entry;
int rc = 0;
/* lprocfs must be setup before the ofd so state can be safely added
* to /proc incrementally as the ofd is setup */
- lprocfs_ofd_init_vars(&lvars);
- rc = lprocfs_obd_setup(obd, lvars.obd_vars);
+ obd->obd_vars = lprocfs_ofd_obd_vars;
+ rc = lprocfs_seq_obd_setup(obd);
if (rc) {
CERROR("%s: lprocfs_obd_setup failed: %d.\n",
obd->obd_name, rc);
obd->obd_uses_nid_stats = 1;
- entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL);
+ entry = lprocfs_seq_register("exports", obd->obd_proc_entry, NULL,
+ NULL);
if (IS_ERR(entry)) {
rc = PTR_ERR(entry);
CERROR("%s: error %d setting up lprocfs for %s\n",
obd->obd_proc_exports_entry = entry;
entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
- lprocfs_nid_stats_clear_read,
- lprocfs_nid_stats_clear_write, obd, NULL);
+#ifndef HAVE_ONLY_PROCFS_SEQ
+ NULL, NULL,
+#endif
+ obd, &lprocfs_nid_stats_clear_fops);
if (IS_ERR(entry)) {
rc = PTR_ERR(entry);
CERROR("%s: add proc entry 'clear' failed: %d.\n",
rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST,
ofd_stats_counter_init);
if (rc)
- GOTO(remove_entry_clear, rc);
+ GOTO(obd_cleanup, rc);
RETURN(0);
-remove_entry_clear:
- lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
obd_cleanup:
lprocfs_obd_cleanup(obd);
lprocfs_free_obd_stats(obd);
return rc;
}
+/**
+ * ofd_procfs_add_brw_stats_symlink - expose osd stats to ofd layer
+ *
+ * The osd interfaces to the backend file system exposes useful data
+ * such as brw_stats and read or write cache states. This same data
+ * needs to be exposed into the obdfilter (ofd) layer to maintain
+ * backwards compatibility. This function creates the symlinks in the
+ * proc layer to enable this.
+ */
static void ofd_procfs_add_brw_stats_symlink(struct ofd_device *ofd)
{
struct obd_device *obd = ofd_obd(ofd);
struct obd_device *osd_obd = ofd->ofd_osd_exp->exp_obd;
- cfs_proc_dir_entry_t *osd_root = osd_obd->obd_type->typ_procroot;
- cfs_proc_dir_entry_t *osd_dir;
- osd_dir = lprocfs_srch(osd_root, obd->obd_name);
- if (osd_dir == NULL)
+ if (obd->obd_proc_entry == NULL)
return;
- if (lprocfs_srch(osd_dir, "brw_stats") != NULL)
- lprocfs_add_symlink("brw_stats", obd->obd_proc_entry,
- "../../%s/%s/brw_stats",
- osd_root->name, osd_dir->name);
-
- if (lprocfs_srch(osd_dir, "read_cache_enable") != NULL)
- lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry,
- "../../%s/%s/read_cache_enable",
- osd_root->name, osd_dir->name);
-
- if (lprocfs_srch(osd_dir, "readcache_max_filesize") != NULL)
- lprocfs_add_symlink("readcache_max_filesize",
- obd->obd_proc_entry,
- "../../%s/%s/readcache_max_filesize",
- osd_root->name, osd_dir->name);
-
- if (lprocfs_srch(osd_dir, "writethrough_cache_enable") != NULL)
- lprocfs_add_symlink("writethrough_cache_enable",
- obd->obd_proc_entry,
- "../../%s/%s/writethrough_cache_enable",
- osd_root->name, osd_dir->name);
+ lprocfs_add_symlink("brw_stats", obd->obd_proc_entry,
+ "../../%s/%s/brw_stats",
+ osd_obd->obd_type->typ_name, obd->obd_name);
+
+ lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry,
+ "../../%s/%s/read_cache_enable",
+ osd_obd->obd_type->typ_name, obd->obd_name);
+
+ lprocfs_add_symlink("readcache_max_filesize",
+ obd->obd_proc_entry,
+ "../../%s/%s/readcache_max_filesize",
+ osd_obd->obd_type->typ_name, obd->obd_name);
+
+ lprocfs_add_symlink("writethrough_cache_enable",
+ obd->obd_proc_entry,
+ "../../%s/%s/writethrough_cache_enable",
+ osd_obd->obd_type->typ_name, obd->obd_name);
}
static void ofd_procfs_fini(struct ofd_device *ofd)
{
struct obd_device *obd = ofd_obd(ofd);
- lprocfs_remove_proc_entry("writethrough_cache_enable",
- obd->obd_proc_entry);
- lprocfs_remove_proc_entry("readcache_max_filesize",
- obd->obd_proc_entry);
- lprocfs_remove_proc_entry("read_cache_enable", obd->obd_proc_entry);
- lprocfs_remove_proc_entry("brw_stats", obd->obd_proc_entry);
- lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
lprocfs_free_per_client_stats(obd);
lprocfs_obd_cleanup(obd);
lprocfs_free_obd_stats(obd);
int __init ofd_init(void)
{
- struct lprocfs_static_vars lvars;
int rc;
rc = lu_kmem_init(ofd_caches);
return(rc);
}
- lprocfs_ofd_init_vars(&lvars);
-
rc = class_register_type(&ofd_obd_ops, NULL, true, NULL,
#ifndef HAVE_ONLY_PROCFS_SEQ
- lvars.module_vars,
+ NULL,
#endif
LUSTRE_OST_NAME, &ofd_device_type);
return rc;
/* lproc_ofd.c */
#ifdef LPROCFS
-void lprocfs_ofd_init_vars(struct lprocfs_static_vars *lvars);
+extern struct lprocfs_seq_vars lprocfs_ofd_obd_vars[];
void ofd_stats_counter_init(struct lprocfs_stats *stats);
#else
-static void lprocfs_ofd_init_vars(struct lprocfs_static_vars *lvars)
-{
- memset(lvars, 0, sizeof(*lvars));
-}
static inline void ofd_stats_counter_init(struct lprocfs_stats *stats) {}
#endif
git://git.whamcloud.com / fs / lustre-release.git / commitdiff