X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Fmdd%2Fmdd_lproc.c;h=b291ffdbdc76c1ea5e0cf53ce9b723c6d233ee38;hb=2104ed0f0da3651f0cb4ab0c78a1037891d7cb4f;hp=c15696c9cdd3a1e54e84976b71598f0d4cfea2d5;hpb=9eccc6cc308e931d9c6040714caffdaef62a56f9;p=fs%2Flustre-release.git diff --git a/lustre/mdd/mdd_lproc.c b/lustre/mdd/mdd_lproc.c index c15696c..b291ffd 100644 --- a/lustre/mdd/mdd_lproc.c +++ b/lustre/mdd/mdd_lproc.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -28,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,98 +40,28 @@ * Author: Wang Di */ -#ifndef EXPORT_SYMTAB -# define EXPORT_SYMTAB -#endif #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) -{ - 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) +static ssize_t +mdd_atime_diff_seq_write(struct file *file, const char __user *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; - if (cfs_copy_from_user(kernbuf, buffer, count)) + if (copy_from_user(kernbuf, buffer, count)) return -EFAULT; kernbuf[count] = '\0'; @@ -144,182 +74,327 @@ 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_SIZE) + RETURN(-EINVAL); + OBD_ALLOC(kernbuf, PAGE_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_SIZE); + return rc; } +LPROC_SEQ_FOPS(mdd_changelog_mask); -struct cucb_data { - char *page; - int count; - int idx; -}; +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 seq_file *m = data; + + LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN); -static int lprocfs_changelog_users_cb(struct llog_handle *llh, - struct llog_rec_hdr *hdr, void *data) + rec = (struct llog_changelog_user_rec *)hdr; + + seq_printf(m, CHANGELOG_USER_PREFIX"%-3d "LPU64"\n", + rec->cur_id, rec->cur_endrec); + return 0; +} + +static int mdd_changelog_users_seq_show(struct seq_file *m, void *data) { - struct llog_changelog_user_rec *rec; - struct cucb_data *cucb = (struct cucb_data *)data; + 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); - LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN); + rc = lu_env_init(&env, LCT_LOCAL); + if (rc) { + llog_ctxt_put(ctxt); + return rc; + } - rec = (struct llog_changelog_user_rec *)hdr; + 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, - CHANGELOG_USER_PREFIX"%-3d "LPU64"\n", - rec->cur_id, rec->cur_endrec); - if (cucb->idx >= cucb->count) - return -ENOSPC; + seq_printf(m, "current index: "LPU64"\n", cur); + seq_printf(m, "%-5s %s\n", "ID", "index"); - return 0; + llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb, + m, 0, 0); + + lu_env_fini(&env); + llog_ctxt_put(ctxt); + return 0; } +LPROC_SEQ_FOPS_RO(mdd_changelog_users); -static int lprocfs_rd_changelog_users(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int mdd_changelog_size_ctxt(const struct lu_env *env, + struct mdd_device *mdd, + int index, __u64 *val) { - struct mdd_device *mdd = data; - struct llog_ctxt *ctxt; - struct cucb_data cucb; - __u64 cur; + struct llog_ctxt *ctxt; - *eof = 1; + ctxt = llog_get_context(mdd2obd_dev(mdd), + index); + if (ctxt == NULL) + return -ENXIO; - 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); + if (!(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT)) { + CERROR("%s: ChangeLog has wrong flags: rc = %d\n", + ctxt->loc_obd->obd_name, -EINVAL); + llog_ctxt_put(ctxt); + return -EINVAL; + } + + *val += llog_cat_size(env, ctxt->loc_handle); + + llog_ctxt_put(ctxt); + + return 0; +} + +static int mdd_changelog_size_seq_show(struct seq_file *m, void *data) +{ + struct lu_env env; + struct mdd_device *mdd = m->private; + __u64 tmp = 0; + int rc; + + rc = lu_env_init(&env, LCT_LOCAL); + if (rc) + return rc; + + rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_ORIG_CTXT, &tmp); + if (rc) { + lu_env_fini(&env); + return rc; + } + + rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT, + &tmp); + + seq_printf(m, LPU64"\n", tmp); + lu_env_fini(&env); + return rc; +} +LPROC_SEQ_FOPS_RO(mdd_changelog_size); - cfs_spin_lock(&mdd->mdd_cl.mc_lock); - cur = mdd->mdd_cl.mc_index; - cfs_spin_unlock(&mdd->mdd_cl.mc_lock); +static int mdd_sync_perm_seq_show(struct seq_file *m, void *data) +{ + struct mdd_device *mdd = m->private; - cucb.count = count; - cucb.page = page; - cucb.idx = 0; + LASSERT(mdd != NULL); + seq_printf(m, "%d\n", mdd->mdd_sync_permission); + return 0; +} - cucb.idx += snprintf(cucb.page + cucb.idx, cucb.count - cucb.idx, - "current index: "LPU64"\n", cur); +static ssize_t +mdd_sync_perm_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; + int rc; + __s64 val; - cucb.idx += snprintf(cucb.page + cucb.idx, cucb.count - cucb.idx, - "%-5s %s\n", "ID", "index"); + LASSERT(mdd != NULL); + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; - llog_cat_process(ctxt->loc_handle, lprocfs_changelog_users_cb, - &cucb, 0, 0); + mdd->mdd_sync_permission = !!val; - llog_ctxt_put(ctxt); - return cucb.idx; + return count; } +LPROC_SEQ_FOPS(mdd_sync_perm); -#ifdef HAVE_QUOTA_SUPPORT -static int mdd_lprocfs_quota_rd_type(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; - return lprocfs_quota_rd_type(page, start, off, count, eof, - mdd->mdd_obd_dev); + struct mdd_device *mdd = m->private; + + LASSERT(mdd != NULL); + return lfsck_get_speed(m, mdd->mdd_bottom); } -static int mdd_lprocfs_quota_wr_type(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 __user *buffer, + size_t count, loff_t *off) { - struct mdd_device *mdd = data; - return lprocfs_quota_wr_type(file, buffer, count, mdd->mdd_obd_dev); + struct seq_file *m = file->private_data; + struct mdd_device *mdd = m->private; + __s64 val; + int rc; + + LASSERT(mdd != NULL); + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc != 0) + return rc; + if (val < 0 || val > INT_MAX) + return -ERANGE; + + rc = lfsck_set_speed(mdd->mdd_bottom, val); + return rc != 0 ? rc : count; } -#endif +LPROC_SEQ_FOPS(mdd_lfsck_speed_limit); -static int lprocfs_rd_sync_perm(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; + struct mdd_device *mdd = m->private; - LASSERT(mdd != NULL); - return snprintf(page, count, "%d\n", mdd->mdd_sync_permission); + LASSERT(mdd != NULL); + return lfsck_get_windows(m, mdd->mdd_bottom); } -static int lprocfs_wr_sync_perm(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 __user *buffer, + size_t count, loff_t *off) { - struct mdd_device *mdd = data; - int val, rc; + struct seq_file *m = file->private_data; + struct mdd_device *mdd = m->private; + __s64 val; + int rc; - LASSERT(mdd != NULL); - rc = lprocfs_write_helper(buffer, count, &val); - if (rc) - return rc; + LASSERT(mdd != NULL); + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + if (val < 0 || val > INT_MAX) + return -ERANGE; - mdd->mdd_sync_permission = !!val; - return count; + rc = lfsck_set_windows(mdd->mdd_bottom, val); + + return rc != 0 ? rc : count; } +LPROC_SEQ_FOPS(mdd_lfsck_async_windows); -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_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; + + LASSERT(mdd != NULL); -static struct lprocfs_vars lprocfs_mdd_module_vars[] = { - { "num_refs", lprocfs_rd_numrefs, 0, 0 }, - { 0 } + 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 = "changelog_size", + .fops = &mdd_changelog_size_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); +}