X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmdd%2Fmdd_lproc.c;h=1329852e12bc8c162704d2d9e5542ebe41f7fa20;hb=aff399789fe456d8dc58f49cd490c94916b2a46f;hp=e3cd4ee064e9def72f961132d5305562e8c08e37;hpb=e2af7fb3c91dfb13d34d8e1b2f2df8c09621f768;p=fs%2Flustre-release.git diff --git a/lustre/mdd/mdd_lproc.c b/lustre/mdd/mdd_lproc.c index e3cd4ee..1329852 100644 --- a/lustre/mdd/mdd_lproc.c +++ b/lustre/mdd/mdd_lproc.c @@ -26,6 +26,8 @@ /* * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2012, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -40,93 +42,26 @@ #define DEBUG_SUBSYSTEM S_MDS -#include -#include #include #include -#include #include #include -#include -#include -#include #include - #include "mdd_internal.h" -static const char *mdd_counter_names[LPROC_MDD_NR] = { -}; - -int mdd_procfs_init(struct mdd_device *mdd, const char *name) +static ssize_t +mdd_atime_diff_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct lprocfs_static_vars lvars; - struct lu_device *ld = &mdd->mdd_md_dev.md_lu_dev; - struct obd_type *type; - int rc; - ENTRY; - - type = ld->ld_type->ldt_obd_type; - - 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 = lu_time_init(&mdd->mdd_stats, - mdd->mdd_proc_entry, - mdd_counter_names, ARRAY_SIZE(mdd_counter_names)); - - EXIT; -out: - if (rc) - mdd_procfs_fini(mdd); - return rc; -} - -int mdd_procfs_fini(struct mdd_device *mdd) -{ - if (mdd->mdd_stats) - lu_time_fini(&mdd->mdd_stats); - - if (mdd->mdd_proc_entry) { - lprocfs_remove(&mdd->mdd_proc_entry); - mdd->mdd_proc_entry = NULL; - } - RETURN(0); -} - -void mdd_lprocfs_time_start(const struct lu_env *env) -{ - lu_lprocfs_time_start(env); -} - -void mdd_lprocfs_time_end(const struct lu_env *env, struct mdd_device *mdd, - int idx) -{ - lu_lprocfs_time_end(env, mdd->mdd_stats, idx); -} - -static int lprocfs_wr_atime_diff(struct file *file, const char *buffer, - unsigned long count, void *data) -{ - 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; - if (cfs_copy_from_user(kernbuf, buffer, count)) + if (copy_from_user(kernbuf, buffer, count)) return -EFAULT; kernbuf[count] = '\0'; @@ -139,150 +74,125 @@ static int lprocfs_wr_atime_diff(struct file *file, const char *buffer, 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); + seq_printf(m, "%lu\n", mdd->mdd_atime_diff); + return 0; } - +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 __user *buffer, + size_t count, loff_t *off) { - struct mdd_device *mdd = data; - char *kernbuf; - int rc; - ENTRY; - - if (count >= CFS_PAGE_SIZE) - RETURN(-EINVAL); - OBD_ALLOC(kernbuf, CFS_PAGE_SIZE); - if (kernbuf == NULL) - RETURN(-ENOMEM); - if (cfs_copy_from_user(kernbuf, buffer, count)) - GOTO(out, rc = -EFAULT); - kernbuf[count] = 0; - - rc = cfs_str2mask(kernbuf, changelog_type2str, &mdd->mdd_cl.mc_mask, - CHANGELOG_MINMASK, CHANGELOG_ALLMASK); - if (rc == 0) - rc = count; + struct seq_file *m = file->private_data; + struct mdd_device *mdd = m->private; + char *kernbuf; + int rc; + ENTRY; + + if (count >= PAGE_CACHE_SIZE) + RETURN(-EINVAL); + OBD_ALLOC(kernbuf, PAGE_CACHE_SIZE); + if (kernbuf == NULL) + RETURN(-ENOMEM); + if (copy_from_user(kernbuf, buffer, count)) + GOTO(out, rc = -EFAULT); + kernbuf[count] = 0; + + rc = cfs_str2mask(kernbuf, changelog_type2str, &mdd->mdd_cl.mc_mask, + CHANGELOG_MINMASK, CHANGELOG_ALLMASK); + if (rc == 0) + rc = count; out: - OBD_FREE(kernbuf, CFS_PAGE_SIZE); - return rc; + OBD_FREE(kernbuf, PAGE_CACHE_SIZE); + return rc; } +LPROC_SEQ_FOPS(mdd_changelog_mask); -struct cucb_data { - char *page; - int count; - int idx; -}; - -static int lprocfs_changelog_users_cb(struct llog_handle *llh, - struct llog_rec_hdr *hdr, void *data) +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 mdd_device *mdd = data; - struct llog_ctxt *ctxt; - struct cucb_data cucb; - __u64 cur; - - *eof = 1; - - ctxt = llog_get_context(mdd2obd_dev(mdd),LLOG_CHANGELOG_USER_ORIG_CTXT); + struct lu_env env; + struct mdd_device *mdd = m->private; + struct llog_ctxt *ctxt; + __u64 cur; + int rc; + + ctxt = llog_get_context(mdd2obd_dev(mdd), + LLOG_CHANGELOG_USER_ORIG_CTXT); if (ctxt == NULL) return -ENXIO; LASSERT(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT); - cfs_spin_lock(&mdd->mdd_cl.mc_lock); - cur = mdd->mdd_cl.mc_index; - cfs_spin_unlock(&mdd->mdd_cl.mc_lock); + rc = lu_env_init(&env, LCT_LOCAL); + if (rc) { + llog_ctxt_put(ctxt); + return rc; + } - cucb.count = count; - cucb.page = page; - cucb.idx = 0; + spin_lock(&mdd->mdd_cl.mc_lock); + cur = mdd->mdd_cl.mc_index; + spin_unlock(&mdd->mdd_cl.mc_lock); - cucb.idx += snprintf(cucb.page + cucb.idx, cucb.count - cucb.idx, - "current index: "LPU64"\n", cur); + seq_printf(m, "current index: "LPU64"\n", cur); + seq_printf(m, "%-5s %s\n", "ID", "index"); - cucb.idx += snprintf(cucb.page + cucb.idx, cucb.count - cucb.idx, - "%-5s %s\n", "ID", "index"); + llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb, + m, 0, 0); - llog_cat_process(ctxt->loc_handle, lprocfs_changelog_users_cb, - &cucb, 0, 0); - - llog_ctxt_put(ctxt); - return cucb.idx; -} - -#ifdef HAVE_QUOTA_SUPPORT -static int mdd_lprocfs_quota_rd_type(char *page, char **start, off_t off, - int count, int *eof, void *data) -{ - struct mdd_device *mdd = data; - return lprocfs_quota_rd_type(page, start, off, count, eof, - mdd->mdd_obd_dev); + lu_env_fini(&env); + llog_ctxt_put(ctxt); + return 0; } +LPROC_SEQ_FOPS_RO(mdd_changelog_users); -static int mdd_lprocfs_quota_wr_type(struct file *file, const char *buffer, - unsigned long count, void *data) +static int mdd_sync_perm_seq_show(struct seq_file *m, void *data) { - struct mdd_device *mdd = data; - return lprocfs_quota_wr_type(file, buffer, count, mdd->mdd_obd_dev); -} -#endif - -static int lprocfs_rd_sync_perm(char *page, char **start, off_t off, - int count, int *eof, 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); + seq_printf(m, "%d\n", mdd->mdd_sync_permission); + return 0; } -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 __user *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); @@ -293,28 +203,137 @@ static int lprocfs_wr_sync_perm(struct file *file, const char *buffer, mdd->mdd_sync_permission = !!val; return count; } +LPROC_SEQ_FOPS(mdd_sync_perm); -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}, -#ifdef HAVE_QUOTA_SUPPORT - { "quota_type", mdd_lprocfs_quota_rd_type, - mdd_lprocfs_quota_wr_type, 0 }, -#endif - { "sync_permission", lprocfs_rd_sync_perm, lprocfs_wr_sync_perm, 0 }, - { 0 } -}; +static int mdd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data) +{ + struct mdd_device *mdd = m->private; + + LASSERT(mdd != NULL); + return lfsck_get_speed(m, mdd->mdd_bottom); +} + +static ssize_t +mdd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct mdd_device *mdd = m->private; + __u32 val; + int rc; + + LASSERT(mdd != NULL); + rc = lprocfs_write_helper(buffer, count, &val); + if (rc != 0) + return rc; + + rc = lfsck_set_speed(mdd->mdd_bottom, val); + return rc != 0 ? rc : count; +} +LPROC_SEQ_FOPS(mdd_lfsck_speed_limit); + +static int mdd_lfsck_async_windows_seq_show(struct seq_file *m, void *data) +{ + struct mdd_device *mdd = m->private; + + LASSERT(mdd != NULL); + return lfsck_get_windows(m, mdd->mdd_bottom); +} + +static ssize_t +mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct mdd_device *mdd = m->private; + __u32 val; + int rc; + + LASSERT(mdd != NULL); + rc = lprocfs_write_helper(buffer, count, &val); + if (rc == 0) + rc = lfsck_set_windows(mdd->mdd_bottom, val); + + return rc != 0 ? rc : count; +} +LPROC_SEQ_FOPS(mdd_lfsck_async_windows); + +static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data) +{ + struct mdd_device *mdd = m->private; + + LASSERT(mdd != NULL); + + return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE); +} +LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace); + +static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data) +{ + struct mdd_device *mdd = m->private; -static struct lprocfs_vars lprocfs_mdd_module_vars[] = { - { "num_refs", lprocfs_rd_numrefs, 0, 0 }, - { 0 } + LASSERT(mdd != NULL); + + return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT); +} +LPROC_SEQ_FOPS_RO(mdd_lfsck_layout); + +static struct lprocfs_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 }, + { NULL } }; -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 = mdd2obd_dev(mdd); + 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_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); +}