X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=aa2925ab820d3d30e721af3d67a0f64a5bbe3c03;hp=47171960dc666615f171d55f3b6ee57ced84f436;hb=5d085745af43bd15e6b7ea728491600411833b2a;hpb=73c12f4d6c98476c0dc5de77a646a157db727eef diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index 4717196..aa2925a 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,7 +23,7 @@ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2013, Intel Corporation. + * Copyright (c) 2011, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -40,31 +36,52 @@ #define DEBUG_SUBSYSTEM S_CLASS - #include #include -#include -#if defined(LPROCFS) +#ifdef CONFIG_PROC_FS static int lprocfs_no_percpu_stats = 0; -CFS_MODULE_PARM(lprocfs_no_percpu_stats, "i", int, 0644, - "Do not alloc percpu data for lprocfs stats"); +module_param(lprocfs_no_percpu_stats, int, 0644); +MODULE_PARM_DESC(lprocfs_no_percpu_stats, "Do not alloc percpu data for lprocfs stats"); #define MAX_STRING_SIZE 128 int lprocfs_single_release(struct inode *inode, struct file *file) { - return single_release(inode, file); + return single_release(inode, file); } EXPORT_SYMBOL(lprocfs_single_release); int lprocfs_seq_release(struct inode *inode, struct file *file) { - return seq_release(inode, file); + return seq_release(inode, file); } EXPORT_SYMBOL(lprocfs_seq_release); +struct dentry *ldebugfs_add_simple(struct dentry *root, + char *name, void *data, + const struct file_operations *fops) +{ + struct dentry *entry; + umode_t mode = 0; + + if (!root || !name || !fops) + return ERR_PTR(-EINVAL); + + if (fops->read) + mode = 0444; + if (fops->write) + mode |= 0200; + entry = debugfs_create_file(name, mode, root, data, fops); + if (IS_ERR_OR_NULL(entry)) { + CERROR("LprocFS: No memory to create entry %s", name); + return entry ?: ERR_PTR(-ENOMEM); + } + return entry; +} +EXPORT_SYMBOL(ldebugfs_add_simple); + struct proc_dir_entry * lprocfs_add_simple(struct proc_dir_entry *root, char *name, void *data, const struct file_operations *fops) @@ -72,8 +89,8 @@ lprocfs_add_simple(struct proc_dir_entry *root, char *name, struct proc_dir_entry *proc; mode_t mode = 0; - if (root == NULL || name == NULL || fops == NULL) - return ERR_PTR(-EINVAL); + if (!root || !name || !fops) + return ERR_PTR(-EINVAL); if (fops->read) mode = 0444; @@ -85,236 +102,69 @@ lprocfs_add_simple(struct proc_dir_entry *root, char *name, name); return ERR_PTR(-ENOMEM); } - return proc; + return proc; } EXPORT_SYMBOL(lprocfs_add_simple); struct proc_dir_entry *lprocfs_add_symlink(const char *name, - struct proc_dir_entry *parent, const char *format, ...) + struct proc_dir_entry *parent, + const char *format, ...) { - struct proc_dir_entry *entry; - char *dest; - va_list ap; + struct proc_dir_entry *entry; + char *dest; + va_list ap; - if (parent == NULL || format == NULL) - return NULL; + if (!parent || !format) + return NULL; - OBD_ALLOC_WAIT(dest, MAX_STRING_SIZE + 1); - if (dest == NULL) - return NULL; + OBD_ALLOC_WAIT(dest, MAX_STRING_SIZE + 1); + if (!dest) + return NULL; - va_start(ap, format); - vsnprintf(dest, MAX_STRING_SIZE, format, ap); - va_end(ap); + va_start(ap, format); + vsnprintf(dest, MAX_STRING_SIZE, format, ap); + va_end(ap); - entry = proc_symlink(name, parent, dest); - if (entry == NULL) + entry = proc_symlink(name, parent, dest); + if (!entry) CERROR("LprocFS: Could not create symbolic link from " "%s to %s\n", name, dest); - OBD_FREE(dest, MAX_STRING_SIZE + 1); - return entry; + OBD_FREE(dest, MAX_STRING_SIZE + 1); + return entry; } EXPORT_SYMBOL(lprocfs_add_symlink); -#ifdef HAVE_ONLY_PROCFS_SEQ static const struct file_operations lprocfs_generic_fops = { }; -#else - -ssize_t -lprocfs_fops_read(struct file *f, char __user *buf, size_t size, loff_t *ppos) -{ - struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode); - char *page, *start = NULL; - int rc = 0, eof = 1, count; - - if (*ppos >= PAGE_CACHE_SIZE) - return 0; - - page = (char *)__get_free_page(GFP_KERNEL); - if (page == NULL) - return -ENOMEM; - - if (LPROCFS_ENTRY_CHECK(dp)) { - rc = -ENOENT; - goto out; - } - - OBD_FAIL_TIMEOUT(OBD_FAIL_LPROC_REMOVE, 10); - if (dp->read_proc) - rc = dp->read_proc(page, &start, *ppos, PAGE_CACHE_SIZE, - &eof, dp->data); - if (rc <= 0) - goto out; - - /* for lustre proc read, the read count must be less than PAGE_SIZE */ - LASSERT(eof == 1); - - if (start == NULL) { - rc -= *ppos; - if (rc < 0) - rc = 0; - if (rc == 0) - goto out; - start = page + *ppos; - } else if (start < page) { - start = page; - } - - count = (rc < size) ? rc : size; - if (copy_to_user(buf, start, count)) { - rc = -EFAULT; - goto out; - } - *ppos += count; - -out: - free_page((unsigned long)page); - return rc; -} - -ssize_t -lprocfs_fops_write(struct file *f, const char __user *buf, size_t size, - loff_t *ppos) -{ - struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode); - int rc = -EIO; - - if (LPROCFS_ENTRY_CHECK(dp)) - return -ENOENT; - if (dp->write_proc) - rc = dp->write_proc(f, buf, size, dp->data); - return rc; -} - -static struct file_operations lprocfs_generic_fops = { - .owner = THIS_MODULE, - .read = lprocfs_fops_read, - .write = lprocfs_fops_write, -}; - -/* for b=10866, global variable */ -DECLARE_RWSEM(_lprocfs_lock); -EXPORT_SYMBOL(_lprocfs_lock); -static struct proc_dir_entry *__lprocfs_srch(struct proc_dir_entry *head, - const char *name) +int ldebugfs_add_vars(struct dentry *parent, struct lprocfs_vars *list, + void *data) { - struct proc_dir_entry *temp; + if (IS_ERR_OR_NULL(parent) || IS_ERR_OR_NULL(list)) + return -EINVAL; - if (head == NULL) - return NULL; + while (list->name) { + struct dentry *entry; + umode_t mode = 0; - temp = head->subdir; - while (temp != NULL) { - if (strcmp(temp->name, name) == 0) - return temp; - temp = temp->next; + if (list->proc_mode != 0000) { + mode = list->proc_mode; + } else if (list->fops) { + if (list->fops->read) + mode = 0444; + if (list->fops->write) + mode |= 0200; + } + entry = debugfs_create_file(list->name, mode, parent, + list->data ? : data, + list->fops ? : &lprocfs_generic_fops); + if (IS_ERR_OR_NULL(entry)) + return entry ? PTR_ERR(entry) : -ENOMEM; + list++; } - return NULL; -} - -struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head, - const char *name) -{ - struct proc_dir_entry *temp; - - LPROCFS_SRCH_ENTRY(); - temp = __lprocfs_srch(head, name); - LPROCFS_SRCH_EXIT(); - return temp; -} -EXPORT_SYMBOL(lprocfs_srch); - -static int __lprocfs_add_vars(struct proc_dir_entry *root, - struct lprocfs_vars *list, - void *data) -{ - int rc = 0; - - if (root == NULL || list == NULL) - return -EINVAL; - - while (list->name != NULL) { - struct proc_dir_entry *cur_root, *proc; - char *pathcopy, *cur, *next, pathbuf[64]; - int pathsize = strlen(list->name) + 1; - - proc = NULL; - cur_root = root; - - /* need copy of path for strsep */ - if (strlen(list->name) > sizeof(pathbuf) - 1) { - OBD_ALLOC(pathcopy, pathsize); - if (pathcopy == NULL) - GOTO(out, rc = -ENOMEM); - } else { - pathcopy = pathbuf; - } - - next = pathcopy; - strcpy(pathcopy, list->name); - - while (cur_root != NULL && (cur = strsep(&next, "/"))) { - if (*cur =='\0') /* skip double/trailing "/" */ - continue; - - proc = __lprocfs_srch(cur_root, cur); - CDEBUG(D_OTHER, "cur_root=%s, cur=%s, next=%s, (%s)\n", - cur_root->name, cur, next, - (proc ? "exists" : "new")); - if (next != NULL) { - cur_root = (proc ? proc : - proc_mkdir(cur, cur_root)); - } else if (proc == NULL) { - mode_t mode = 0; - if (list->proc_mode != 0000) { - mode = list->proc_mode; - } else { - if (list->read_fptr) - mode = 0444; - if (list->write_fptr) - mode |= 0200; - } - proc = create_proc_entry(cur, mode, cur_root); - } - } - - if (pathcopy != pathbuf) - OBD_FREE(pathcopy, pathsize); - - if (cur_root == NULL || proc == NULL) { - CERROR("LprocFS: No memory to create /proc entry %s\n", - list->name); - GOTO(out, rc = -ENOMEM); - } - - if (list->fops) - proc->proc_fops = list->fops; - else - proc->proc_fops = &lprocfs_generic_fops; - proc->read_proc = list->read_fptr; - proc->write_proc = list->write_fptr; - proc->data = (list->data ? list->data : data); - list++; - } -out: - return rc; -} - -int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, - void *data) -{ - int rc = 0; - - LPROCFS_WRITE_ENTRY(); - rc = __lprocfs_add_vars(root, list, data); - LPROCFS_WRITE_EXIT(); - - return rc; + return 0; } -EXPORT_SYMBOL(lprocfs_add_vars); -#endif +EXPORT_SYMBOL_GPL(ldebugfs_add_vars); /** * Add /proc entries. @@ -328,13 +178,13 @@ EXPORT_SYMBOL(lprocfs_add_vars); * < 0 on error */ int -lprocfs_seq_add_vars(struct proc_dir_entry *root, struct lprocfs_seq_vars *list, - void *data) +lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, + void *data) { - if (root == NULL || list == NULL) + if (!root || !list) return -EINVAL; - while (list->name != NULL) { + while (list->name) { struct proc_dir_entry *proc; mode_t mode = 0; @@ -349,16 +199,27 @@ lprocfs_seq_add_vars(struct proc_dir_entry *root, struct lprocfs_seq_vars *list, proc = proc_create_data(list->name, mode, root, list->fops ?: &lprocfs_generic_fops, list->data ?: data); - if (proc == NULL) + if (!proc) return -ENOMEM; list++; } return 0; } -EXPORT_SYMBOL(lprocfs_seq_add_vars); +EXPORT_SYMBOL(lprocfs_add_vars); -#ifndef HAVE_ONLY_PROCFS_SEQ -void lprocfs_remove_nolock(struct proc_dir_entry **proot) +void ldebugfs_remove(struct dentry **entryp) +{ + debugfs_remove_recursive(*entryp); + *entryp = NULL; +} +EXPORT_SYMBOL_GPL(ldebugfs_remove); + +#ifndef HAVE_REMOVE_PROC_SUBTREE +/* for b=10866, global variable */ +DECLARE_RWSEM(_lprocfs_lock); +EXPORT_SYMBOL(_lprocfs_lock); + +static void lprocfs_remove_nolock(struct proc_dir_entry **proot) { struct proc_dir_entry *root = *proot; struct proc_dir_entry *temp = root; @@ -366,65 +227,43 @@ void lprocfs_remove_nolock(struct proc_dir_entry **proot) struct proc_dir_entry *parent; *proot = NULL; - if (root == NULL || IS_ERR(root)) + if (!root || IS_ERR(root)) return; - parent = root->parent; - LASSERT(parent != NULL); - - while (1) { - while (temp->subdir != NULL) - temp = temp->subdir; - - rm_entry = temp; - temp = temp->parent; + parent = root->parent; + LASSERT(parent != NULL); - /* Memory corruption once caused this to fail, and - without this LASSERT we would loop here forever. */ - LASSERTF(strlen(rm_entry->name) == rm_entry->namelen, - "0x%p %s/%s len %d\n", rm_entry, temp->name, - rm_entry->name, (int)strlen(rm_entry->name)); + while (1) { + while (temp->subdir) + temp = temp->subdir; - remove_proc_entry(rm_entry->name, temp); - if (temp == parent) - break; - } -} -#endif + rm_entry = temp; + temp = temp->parent; -void lprocfs_remove(struct proc_dir_entry **rooth) -{ -#ifndef HAVE_ONLY_PROCFS_SEQ - LPROCFS_WRITE_ENTRY(); /* search vs remove race */ - lprocfs_remove_nolock(rooth); - LPROCFS_WRITE_EXIT(); -#else - proc_remove(*rooth); - *rooth = NULL; -#endif -} -EXPORT_SYMBOL(lprocfs_remove); + /* + * Memory corruption once caused this to fail, and + * without this LASSERT we would loop here forever. + */ + LASSERTF(strlen(rm_entry->name) == rm_entry->namelen, + "0x%p %s/%s len %d\n", rm_entry, temp->name, + rm_entry->name, (int)strlen(rm_entry->name)); -void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent) -{ - LASSERT(parent != NULL); - remove_proc_entry(name, parent); + remove_proc_entry(rm_entry->name, temp); + if (temp == parent) + break; + } } -EXPORT_SYMBOL(lprocfs_remove_proc_entry); -#ifndef HAVE_ONLY_PROCFS_SEQ -void lprocfs_try_remove_proc_entry(const char *name, - struct proc_dir_entry *parent) +int remove_proc_subtree(const char *name, struct proc_dir_entry *parent) { - struct proc_dir_entry *t = NULL; - struct proc_dir_entry **p; - int len, busy = 0; + struct proc_dir_entry *t = NULL; + struct proc_dir_entry **p; + int len, busy = 0; LASSERT(parent != NULL); len = strlen(name); - LPROCFS_WRITE_ENTRY(); - + down_write(&_lprocfs_lock); /* lookup target name */ for (p = &parent->subdir; *p; p = &(*p)->next) { if ((*p)->namelen != len) @@ -453,56 +292,76 @@ void lprocfs_try_remove_proc_entry(const char *name, if (busy == 0) lprocfs_remove_nolock(&t); - LPROCFS_WRITE_EXIT(); + up_write(&_lprocfs_lock); + return 0; +} +#endif /* !HAVE_REMOVE_PROC_SUBTREE */ - return; +#ifndef HAVE_PROC_REMOVE +void proc_remove(struct proc_dir_entry *de) +{ +#ifndef HAVE_REMOVE_PROC_SUBTREE + down_write(&_lprocfs_lock); /* search vs remove race */ + lprocfs_remove_nolock(&de); + up_write(&_lprocfs_lock); +#else + if (de) + remove_proc_subtree(de->name, de->parent); +#endif } -EXPORT_SYMBOL(lprocfs_try_remove_proc_entry); +#endif -struct proc_dir_entry *lprocfs_register(const char *name, - struct proc_dir_entry *parent, - struct lprocfs_vars *list, void *data) +void lprocfs_remove(struct proc_dir_entry **rooth) { - struct proc_dir_entry *entry; - int rc; + proc_remove(*rooth); + *rooth = NULL; +} +EXPORT_SYMBOL(lprocfs_remove); + +void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent) +{ + LASSERT(parent != NULL); + remove_proc_entry(name, parent); +} +EXPORT_SYMBOL(lprocfs_remove_proc_entry); + +struct dentry *ldebugfs_register(const char *name, struct dentry *parent, + struct lprocfs_vars *list, void *data) +{ + struct dentry *entry; - LPROCFS_WRITE_ENTRY(); - entry = __lprocfs_srch(parent, name); - if (entry != NULL) { - CERROR("entry '%s' already registered\n", name); - GOTO(out, entry = ERR_PTR(-EALREADY)); + entry = debugfs_create_dir(name, parent); + if (IS_ERR_OR_NULL(entry)) { + entry = entry ?: ERR_PTR(-ENOMEM); + goto out; } - entry = proc_mkdir(name, parent); - if (entry == NULL) - GOTO(out, entry = ERR_PTR(-ENOMEM)); + if (!IS_ERR_OR_NULL(list)) { + int rc; - if (list != NULL) { - rc = __lprocfs_add_vars(entry, list, data); - if (rc != 0) { - lprocfs_remove_nolock(&entry); - GOTO(out, entry = ERR_PTR(rc)); + rc = ldebugfs_add_vars(entry, list, data); + if (rc) { + debugfs_remove(entry); + entry = ERR_PTR(rc); } } out: - LPROCFS_WRITE_EXIT(); return entry; } -EXPORT_SYMBOL(lprocfs_register); -#endif +EXPORT_SYMBOL_GPL(ldebugfs_register); struct proc_dir_entry * -lprocfs_seq_register(const char *name, struct proc_dir_entry *parent, - struct lprocfs_seq_vars *list, void *data) +lprocfs_register(const char *name, struct proc_dir_entry *parent, + struct lprocfs_vars *list, void *data) { struct proc_dir_entry *newchild; newchild = proc_mkdir(name, parent); - if (newchild == NULL) + if (!newchild) return ERR_PTR(-ENOMEM); - if (list != NULL) { - int rc = lprocfs_seq_add_vars(newchild, list, data); + if (list) { + int rc = lprocfs_add_vars(newchild, list, data); if (rc) { lprocfs_remove(&newchild); return ERR_PTR(rc); @@ -510,200 +369,176 @@ lprocfs_seq_register(const char *name, struct proc_dir_entry *parent, } return newchild; } -EXPORT_SYMBOL(lprocfs_seq_register); +EXPORT_SYMBOL(lprocfs_register); /* Generic callbacks */ -int lprocfs_uint_seq_show(struct seq_file *m, void *data) -{ - return seq_printf(m, "%u\n", *(unsigned int *)data); -} -EXPORT_SYMBOL(lprocfs_uint_seq_show); - -int lprocfs_wr_uint(struct file *file, const char __user *buffer, - unsigned long count, void *data) -{ - unsigned *p = data; - char dummy[MAX_STRING_SIZE + 1], *end; - unsigned long tmp; - - dummy[MAX_STRING_SIZE] = '\0'; - if (copy_from_user(dummy, buffer, MAX_STRING_SIZE)) - return -EFAULT; - - tmp = simple_strtoul(dummy, &end, 0); - if (dummy == end) - return -EINVAL; - - *p = (unsigned int)tmp; - return count; -} -EXPORT_SYMBOL(lprocfs_wr_uint); - -ssize_t lprocfs_uint_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) -{ - int *data = ((struct seq_file *)file->private_data)->private; - int val = 0, rc; - - rc = lprocfs_write_helper(buffer, count, &val); - if (rc < 0) - return rc; - - return lprocfs_wr_uint(file, buffer, count, data); -} -EXPORT_SYMBOL(lprocfs_uint_seq_write); - -int lprocfs_u64_seq_show(struct seq_file *m, void *data) -{ - LASSERT(data != NULL); - return seq_printf(m, LPU64"\n", *(__u64 *)data); -} -EXPORT_SYMBOL(lprocfs_u64_seq_show); - -int lprocfs_atomic_seq_show(struct seq_file *m, void *data) -{ - atomic_t *atom = data; - LASSERT(atom != NULL); - return seq_printf(m, "%d\n", atomic_read(atom)); -} -EXPORT_SYMBOL(lprocfs_atomic_seq_show); - -ssize_t -lprocfs_atomic_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) -{ - atomic_t *atm = ((struct seq_file *)file->private_data)->private; - int val = 0; - int rc; - - rc = lprocfs_write_helper(buffer, count, &val); - if (rc < 0) - return rc; - - if (val <= 0) - return -ERANGE; - - atomic_set(atm, val); - return count; -} -EXPORT_SYMBOL(lprocfs_atomic_seq_write); - int lprocfs_uuid_seq_show(struct seq_file *m, void *data) { struct obd_device *obd = data; LASSERT(obd != NULL); - return seq_printf(m, "%s\n", obd->obd_uuid.uuid); + seq_printf(m, "%s\n", obd->obd_uuid.uuid); + return 0; } EXPORT_SYMBOL(lprocfs_uuid_seq_show); -int lprocfs_name_seq_show(struct seq_file *m, void *data) +static ssize_t uuid_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct obd_device *dev = data; + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); - LASSERT(dev != NULL); - return seq_printf(m, "%s\n", dev->obd_name); + return sprintf(buf, "%s\n", obd->obd_uuid.uuid); } -EXPORT_SYMBOL(lprocfs_name_seq_show); +LUSTRE_RO_ATTR(uuid); -int lprocfs_blksize_seq_show(struct seq_file *m, void *data) +static ssize_t blocksize_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct obd_device *obd = data; - struct obd_statfs osfs; - int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, - cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), - OBD_STATFS_NODELAY); + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct obd_statfs osfs; + int rc; + + rc = obd_statfs(NULL, obd->obd_self_export, &osfs, + ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, + OBD_STATFS_NODELAY); if (!rc) - rc = seq_printf(m, "%u\n", osfs.os_bsize); + return sprintf(buf, "%u\n", osfs.os_bsize); + return rc; } -EXPORT_SYMBOL(lprocfs_blksize_seq_show); +LUSTRE_RO_ATTR(blocksize); -int lprocfs_kbytestotal_seq_show(struct seq_file *m, void *data) +static ssize_t kbytestotal_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct obd_device *obd = data; - struct obd_statfs osfs; - int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, - cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), - OBD_STATFS_NODELAY); + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct obd_statfs osfs; + int rc; + + rc = obd_statfs(NULL, obd->obd_self_export, &osfs, + ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, + OBD_STATFS_NODELAY); if (!rc) { - __u32 blk_size = osfs.os_bsize >> 10; - __u64 result = osfs.os_blocks; + u32 blk_size = osfs.os_bsize >> 10; + u64 result = osfs.os_blocks; while (blk_size >>= 1) result <<= 1; - rc = seq_printf(m, LPU64"\n", result); + return sprintf(buf, "%llu\n", result); } + return rc; } -EXPORT_SYMBOL(lprocfs_kbytestotal_seq_show); +LUSTRE_RO_ATTR(kbytestotal); -int lprocfs_kbytesfree_seq_show(struct seq_file *m, void *data) +static ssize_t kbytesfree_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct obd_device *obd = data; - struct obd_statfs osfs; - int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, - cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), - OBD_STATFS_NODELAY); + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct obd_statfs osfs; + int rc; + + rc = obd_statfs(NULL, obd->obd_self_export, &osfs, + ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, + OBD_STATFS_NODELAY); if (!rc) { - __u32 blk_size = osfs.os_bsize >> 10; - __u64 result = osfs.os_bfree; + u32 blk_size = osfs.os_bsize >> 10; + u64 result = osfs.os_bfree; while (blk_size >>= 1) result <<= 1; - rc = seq_printf(m, LPU64"\n", result); + return sprintf(buf, "%llu\n", result); } + return rc; } -EXPORT_SYMBOL(lprocfs_kbytesfree_seq_show); +LUSTRE_RO_ATTR(kbytesfree); -int lprocfs_kbytesavail_seq_show(struct seq_file *m, void *data) +static ssize_t kbytesavail_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct obd_device *obd = data; - struct obd_statfs osfs; - int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, - cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), - OBD_STATFS_NODELAY); + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct obd_statfs osfs; + int rc; + + rc = obd_statfs(NULL, obd->obd_self_export, &osfs, + ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, + OBD_STATFS_NODELAY); if (!rc) { - __u32 blk_size = osfs.os_bsize >> 10; - __u64 result = osfs.os_bavail; + u32 blk_size = osfs.os_bsize >> 10; + u64 result = osfs.os_bavail; while (blk_size >>= 1) result <<= 1; - rc = seq_printf(m, LPU64"\n", result); + return sprintf(buf, "%llu\n", result); } + return rc; } -EXPORT_SYMBOL(lprocfs_kbytesavail_seq_show); +LUSTRE_RO_ATTR(kbytesavail); -int lprocfs_filestotal_seq_show(struct seq_file *m, void *data) +static ssize_t filestotal_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct obd_device *obd = data; - struct obd_statfs osfs; - int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, - cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), - OBD_STATFS_NODELAY); + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct obd_statfs osfs; + int rc; + + rc = obd_statfs(NULL, obd->obd_self_export, &osfs, + ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, + OBD_STATFS_NODELAY); if (!rc) - rc = seq_printf(m, LPU64"\n", osfs.os_files); + return sprintf(buf, "%llu\n", osfs.os_files); + return rc; } -EXPORT_SYMBOL(lprocfs_filestotal_seq_show); +LUSTRE_RO_ATTR(filestotal); -int lprocfs_filesfree_seq_show(struct seq_file *m, void *data) +static ssize_t filesfree_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct obd_device *obd = data; - struct obd_statfs osfs; - int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, - cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), - OBD_STATFS_NODELAY); + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct obd_statfs osfs; + int rc; + + rc = obd_statfs(NULL, obd->obd_self_export, &osfs, + ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, + OBD_STATFS_NODELAY); if (!rc) - rc = seq_printf(m, LPU64"\n", osfs.os_ffree); + return sprintf(buf, "%llu\n", osfs.os_ffree); + return rc; } -EXPORT_SYMBOL(lprocfs_filesfree_seq_show); +LUSTRE_RO_ATTR(filesfree); + +ssize_t conn_uuid_show(struct kobject *kobj, struct attribute *attr, char *buf) +{ + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct ptlrpc_connection *conn; + ssize_t count; + + LPROCFS_CLIMP_CHECK(obd); + conn = obd->u.cli.cl_import->imp_connection; + if (conn && obd->u.cli.cl_import) + count = sprintf(buf, "%s\n", conn->c_remote_uuid.uuid); + else + count = sprintf(buf, "%s\n", ""); + + LPROCFS_CLIMP_EXIT(obd); + return count; +} +EXPORT_SYMBOL(conn_uuid_show); int lprocfs_server_uuid_seq_show(struct seq_file *m, void *data) { @@ -716,46 +551,115 @@ int lprocfs_server_uuid_seq_show(struct seq_file *m, void *data) LPROCFS_CLIMP_CHECK(obd); imp = obd->u.cli.cl_import; imp_state_name = ptlrpc_import_state_name(imp->imp_state); - rc = seq_printf(m, "%s\t%s%s\n", obd2cli_tgt(obd), imp_state_name, - imp->imp_deactive ? "\tDEACTIVATED" : ""); + seq_printf(m, "%s\t%s%s\n", obd2cli_tgt(obd), imp_state_name, + imp->imp_deactive ? "\tDEACTIVATED" : ""); LPROCFS_CLIMP_EXIT(obd); return rc; } EXPORT_SYMBOL(lprocfs_server_uuid_seq_show); -int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data) +/** add up per-cpu counters */ + +/** + * Lock statistics structure for access, possibly only on this CPU. + * + * The statistics struct may be allocated with per-CPU structures for + * efficient concurrent update (usually only on server-wide stats), or + * as a single global struct (e.g. for per-client or per-job statistics), + * so the required locking depends on the type of structure allocated. + * + * For per-CPU statistics, pin the thread to the current cpuid so that + * will only access the statistics for that CPU. If the stats structure + * for the current CPU has not been allocated (or previously freed), + * allocate it now. The per-CPU statistics do not need locking since + * the thread is pinned to the CPU during update. + * + * For global statistics, lock the stats structure to prevent concurrent update. + * + * \param[in] stats statistics structure to lock + * \param[in] opc type of operation: + * LPROCFS_GET_SMP_ID: "lock" and return current CPU index + * for incrementing statistics for that CPU + * LPROCFS_GET_NUM_CPU: "lock" and return number of used + * CPU indices to iterate over all indices + * \param[out] flags CPU interrupt saved state for IRQ-safe locking + * + * \retval cpuid of current thread or number of allocated structs + * \retval negative on error (only for opc LPROCFS_GET_SMP_ID + per-CPU stats) + */ +int lprocfs_stats_lock(struct lprocfs_stats *stats, + enum lprocfs_stats_lock_ops opc, + unsigned long *flags) { - struct obd_device *obd = data; - struct ptlrpc_connection *conn; - int rc = 0; + if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) { + if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) + spin_lock_irqsave(&stats->ls_lock, *flags); + else + spin_lock(&stats->ls_lock); + return opc == LPROCFS_GET_NUM_CPU ? 1 : 0; + } - LASSERT(obd != NULL); + switch (opc) { + case LPROCFS_GET_SMP_ID: { + unsigned int cpuid = get_cpu(); - LPROCFS_CLIMP_CHECK(obd); - conn = obd->u.cli.cl_import->imp_connection; - if (conn && obd->u.cli.cl_import) - rc = seq_printf(m, "%s\n", conn->c_remote_uuid.uuid); - else - rc = seq_printf(m, "%s\n", ""); + if (unlikely(!stats->ls_percpu[cpuid])) { + int rc = lprocfs_stats_alloc_one(stats, cpuid); - LPROCFS_CLIMP_EXIT(obd); - return rc; + if (rc < 0) { + put_cpu(); + return rc; + } + } + return cpuid; + } + case LPROCFS_GET_NUM_CPU: + return stats->ls_biggest_alloc_num; + default: + LBUG(); + } +} + +/** + * Unlock statistics structure after access. + * + * Unlock the lock acquired via lprocfs_stats_lock() for global statistics, + * or unpin this thread from the current cpuid for per-CPU statistics. + * + * This function must be called using the same arguments as used when calling + * lprocfs_stats_lock() so that the correct operation can be performed. + * + * \param[in] stats statistics structure to unlock + * \param[in] opc type of operation (current cpuid or number of structs) + * \param[in] flags CPU interrupt saved state for IRQ-safe locking + */ +void lprocfs_stats_unlock(struct lprocfs_stats *stats, + enum lprocfs_stats_lock_ops opc, + unsigned long *flags) +{ + if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) { + if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) + spin_unlock_irqrestore(&stats->ls_lock, *flags); + else + spin_unlock(&stats->ls_lock); + } else if (opc == LPROCFS_GET_SMP_ID) { + put_cpu(); + } } -EXPORT_SYMBOL(lprocfs_conn_uuid_seq_show); /** add up per-cpu counters */ void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, struct lprocfs_counter *cnt) { - unsigned int num_entry; - struct lprocfs_counter *percpu_cntr; - int i; - unsigned long flags = 0; + unsigned int num_entry; + struct lprocfs_counter *percpu_cntr; + int i; + unsigned long flags = 0; memset(cnt, 0, sizeof(*cnt)); - if (stats == NULL) { + if (!stats) { /* set count to 1 to avoid divide-by-zero errs in callers */ cnt->lc_count = 1; return; @@ -766,7 +670,7 @@ void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, num_entry = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); for (i = 0; i < num_entry; i++) { - if (stats->ls_percpu[i] == NULL) + if (!stats->ls_percpu[i]) continue; percpu_cntr = lprocfs_stats_counter_get(stats, i, idx); @@ -781,18 +685,7 @@ void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags); } -EXPORT_SYMBOL(lprocfs_stats_collect); -/** - * Append a space separated list of current set flags to str. - */ -#define flag2str(flag) \ - do { \ - if (imp->imp_##flag) { \ - seq_printf(m, "%s" #flag, first ? "" : ", "); \ - first = false; \ - } \ - } while (0) static void obd_import_flags2str(struct obd_import *imp, struct seq_file *m) { bool first = true; @@ -802,21 +695,19 @@ static void obd_import_flags2str(struct obd_import *imp, struct seq_file *m) first = false; } - flag2str(invalid); - flag2str(deactive); - flag2str(replayable); - flag2str(delayed_recovery); - flag2str(no_lock_replay); - flag2str(vbr_failed); - flag2str(pingable); - flag2str(resend_replay); - flag2str(no_pinger_recover); - flag2str(need_mne_swab); - flag2str(connect_tried); + flag2str(imp, invalid); + flag2str(imp, deactive); + flag2str(imp, replayable); + flag2str(imp, delayed_recovery); + flag2str(imp, vbr_failed); + flag2str(imp, pingable); + flag2str(imp, resend_replay); + flag2str(imp, no_pinger_recover); + flag2str(imp, connect_tried); } -#undef flag2str static const char *obd_connect_names[] = { + /* flags names */ "read_only", "lov_index", "connect_from_mds", @@ -830,7 +721,7 @@ static const char *obd_connect_names[] = { "truncate_lock", "initial_transno", "inode_bit_locks", - "join_file(obsolete)", + "barrier", "getattr_by_fid", "no_oh_for_devices", "remote_client", @@ -874,67 +765,125 @@ static const char *obd_connect_names[] = { "lfsck", "unknown", "unlink_close", - "unknown", + "multi_mod_rpcs", "dir_stripe", - "unknown", + "subtree", + "lockahead", + "bulk_mbits", + "compact_obdo", + "second_flags", + /* flags2 names */ + "file_secctx", /* 0x01 */ + "lockaheadv2", /* 0x02 */ + "dir_migrate", /* 0x04 */ + "sum_statfs", /* 0x08 */ + "overstriping", /* 0x10 */ + "flr", /* 0x20 */ + "wbc", /* 0x40 */ + "lock_convert", /* 0x80 */ + "archive_id_array", /* 0x100 */ + "unknown", /* 0x200 */ + "selinux_policy", /* 0x400 */ + "lsom", /* 0x800 */ + "pcc", /* 0x1000 */ + "plain_layout", /* 0x2000 */ NULL }; -static void obd_connect_seq_flags2str(struct seq_file *m, __u64 flags, char *sep) +void obd_connect_seq_flags2str(struct seq_file *m, __u64 flags, __u64 flags2, + const char *sep) { bool first = true; - __u64 mask = 1; + __u64 mask; int i; - for (i = 0; obd_connect_names[i] != NULL; i++, mask <<= 1) { + for (i = 0, mask = 1; i < 64; i++, mask <<= 1) { if (flags & mask) { seq_printf(m, "%s%s", first ? "" : sep, obd_connect_names[i]); first = false; } } - if (flags & ~(mask - 1)) - seq_printf(m, "%sunknown_"LPX64, + + if (flags & ~(mask - 1)) { + seq_printf(m, "%sunknown_%#llx", first ? "" : sep, flags & ~(mask - 1)); + first = false; + } + + if (!(flags & OBD_CONNECT_FLAGS2) || flags2 == 0) + return; + + for (i = 64, mask = 1; obd_connect_names[i] != NULL; i++, mask <<= 1) { + if (flags2 & mask) { + seq_printf(m, "%s%s", + first ? "" : sep, obd_connect_names[i]); + first = false; + } + } + + if (flags2 & ~(mask - 1)) { + seq_printf(m, "%sunknown2_%#llx", + first ? "" : sep, flags2 & ~(mask - 1)); + first = false; + } } +EXPORT_SYMBOL(obd_connect_seq_flags2str); -int obd_connect_flags2str(char *page, int count, __u64 flags, char *sep) +int obd_connect_flags2str(char *page, int count, __u64 flags, __u64 flags2, + const char *sep) { - __u64 mask = 1; + __u64 mask; int i, ret = 0; - for (i = 0; obd_connect_names[i] != NULL; i++, mask <<= 1) { + for (i = 0, mask = 1; i < 64; i++, mask <<= 1) { if (flags & mask) ret += snprintf(page + ret, count - ret, "%s%s", ret ? sep : "", obd_connect_names[i]); } + if (flags & ~(mask - 1)) ret += snprintf(page + ret, count - ret, - "%sunknown_"LPX64, + "%sunknown_%#llx", ret ? sep : "", flags & ~(mask - 1)); + + if (!(flags & OBD_CONNECT_FLAGS2) || flags2 == 0) + return ret; + + for (i = 64, mask = 1; obd_connect_names[i] != NULL; i++, mask <<= 1) { + if (flags2 & mask) + ret += snprintf(page + ret, count - ret, "%s%s", + ret ? sep : "", obd_connect_names[i]); + } + + if (flags2 & ~(mask - 1)) + ret += snprintf(page + ret, count - ret, + "%sunknown2_%#llx", + ret ? sep : "", flags2 & ~(mask - 1)); + return ret; } EXPORT_SYMBOL(obd_connect_flags2str); -static void obd_connect_data_seqprint(struct seq_file *m, - struct obd_connect_data *ocd) +void +obd_connect_data_seqprint(struct seq_file *m, struct obd_connect_data *ocd) { - int flags; + __u64 flags; LASSERT(ocd != NULL); flags = ocd->ocd_connect_flags; seq_printf(m, " connect_data:\n" - " flags: "LPX64"\n" - " instance: %u\n", - ocd->ocd_connect_flags, - ocd->ocd_instance); + " flags: %#llx\n" + " instance: %u\n", + ocd->ocd_connect_flags, + ocd->ocd_instance); if (flags & OBD_CONNECT_VERSION) seq_printf(m, " target_version: %u.%u.%u.%u\n", - OBD_OCD_VERSION_MAJOR(ocd->ocd_version), - OBD_OCD_VERSION_MINOR(ocd->ocd_version), - OBD_OCD_VERSION_PATCH(ocd->ocd_version), - OBD_OCD_VERSION_FIX(ocd->ocd_version)); + OBD_OCD_VERSION_MAJOR(ocd->ocd_version), + OBD_OCD_VERSION_MINOR(ocd->ocd_version), + OBD_OCD_VERSION_PATCH(ocd->ocd_version), + OBD_OCD_VERSION_FIX(ocd->ocd_version)); if (flags & OBD_CONNECT_MDS) seq_printf(m, " mdt_index: %d\n", ocd->ocd_group); if (flags & OBD_CONNECT_GRANT) @@ -944,39 +893,45 @@ static void obd_connect_data_seqprint(struct seq_file *m, if (flags & OBD_CONNECT_BRW_SIZE) seq_printf(m, " max_brw_size: %d\n", ocd->ocd_brw_size); if (flags & OBD_CONNECT_IBITS) - seq_printf(m, " ibits_known: "LPX64"\n", - ocd->ocd_ibits_known); + seq_printf(m, " ibits_known: %#llx\n", + ocd->ocd_ibits_known); if (flags & OBD_CONNECT_GRANT_PARAM) seq_printf(m, " grant_block_size: %d\n" - " grant_inode_size: %d\n" - " grant_extent_overhead: %d\n", - ocd->ocd_blocksize, - ocd->ocd_inodespace, - ocd->ocd_grant_extent); + " grant_inode_size: %d\n" + " grant_max_extent_size: %d\n" + " grant_extent_tax: %d\n", + 1 << ocd->ocd_grant_blkbits, + 1 << ocd->ocd_grant_inobits, + ocd->ocd_grant_max_blks << ocd->ocd_grant_blkbits, + ocd->ocd_grant_tax_kb << 10); if (flags & OBD_CONNECT_TRANSNO) - seq_printf(m, " first_transno: "LPX64"\n", - ocd->ocd_transno); + seq_printf(m, " first_transno: %#llx\n", + ocd->ocd_transno); if (flags & OBD_CONNECT_CKSUM) seq_printf(m, " cksum_types: %#x\n", - ocd->ocd_cksum_types); + ocd->ocd_cksum_types); if (flags & OBD_CONNECT_MAX_EASIZE) seq_printf(m, " max_easize: %d\n", ocd->ocd_max_easize); if (flags & OBD_CONNECT_MAXBYTES) - seq_printf(m, " max_object_bytes: "LPU64"\n", - ocd->ocd_maxbytes); + seq_printf(m, " max_object_bytes: %llu\n", + ocd->ocd_maxbytes); + if (flags & OBD_CONNECT_MULTIMODRPCS) + seq_printf(m, " max_mod_rpcs: %hu\n", + ocd->ocd_maxmodrpcs); } int lprocfs_import_seq_show(struct seq_file *m, void *data) { - struct lprocfs_counter ret; - struct lprocfs_counter_header *header; - struct obd_device *obd = (struct obd_device *)data; - struct obd_import *imp; - struct obd_import_conn *conn; - struct obd_connect_data *ocd; - int j; - int k; - int rw = 0; + char nidstr[LNET_NIDSTR_SIZE]; + struct lprocfs_counter ret; + struct lprocfs_counter_header *header; + struct obd_device *obd = (struct obd_device *)data; + struct obd_import *imp; + struct obd_import_conn *conn; + struct obd_connect_data *ocd; + int j; + int k; + int rw = 0; LASSERT(obd != NULL); LPROCFS_CLIMP_CHECK(obd); @@ -984,43 +939,51 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) ocd = &imp->imp_connect_data; seq_printf(m, "import:\n" - " name: %s\n" - " target: %s\n" - " state: %s\n" - " connect_flags: [ ", - obd->obd_name, - obd2cli_tgt(obd), - ptlrpc_import_state_name(imp->imp_state)); + " name: %s\n" + " target: %s\n" + " state: %s\n" + " connect_flags: [ ", + obd->obd_name, + obd2cli_tgt(obd), + ptlrpc_import_state_name(imp->imp_state)); obd_connect_seq_flags2str(m, imp->imp_connect_data.ocd_connect_flags, - ", "); + imp->imp_connect_data.ocd_connect_flags2, + ", "); seq_printf(m, " ]\n"); obd_connect_data_seqprint(m, ocd); seq_printf(m, " import_flags: [ "); obd_import_flags2str(imp, m); seq_printf(m, " ]\n" - " connection:\n" - " failover_nids: [ "); + " connection:\n" + " failover_nids: [ "); spin_lock(&imp->imp_lock); j = 0; list_for_each_entry(conn, &imp->imp_conn_list, oic_item) { - seq_printf(m, "%s%s", j ? ", " : "", - libcfs_nid2str(conn->oic_conn->c_peer.nid)); + libcfs_nid2str_r(conn->oic_conn->c_peer.nid, + nidstr, sizeof(nidstr)); + seq_printf(m, "%s%s", j ? ", " : "", nidstr); j++; } + if (imp->imp_connection) + libcfs_nid2str_r(imp->imp_connection->c_peer.nid, + nidstr, sizeof(nidstr)); + else + strncpy(nidstr, "", sizeof(nidstr)); seq_printf(m, " ]\n" - " current_connection: %s\n" - " connection_attempts: %u\n" - " generation: %u\n" - " in-progress_invalidations: %u\n", - imp->imp_connection == NULL ? "" : - libcfs_nid2str(imp->imp_connection->c_peer.nid), - imp->imp_conn_cnt, - imp->imp_generation, - atomic_read(&imp->imp_inval_count)); + " current_connection: %s\n" + " connection_attempts: %u\n" + " generation: %u\n" + " in-progress_invalidations: %u\n" + " idle: %lld sec\n", + nidstr, + imp->imp_conn_cnt, + imp->imp_generation, + atomic_read(&imp->imp_inval_count), + ktime_get_real_seconds() - imp->imp_last_reply_time); spin_unlock(&imp->imp_lock); - if (obd->obd_svc_stats == NULL) + if (!obd->obd_svc_stats) goto out_climp; header = &obd->obd_svc_stats->ls_cnt_header[PTLRPC_REQWAIT_CNTR]; @@ -1033,14 +996,14 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) } else ret.lc_sum = 0; seq_printf(m, " rpcs:\n" - " inflight: %u\n" - " unregistering: %u\n" - " timeouts: %u\n" - " avg_waittime: "LPU64" %s\n", - atomic_read(&imp->imp_inflight), - atomic_read(&imp->imp_unregistering), - atomic_read(&imp->imp_timeouts), - ret.lc_sum, header->lc_units); + " inflight: %u\n" + " unregistering: %u\n" + " timeouts: %u\n" + " avg_waittime: %llu %s\n", + atomic_read(&imp->imp_inflight), + atomic_read(&imp->imp_unregistering), + atomic_read(&imp->imp_timeouts), + ret.lc_sum, header->lc_units); k = 0; for(j = 0; j < IMP_AT_MAX_PORTALS; j++) { @@ -1050,18 +1013,18 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) at_get(&imp->imp_at.iat_service_estimate[j])); } seq_printf(m, " service_estimates:\n" - " services: %u sec\n" - " network: %u sec\n", - k, - at_get(&imp->imp_at.iat_net_latency)); + " services: %u sec\n" + " network: %u sec\n", + k, + at_get(&imp->imp_at.iat_net_latency)); seq_printf(m, " transactions:\n" - " last_replay: "LPU64"\n" - " peer_committed: "LPU64"\n" - " last_checked: "LPU64"\n", - imp->imp_last_replay_transno, - imp->imp_peer_committed_transno, - imp->imp_last_transno_checked); + " last_replay: %llu\n" + " peer_committed: %llu\n" + " last_checked: %llu\n", + imp->imp_last_replay_transno, + imp->imp_peer_committed_transno, + imp->imp_last_transno_checked); /* avg data rates */ for (rw = 0; rw <= 1; rw++) { @@ -1074,9 +1037,9 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) do_div(sum, ret.lc_count); ret.lc_sum = sum; seq_printf(m, " %s_data_averages:\n" - " bytes_per_rpc: "LPU64"\n", - rw ? "write" : "read", - ret.lc_sum); + " bytes_per_rpc: %llu\n", + rw ? "write" : "read", + ret.lc_sum); } k = (int)ret.lc_sum; j = opcode_offset(OST_READ + rw) + EXTRA_MAX_OPCODES; @@ -1087,12 +1050,12 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) __u64 sum = ret.lc_sum; do_div(sum, ret.lc_count); ret.lc_sum = sum; - seq_printf(m, " %s_per_rpc: "LPU64"\n", - header->lc_units, ret.lc_sum); + seq_printf(m, " %s_per_rpc: %llu\n", + header->lc_units, ret.lc_sum); j = (int)ret.lc_sum; if (j > 0) seq_printf(m, " MB_per_sec: %u.%.02u\n", - k / j, (100 * k / j) % 100); + k / j, (100 * k / j) % 100); } } @@ -1121,9 +1084,8 @@ int lprocfs_state_seq_show(struct seq_file *m, void *data) &imp->imp_state_hist[(k + j) % IMP_STATE_HIST_LEN]; if (ish->ish_state == 0) continue; - seq_printf(m, " - [ "CFS_TIME_T", %s ]\n", - ish->ish_time, - ptlrpc_import_state_name(ish->ish_state)); + seq_printf(m, " - [ %lld, %s ]\n", (s64)ish->ish_time, + ptlrpc_import_state_name(ish->ish_state)); } LPROCFS_CLIMP_EXIT(obd); @@ -1131,7 +1093,7 @@ int lprocfs_state_seq_show(struct seq_file *m, void *data) } EXPORT_SYMBOL(lprocfs_state_seq_show); -int lprocfs_seq_at_hist_helper(struct seq_file *m, struct adaptive_timeout *at) +int lprocfs_at_hist_helper(struct seq_file *m, struct adaptive_timeout *at) { int i; for (i = 0; i < AT_BINS; i++) @@ -1139,7 +1101,7 @@ int lprocfs_seq_at_hist_helper(struct seq_file *m, struct adaptive_timeout *at) seq_printf(m, "\n"); return 0; } -EXPORT_SYMBOL(lprocfs_seq_at_hist_helper); +EXPORT_SYMBOL(lprocfs_at_hist_helper); /* See also ptlrpc_lprocfs_timeouts_show_seq */ int lprocfs_timeouts_seq_show(struct seq_file *m, void *data) @@ -1147,28 +1109,26 @@ int lprocfs_timeouts_seq_show(struct seq_file *m, void *data) struct obd_device *obd = (struct obd_device *)data; struct obd_import *imp; unsigned int cur, worst; - time_t now, worstt; - struct dhms ts; + time64_t now, worstt; int i; LASSERT(obd != NULL); LPROCFS_CLIMP_CHECK(obd); imp = obd->u.cli.cl_import; - now = cfs_time_current_sec(); + now = ktime_get_real_seconds(); /* Some network health info for kicks */ - s2dhms(&ts, now - imp->imp_last_reply_time); - seq_printf(m, "%-10s : %ld, "DHMS_FMT" ago\n", - "last reply", imp->imp_last_reply_time, DHMS_VARS(&ts)); + seq_printf(m, "%-10s : %lld, %llds ago\n", + "last reply", (s64)imp->imp_last_reply_time, + (s64)(now - imp->imp_last_reply_time)); cur = at_get(&imp->imp_at.iat_net_latency); worst = imp->imp_at.iat_net_latency.at_worst_ever; worstt = imp->imp_at.iat_net_latency.at_worst_time; - s2dhms(&ts, now - worstt); - seq_printf(m, "%-10s : cur %3u worst %3u (at %ld, "DHMS_FMT" ago) ", - "network", cur, worst, worstt, DHMS_VARS(&ts)); - lprocfs_seq_at_hist_helper(m, &imp->imp_at.iat_net_latency); + seq_printf(m, "%-10s : cur %3u worst %3u (at %lld, %llds ago) ", + "network", cur, worst, (s64)worstt, (s64)(now - worstt)); + lprocfs_at_hist_helper(m, &imp->imp_at.iat_net_latency); for(i = 0; i < IMP_AT_MAX_PORTALS; i++) { if (imp->imp_at.iat_portal[i] == 0) @@ -1176,11 +1136,10 @@ int lprocfs_timeouts_seq_show(struct seq_file *m, void *data) cur = at_get(&imp->imp_at.iat_service_estimate[i]); worst = imp->imp_at.iat_service_estimate[i].at_worst_ever; worstt = imp->imp_at.iat_service_estimate[i].at_worst_time; - s2dhms(&ts, now - worstt); - seq_printf(m, "portal %-2d : cur %3u worst %3u (at %ld, " - DHMS_FMT" ago) ", imp->imp_at.iat_portal[i], - cur, worst, worstt, DHMS_VARS(&ts)); - lprocfs_seq_at_hist_helper(m, &imp->imp_at.iat_service_estimate[i]); + seq_printf(m, "portal %-2d : cur %3u worst %3u (at %lld, %llds ago) ", + imp->imp_at.iat_portal[i], cur, worst, (s64)worstt, + (s64)(now - worstt)); + lprocfs_at_hist_helper(m, &imp->imp_at.iat_service_estimate[i]); } LPROCFS_CLIMP_EXIT(obd); @@ -1192,69 +1151,165 @@ int lprocfs_connect_flags_seq_show(struct seq_file *m, void *data) { struct obd_device *obd = data; __u64 flags; + __u64 flags2; LPROCFS_CLIMP_CHECK(obd); flags = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags; - seq_printf(m, "flags="LPX64"\n", flags); - obd_connect_seq_flags2str(m, flags, "\n"); + flags2 = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags2; + seq_printf(m, "flags=%#llx\n", flags); + seq_printf(m, "flags2=%#llx\n", flags2); + obd_connect_seq_flags2str(m, flags, flags2, "\n"); seq_printf(m, "\n"); LPROCFS_CLIMP_EXIT(obd); return 0; } EXPORT_SYMBOL(lprocfs_connect_flags_seq_show); -int -lprocfs_obd_setup(struct obd_device *obd) +static const struct attribute *obd_def_uuid_attrs[] = { + &lustre_attr_uuid.attr, + NULL, +}; + +static const struct attribute *obd_def_attrs[] = { + &lustre_attr_blocksize.attr, + &lustre_attr_kbytestotal.attr, + &lustre_attr_kbytesfree.attr, + &lustre_attr_kbytesavail.attr, + &lustre_attr_filestotal.attr, + &lustre_attr_filesfree.attr, + &lustre_attr_uuid.attr, + NULL, +}; + +static void obd_sysfs_release(struct kobject *kobj) { - int rc = 0; + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); - LASSERT(obd != NULL); - LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC); - LASSERT(obd->obd_type->typ_procroot != NULL); + complete(&obd->obd_kobj_unregister); +} + +int lprocfs_obd_setup(struct obd_device *obd, bool uuid_only) +{ + struct lprocfs_vars *debugfs_vars = NULL; + int rc; + + if (!obd || obd->obd_magic != OBD_DEVICE_MAGIC) + return -ENODEV; + + rc = kobject_set_name(&obd->obd_kset.kobj, "%s", obd->obd_name); + if (rc) + return rc; + + obd->obd_ktype.sysfs_ops = &lustre_sysfs_ops; + obd->obd_ktype.release = obd_sysfs_release; + + obd->obd_kset.kobj.parent = obd->obd_type->typ_kobj; + obd->obd_kset.kobj.ktype = &obd->obd_ktype; + init_completion(&obd->obd_kobj_unregister); + rc = kset_register(&obd->obd_kset); + if (rc) + return rc; - obd->obd_proc_entry = lprocfs_seq_register(obd->obd_name, - obd->obd_type->typ_procroot, - obd->obd_vars, obd); + if (uuid_only) + obd->obd_attrs = obd_def_uuid_attrs; + else + obd->obd_attrs = obd_def_attrs; + + rc = sysfs_create_files(&obd->obd_kset.kobj, obd->obd_attrs); + if (rc) { + kset_unregister(&obd->obd_kset); + return rc; + } + + if (!obd->obd_type->typ_procroot) + debugfs_vars = obd->obd_vars; + obd->obd_debugfs_entry = ldebugfs_register(obd->obd_name, + obd->obd_type->typ_debugfs_entry, + debugfs_vars, obd); + if (IS_ERR_OR_NULL(obd->obd_debugfs_entry)) { + rc = obd->obd_debugfs_entry ? PTR_ERR(obd->obd_debugfs_entry) + : -ENOMEM; + CERROR("error %d setting up debugfs for %s\n", + rc, obd->obd_name); + obd->obd_debugfs_entry = NULL; + + sysfs_remove_files(&obd->obd_kset.kobj, obd->obd_attrs); + obd->obd_attrs = NULL; + kset_unregister(&obd->obd_kset); + return rc; + } + + if (obd->obd_proc_entry || !obd->obd_type->typ_procroot) + GOTO(already_registered, rc); + + obd->obd_proc_entry = lprocfs_register(obd->obd_name, + obd->obd_type->typ_procroot, + obd->obd_vars, obd); if (IS_ERR(obd->obd_proc_entry)) { rc = PTR_ERR(obd->obd_proc_entry); CERROR("error %d setting up lprocfs for %s\n",rc,obd->obd_name); obd->obd_proc_entry = NULL; + + ldebugfs_remove(&obd->obd_debugfs_entry); + sysfs_remove_files(&obd->obd_kset.kobj, obd->obd_attrs); + obd->obd_attrs = NULL; + kset_unregister(&obd->obd_kset); + return rc; } +already_registered: return rc; } EXPORT_SYMBOL(lprocfs_obd_setup); int lprocfs_obd_cleanup(struct obd_device *obd) { - if (!obd) - return -EINVAL; - if (obd->obd_proc_exports_entry) { - /* Should be no exports left */ - lprocfs_remove(&obd->obd_proc_exports_entry); - obd->obd_proc_exports_entry = NULL; - } - if (obd->obd_proc_entry) { - lprocfs_remove(&obd->obd_proc_entry); - obd->obd_proc_entry = NULL; - } - return 0; + if (!obd) + return -EINVAL; + + if (obd->obd_proc_exports_entry) { + /* Should be no exports left */ + lprocfs_remove(&obd->obd_proc_exports_entry); + obd->obd_proc_exports_entry = NULL; + } + + if (obd->obd_proc_entry) { + lprocfs_remove(&obd->obd_proc_entry); + obd->obd_proc_entry = NULL; + } + + if (!IS_ERR_OR_NULL(obd->obd_debugfs_entry)) + ldebugfs_remove(&obd->obd_debugfs_entry); + + /* obd device never allocated a kset */ + if (!obd->obd_kset.kobj.state_initialized) + return 0; + + if (obd->obd_attrs) { + sysfs_remove_files(&obd->obd_kset.kobj, obd->obd_attrs); + obd->obd_attrs = NULL; + } + + kset_unregister(&obd->obd_kset); + wait_for_completion(&obd->obd_kobj_unregister); + return 0; } EXPORT_SYMBOL(lprocfs_obd_cleanup); int lprocfs_stats_alloc_one(struct lprocfs_stats *stats, unsigned int cpuid) { - struct lprocfs_counter *cntr; - unsigned int percpusize; - int rc = -ENOMEM; - unsigned long flags = 0; - int i; + struct lprocfs_counter *cntr; + unsigned int percpusize; + int rc = -ENOMEM; + unsigned long flags = 0; + int i; LASSERT(stats->ls_percpu[cpuid] == NULL); LASSERT((stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) == 0); percpusize = lprocfs_stats_counter_size(stats); LIBCFS_ALLOC_ATOMIC(stats->ls_percpu[cpuid], percpusize); - if (stats->ls_percpu[cpuid] != NULL) { + if (stats->ls_percpu[cpuid]) { rc = 0; if (unlikely(stats->ls_biggest_alloc_num <= cpuid)) { if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) @@ -1277,21 +1332,20 @@ int lprocfs_stats_alloc_one(struct lprocfs_stats *stats, unsigned int cpuid) } return rc; } -EXPORT_SYMBOL(lprocfs_stats_alloc_one); struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num, enum lprocfs_stats_flags flags) { - struct lprocfs_stats *stats; - unsigned int num_entry; - unsigned int percpusize = 0; - int i; + struct lprocfs_stats *stats; + unsigned int num_entry; + unsigned int percpusize = 0; + int i; - if (num == 0) - return NULL; + if (num == 0) + return NULL; - if (lprocfs_no_percpu_stats != 0) - flags |= LPROCFS_STATS_FLAG_NOPERCPU; + if (lprocfs_no_percpu_stats != 0) + flags |= LPROCFS_STATS_FLAG_NOPERCPU; if (flags & LPROCFS_STATS_FLAG_NOPERCPU) num_entry = 1; @@ -1300,7 +1354,7 @@ struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num, /* alloc percpu pointers for all possible cpu slots */ LIBCFS_ALLOC(stats, offsetof(typeof(*stats), ls_percpu[num_entry])); - if (stats == NULL) + if (!stats) return NULL; stats->ls_num = num; @@ -1310,14 +1364,14 @@ struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num, /* alloc num of counter headers */ LIBCFS_ALLOC(stats->ls_cnt_header, stats->ls_num * sizeof(struct lprocfs_counter_header)); - if (stats->ls_cnt_header == NULL) + if (!stats->ls_cnt_header) goto fail; if ((flags & LPROCFS_STATS_FLAG_NOPERCPU) != 0) { /* contains only one set counters */ percpusize = lprocfs_stats_counter_size(stats); LIBCFS_ALLOC_ATOMIC(stats->ls_percpu[0], percpusize); - if (stats->ls_percpu[0] == NULL) + if (!stats->ls_percpu[0]) goto fail; stats->ls_biggest_alloc_num = 1; } else if ((flags & LPROCFS_STATS_FLAG_IRQ_SAFE) != 0) { @@ -1342,9 +1396,9 @@ void lprocfs_free_stats(struct lprocfs_stats **statsh) unsigned int percpusize; unsigned int i; - if (stats == NULL || stats->ls_num == 0) - return; - *statsh = NULL; + if (!stats || stats->ls_num == 0) + return; + *statsh = NULL; if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) num_entry = 1; @@ -1353,27 +1407,53 @@ void lprocfs_free_stats(struct lprocfs_stats **statsh) percpusize = lprocfs_stats_counter_size(stats); for (i = 0; i < num_entry; i++) - if (stats->ls_percpu[i] != NULL) + if (stats->ls_percpu[i]) LIBCFS_FREE(stats->ls_percpu[i], percpusize); - if (stats->ls_cnt_header != NULL) + if (stats->ls_cnt_header) LIBCFS_FREE(stats->ls_cnt_header, stats->ls_num * sizeof(struct lprocfs_counter_header)); LIBCFS_FREE(stats, offsetof(typeof(*stats), ls_percpu[num_entry])); } EXPORT_SYMBOL(lprocfs_free_stats); +u64 lprocfs_stats_collector(struct lprocfs_stats *stats, int idx, + enum lprocfs_fields_flags field) +{ + unsigned long flags = 0; + unsigned int num_cpu; + unsigned int i; + u64 ret = 0; + + LASSERT(stats); + + num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); + for (i = 0; i < num_cpu; i++) { + struct lprocfs_counter *cntr; + + if (!stats->ls_percpu[i]) + continue; + + cntr = lprocfs_stats_counter_get(stats, i, idx); + ret += lprocfs_read_helper(cntr, &stats->ls_cnt_header[idx], + stats->ls_flags, field); + } + lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags); + return ret; +} +EXPORT_SYMBOL(lprocfs_stats_collector); + void lprocfs_clear_stats(struct lprocfs_stats *stats) { - struct lprocfs_counter *percpu_cntr; - int i; - int j; - unsigned int num_entry; - unsigned long flags = 0; + struct lprocfs_counter *percpu_cntr; + int i; + int j; + unsigned int num_entry; + unsigned long flags = 0; num_entry = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); for (i = 0; i < num_entry; i++) { - if (stats->ls_percpu[i] == NULL) + if (!stats->ls_percpu[i]) continue; for (j = 0; j < stats->ls_num; j++) { percpu_cntr = lprocfs_stats_counter_get(stats, i, j); @@ -1395,12 +1475,12 @@ static ssize_t lprocfs_stats_seq_write(struct file *file, const char __user *buf, size_t len, loff_t *off) { - struct seq_file *seq = file->private_data; - struct lprocfs_stats *stats = seq->private; + struct seq_file *seq = file->private_data; + struct lprocfs_stats *stats = seq->private; - lprocfs_clear_stats(stats); + lprocfs_clear_stats(stats); - return len; + return len; } static void *lprocfs_stats_seq_start(struct seq_file *p, loff_t *pos) @@ -1424,49 +1504,39 @@ static void *lprocfs_stats_seq_next(struct seq_file *p, void *v, loff_t *pos) /* seq file export of one lprocfs counter */ static int lprocfs_stats_seq_show(struct seq_file *p, void *v) { - struct lprocfs_stats *stats = p->private; - struct lprocfs_counter_header *hdr; - struct lprocfs_counter ctr; - int idx = *(loff_t *)v; - int rc = 0; + struct lprocfs_stats *stats = p->private; + struct lprocfs_counter_header *hdr; + struct lprocfs_counter ctr; + int idx = *(loff_t *)v; if (idx == 0) { - struct timeval now; + struct timespec64 now; - do_gettimeofday(&now); - rc = seq_printf(p, "%-25s %lu.%lu secs.usecs\n", - "snapshot_time", now.tv_sec, now.tv_usec); - if (rc < 0) - return rc; + ktime_get_real_ts64(&now); + seq_printf(p, "%-25s %llu.%09lu secs.nsecs\n", + "snapshot_time", (s64)now.tv_sec, now.tv_nsec); } hdr = &stats->ls_cnt_header[idx]; lprocfs_stats_collect(stats, idx, &ctr); if (ctr.lc_count == 0) - goto out; + return 0; - rc = seq_printf(p, "%-25s "LPD64" samples [%s]", hdr->lc_name, - ctr.lc_count, hdr->lc_units); - if (rc < 0) - goto out; + seq_printf(p, "%-25s %lld samples [%s]", hdr->lc_name, + ctr.lc_count, hdr->lc_units); if ((hdr->lc_config & LPROCFS_CNTR_AVGMINMAX) && ctr.lc_count > 0) { - rc = seq_printf(p, " "LPD64" "LPD64" "LPD64, - ctr.lc_min, ctr.lc_max, ctr.lc_sum); - if (rc < 0) - goto out; + seq_printf(p, " %lld %lld %lld", + ctr.lc_min, ctr.lc_max, ctr.lc_sum); if (hdr->lc_config & LPROCFS_CNTR_STDDEV) - rc = seq_printf(p, " "LPD64, ctr.lc_sumsquare); - if (rc < 0) - goto out; + seq_printf(p, " %llu", ctr.lc_sumsquare); } - rc = seq_printf(p, "\n"); -out: - return (rc < 0) ? rc : 0; + seq_putc(p, '\n'); + return 0; } -struct seq_operations lprocfs_stats_seq_sops = { +static const struct seq_operations lprocfs_stats_seq_sops = { .start = lprocfs_stats_seq_start, .stop = lprocfs_stats_seq_stop, .next = lprocfs_stats_seq_next, @@ -1478,27 +1548,43 @@ static int lprocfs_stats_seq_open(struct inode *inode, struct file *file) struct seq_file *seq; int rc; -#ifndef HAVE_ONLY_PROCFS_SEQ - if (LPROCFS_ENTRY_CHECK(PDE(inode))) - return -ENOENT; -#endif + rc = LPROCFS_ENTRY_CHECK(inode); + if (rc < 0) + return rc; + rc = seq_open(file, &lprocfs_stats_seq_sops); if (rc) return rc; seq = file->private_data; - seq->private = PDE_DATA(inode); + seq->private = inode->i_private ? inode->i_private : PDE_DATA(inode); return 0; } -struct file_operations lprocfs_stats_seq_fops = { - .owner = THIS_MODULE, - .open = lprocfs_stats_seq_open, - .read = seq_read, - .write = lprocfs_stats_seq_write, - .llseek = seq_lseek, - .release = lprocfs_seq_release, +static const struct file_operations lprocfs_stats_seq_fops = { + .owner = THIS_MODULE, + .open = lprocfs_stats_seq_open, + .read = seq_read, + .write = lprocfs_stats_seq_write, + .llseek = seq_lseek, + .release = lprocfs_seq_release, }; +int ldebugfs_register_stats(struct dentry *parent, const char *name, + struct lprocfs_stats *stats) +{ + struct dentry *entry; + + LASSERT(!IS_ERR_OR_NULL(parent)); + + entry = debugfs_create_file(name, 0644, parent, stats, + &lprocfs_stats_seq_fops); + if (IS_ERR_OR_NULL(entry)) + return entry ? PTR_ERR(entry) : -ENOMEM; + + return 0; +} +EXPORT_SYMBOL_GPL(ldebugfs_register_stats); + int lprocfs_register_stats(struct proc_dir_entry *root, const char *name, struct lprocfs_stats *stats) { @@ -1507,7 +1593,7 @@ int lprocfs_register_stats(struct proc_dir_entry *root, const char *name, entry = proc_create_data(name, 0644, root, &lprocfs_stats_seq_fops, stats); - if (entry == NULL) + if (!entry) return -ENOMEM; return 0; } @@ -1516,11 +1602,11 @@ EXPORT_SYMBOL(lprocfs_register_stats); void lprocfs_counter_init(struct lprocfs_stats *stats, int index, unsigned conf, const char *name, const char *units) { - struct lprocfs_counter_header *header; - struct lprocfs_counter *percpu_cntr; - unsigned long flags = 0; - unsigned int i; - unsigned int num_cpu; + struct lprocfs_counter_header *header; + struct lprocfs_counter *percpu_cntr; + unsigned long flags = 0; + unsigned int i; + unsigned int num_cpu; LASSERT(stats != NULL); @@ -1534,7 +1620,7 @@ void lprocfs_counter_init(struct lprocfs_stats *stats, int index, num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); for (i = 0; i < num_cpu; ++i) { - if (stats->ls_percpu[i] == NULL) + if (!stats->ls_percpu[i]) continue; percpu_cntr = lprocfs_stats_counter_get(stats, i, index); percpu_cntr->lc_count = 0; @@ -1549,56 +1635,23 @@ void lprocfs_counter_init(struct lprocfs_stats *stats, int index, } EXPORT_SYMBOL(lprocfs_counter_init); -/* Note that we only init md counters for ops whose offset is less - * than NUM_MD_STATS. This is explained in a comment in the definition - * of struct md_ops. */ -#define LPROCFS_MD_OP_INIT(base, stats, op) \ - do { \ - unsigned int _idx = base + MD_COUNTER_OFFSET(op); \ - \ - if (MD_COUNTER_OFFSET(op) < NUM_MD_STATS) { \ - LASSERT(_idx < stats->ls_num); \ - lprocfs_counter_init(stats, _idx, 0, #op, "reqs"); \ - } \ - } while (0) - -void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats) -{ - LPROCFS_MD_OP_INIT(num_private_stats, stats, getstatus); - LPROCFS_MD_OP_INIT(num_private_stats, stats, null_inode); - LPROCFS_MD_OP_INIT(num_private_stats, stats, find_cbdata); - LPROCFS_MD_OP_INIT(num_private_stats, stats, close); - LPROCFS_MD_OP_INIT(num_private_stats, stats, create); - LPROCFS_MD_OP_INIT(num_private_stats, stats, done_writing); - LPROCFS_MD_OP_INIT(num_private_stats, stats, enqueue); - LPROCFS_MD_OP_INIT(num_private_stats, stats, getattr); - LPROCFS_MD_OP_INIT(num_private_stats, stats, getattr_name); - LPROCFS_MD_OP_INIT(num_private_stats, stats, intent_lock); - LPROCFS_MD_OP_INIT(num_private_stats, stats, link); - LPROCFS_MD_OP_INIT(num_private_stats, stats, rename); - LPROCFS_MD_OP_INIT(num_private_stats, stats, setattr); - LPROCFS_MD_OP_INIT(num_private_stats, stats, fsync); - LPROCFS_MD_OP_INIT(num_private_stats, stats, read_page); - LPROCFS_MD_OP_INIT(num_private_stats, stats, unlink); - LPROCFS_MD_OP_INIT(num_private_stats, stats, setxattr); - LPROCFS_MD_OP_INIT(num_private_stats, stats, getxattr); - LPROCFS_MD_OP_INIT(num_private_stats, stats, init_ea_size); - LPROCFS_MD_OP_INIT(num_private_stats, stats, get_lustre_md); - LPROCFS_MD_OP_INIT(num_private_stats, stats, free_lustre_md); - LPROCFS_MD_OP_INIT(num_private_stats, stats, update_lsm_md); - LPROCFS_MD_OP_INIT(num_private_stats, stats, merge_attr); - LPROCFS_MD_OP_INIT(num_private_stats, stats, set_open_replay_data); - LPROCFS_MD_OP_INIT(num_private_stats, stats, clear_open_replay_data); - LPROCFS_MD_OP_INIT(num_private_stats, stats, set_lock_data); - LPROCFS_MD_OP_INIT(num_private_stats, stats, lock_match); - LPROCFS_MD_OP_INIT(num_private_stats, stats, cancel_unused); - LPROCFS_MD_OP_INIT(num_private_stats, stats, renew_capa); - LPROCFS_MD_OP_INIT(num_private_stats, stats, unpack_capa); - LPROCFS_MD_OP_INIT(num_private_stats, stats, get_remote_perm); - LPROCFS_MD_OP_INIT(num_private_stats, stats, intent_getattr_async); - LPROCFS_MD_OP_INIT(num_private_stats, stats, revalidate_lock); -} -EXPORT_SYMBOL(lprocfs_init_mps_stats); +static const char * const mps_stats[] = { + [LPROC_MD_CLOSE] = "close", + [LPROC_MD_CREATE] = "create", + [LPROC_MD_ENQUEUE] = "enqueue", + [LPROC_MD_GETATTR] = "getattr", + [LPROC_MD_INTENT_LOCK] = "intent_lock", + [LPROC_MD_LINK] = "link", + [LPROC_MD_RENAME] = "rename", + [LPROC_MD_SETATTR] = "setattr", + [LPROC_MD_FSYNC] = "fsync", + [LPROC_MD_READ_PAGE] = "read_page", + [LPROC_MD_UNLINK] = "unlink", + [LPROC_MD_SETXATTR] = "setxattr", + [LPROC_MD_GETXATTR] = "getxattr", + [LPROC_MD_INTENT_GETATTR_ASYNC] = "intent_getattr_async", + [LPROC_MD_REVALIDATE_LOCK] = "revalidate_lock", +}; int lprocfs_alloc_md_stats(struct obd_device *obd, unsigned int num_private_stats) @@ -1607,11 +1660,8 @@ int lprocfs_alloc_md_stats(struct obd_device *obd, unsigned int num_stats; int rc, i; - CLASSERT(offsetof(struct md_ops, MD_STATS_FIRST_OP) == 0); - CLASSERT(_MD_COUNTER_OFFSET(MD_STATS_FIRST_OP) == 0); - CLASSERT(_MD_COUNTER_OFFSET(MD_STATS_LAST_OP) > 0); - - /* TODO Ensure that this function is only used where + /* + * TODO Ensure that this function is only used where * appropriate by adding an assertion to the effect that * obd->obd_type->typ_md_ops is not NULL. We can't do this now * because mdt_procfs_init() uses this function to allocate @@ -1621,20 +1671,17 @@ int lprocfs_alloc_md_stats(struct obd_device *obd, */ LASSERT(obd->obd_proc_entry != NULL); LASSERT(obd->obd_md_stats == NULL); - LASSERT(obd->obd_md_cntr_base == 0); - num_stats = NUM_MD_STATS + num_private_stats; + num_stats = ARRAY_SIZE(mps_stats) + num_private_stats; stats = lprocfs_alloc_stats(num_stats, 0); - if (stats == NULL) + if (!stats) return -ENOMEM; - lprocfs_init_mps_stats(num_private_stats, stats); - - for (i = num_private_stats; i < num_stats; i++) { - if (stats->ls_cnt_header[i].lc_name == NULL) { - CERROR("Missing md_stat initializer md_op " - "operation at offset %d. Aborting.\n", - i - num_private_stats); + for (i = 0; i < ARRAY_SIZE(mps_stats); i++) { + lprocfs_counter_init(stats, i, 0, mps_stats[i], "reqs"); + if (!stats->ls_cnt_header[i].lc_name) { + CERROR("Missing md_stat initializer md_op operation at offset %d. Aborting.\n", + i); LBUG(); } } @@ -1644,7 +1691,6 @@ int lprocfs_alloc_md_stats(struct obd_device *obd, lprocfs_free_stats(&stats); } else { obd->obd_md_stats = stats; - obd->obd_md_cntr_base = num_private_stats; } return rc; @@ -1655,9 +1701,8 @@ void lprocfs_free_md_stats(struct obd_device *obd) { struct lprocfs_stats *stats = obd->obd_md_stats; - if (stats != NULL) { + if (stats) { obd->obd_md_stats = NULL; - obd->obd_md_cntr_base = 0; lprocfs_free_stats(&stats); } } @@ -1665,24 +1710,24 @@ EXPORT_SYMBOL(lprocfs_free_md_stats); void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats) { - lprocfs_counter_init(ldlm_stats, - LDLM_ENQUEUE - LDLM_FIRST_OPC, - 0, "ldlm_enqueue", "reqs"); - lprocfs_counter_init(ldlm_stats, - LDLM_CONVERT - LDLM_FIRST_OPC, - 0, "ldlm_convert", "reqs"); - lprocfs_counter_init(ldlm_stats, - LDLM_CANCEL - LDLM_FIRST_OPC, - 0, "ldlm_cancel", "reqs"); - lprocfs_counter_init(ldlm_stats, - LDLM_BL_CALLBACK - LDLM_FIRST_OPC, - 0, "ldlm_bl_callback", "reqs"); - lprocfs_counter_init(ldlm_stats, - LDLM_CP_CALLBACK - LDLM_FIRST_OPC, - 0, "ldlm_cp_callback", "reqs"); - lprocfs_counter_init(ldlm_stats, - LDLM_GL_CALLBACK - LDLM_FIRST_OPC, - 0, "ldlm_gl_callback", "reqs"); + lprocfs_counter_init(ldlm_stats, + LDLM_ENQUEUE - LDLM_FIRST_OPC, + 0, "ldlm_enqueue", "reqs"); + lprocfs_counter_init(ldlm_stats, + LDLM_CONVERT - LDLM_FIRST_OPC, + 0, "ldlm_convert", "reqs"); + lprocfs_counter_init(ldlm_stats, + LDLM_CANCEL - LDLM_FIRST_OPC, + 0, "ldlm_cancel", "reqs"); + lprocfs_counter_init(ldlm_stats, + LDLM_BL_CALLBACK - LDLM_FIRST_OPC, + 0, "ldlm_bl_callback", "reqs"); + lprocfs_counter_init(ldlm_stats, + LDLM_CP_CALLBACK - LDLM_FIRST_OPC, + 0, "ldlm_cp_callback", "reqs"); + lprocfs_counter_init(ldlm_stats, + LDLM_GL_CALLBACK - LDLM_FIRST_OPC, + 0, "ldlm_gl_callback", "reqs"); } EXPORT_SYMBOL(lprocfs_init_ldlm_stats); @@ -1693,7 +1738,7 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc, { __s64 ret = 0; - if (lc == NULL || header == NULL) + if (!lc || !header) RETURN(0); switch (field) { @@ -1727,108 +1772,58 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc, } EXPORT_SYMBOL(lprocfs_read_helper); -int lprocfs_write_helper(const char __user *buffer, unsigned long count, - int *val) -{ - return lprocfs_write_frac_helper(buffer, count, val, 1); -} -EXPORT_SYMBOL(lprocfs_write_helper); - -int lprocfs_write_frac_helper(const char __user *buffer, unsigned long count, - int *val, int mult) +int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val, + int mult) { - char kernbuf[20], *end, *pbuf; - - if (count > (sizeof(kernbuf) - 1)) - return -EINVAL; - - if (copy_from_user(kernbuf, buffer, count)) - return -EFAULT; - - kernbuf[count] = '\0'; - pbuf = kernbuf; - if (*pbuf == '-') { - mult = -mult; - pbuf++; - } - - *val = (int)simple_strtoul(pbuf, &end, 10) * mult; - if (pbuf == end) - return -EINVAL; - - if (end != NULL && *end == '.') { - int temp_val, pow = 1; - int i; - - pbuf = end + 1; - if (strlen(pbuf) > 5) - pbuf[5] = '\0'; /*only allow 5bits fractional*/ - - temp_val = (int)simple_strtoul(pbuf, &end, 10) * mult; + long decimal_val, frac_val; + int prtn; - if (pbuf < end) { - for (i = 0; i < (end - pbuf); i++) - pow *= 10; + if (count < 10) + return -EINVAL; - *val += temp_val / pow; - } - } - return 0; -} -EXPORT_SYMBOL(lprocfs_write_frac_helper); + decimal_val = val / mult; + prtn = snprintf(buffer, count, "%ld", decimal_val); + frac_val = val % mult; -int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val, - int mult) -{ - long decimal_val, frac_val; - int prtn; - - if (count < 10) - return -EINVAL; - - decimal_val = val / mult; - prtn = snprintf(buffer, count, "%ld", decimal_val); - frac_val = val % mult; - - if (prtn < (count - 4) && frac_val > 0) { - long temp_frac; - int i, temp_mult = 1, frac_bits = 0; - - temp_frac = frac_val * 10; - buffer[prtn++] = '.'; - while (frac_bits < 2 && (temp_frac / mult) < 1 ) { - /* only reserved 2 bits fraction */ - buffer[prtn++] ='0'; - temp_frac *= 10; - frac_bits++; - } - /* - * Need to think these cases : - * 1. #echo x.00 > /proc/xxx output result : x - * 2. #echo x.0x > /proc/xxx output result : x.0x - * 3. #echo x.x0 > /proc/xxx output result : x.x - * 4. #echo x.xx > /proc/xxx output result : x.xx - * Only reserved 2 bits fraction. - */ - for (i = 0; i < (5 - prtn); i++) - temp_mult *= 10; - - frac_bits = min((int)count - prtn, 3 - frac_bits); - prtn += snprintf(buffer + prtn, frac_bits, "%ld", - frac_val * temp_mult / mult); - - prtn--; - while(buffer[prtn] < '1' || buffer[prtn] > '9') { - prtn--; - if (buffer[prtn] == '.') { - prtn--; - break; - } - } - prtn++; - } - buffer[prtn++] ='\n'; - return prtn; + if (prtn < (count - 4) && frac_val > 0) { + long temp_frac; + int i, temp_mult = 1, frac_bits = 0; + + temp_frac = frac_val * 10; + buffer[prtn++] = '.'; + while (frac_bits < 2 && (temp_frac / mult) < 1) { + /* only reserved 2 bits fraction */ + buffer[prtn++] = '0'; + temp_frac *= 10; + frac_bits++; + } + /* + * Need to think these cases : + * 1. #echo x.00 > /proc/xxx output result : x + * 2. #echo x.0x > /proc/xxx output result : x.0x + * 3. #echo x.x0 > /proc/xxx output result : x.x + * 4. #echo x.xx > /proc/xxx output result : x.xx + * Only reserved 2 bits fraction. + */ + for (i = 0; i < (5 - prtn); i++) + temp_mult *= 10; + + frac_bits = min((int)count - prtn, 3 - frac_bits); + prtn += snprintf(buffer + prtn, frac_bits, "%ld", + frac_val * temp_mult / mult); + + prtn--; + while (buffer[prtn] < '1' || buffer[prtn] > '9') { + prtn--; + if (buffer[prtn] == '.') { + prtn--; + break; + } + } + prtn++; + } + buffer[prtn++] = '\n'; + return prtn; } EXPORT_SYMBOL(lprocfs_read_frac_helper); @@ -1857,79 +1852,293 @@ int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult) } EXPORT_SYMBOL(lprocfs_seq_read_frac_helper); -int lprocfs_write_u64_helper(const char __user *buffer, unsigned long count, - __u64 *val) +/* Obtains the conversion factor for the unit specified */ +static int get_mult(char unit, __u64 *mult) +{ + __u64 units = 1; + + switch (unit) { + /* peta, tera, giga, mega, and kilo */ + case 'p': + case 'P': + units <<= 10; + case 't': + case 'T': + units <<= 10; + case 'g': + case 'G': + units <<= 10; + case 'm': + case 'M': + units <<= 10; + case 'k': + case 'K': + units <<= 10; + break; + /* some tests expect % to be accepted */ + case '%': + units = 1; + break; + default: + return -EINVAL; + } + + *mult = units; + + return 0; +} + +/* + * Ensures the numeric string is valid. The function provides the final + * multiplier in the case a unit exists at the end of the string. It also + * locates the start of the whole and fractional parts (if any). This + * function modifies the string so kstrtoull can be used to parse both + * the whole and fraction portions. This function also figures out + * the base of the number. + */ +static int preprocess_numeric_str(char *buffer, __u64 *mult, __u64 def_mult, + bool allow_units, char **whole, char **frac, + unsigned int *base) { - return lprocfs_write_frac_u64_helper(buffer, count, val, 1); + bool hit_decimal = false; + bool hit_unit = false; + int rc = 0; + char *start; + *mult = def_mult; + *whole = NULL; + *frac = NULL; + *base = 10; + + /* a hex string if it starts with "0x" */ + if (buffer[0] == '0' && tolower(buffer[1]) == 'x') { + *base = 16; + buffer += 2; + } + + start = buffer; + + while (*buffer) { + /* allow for a single new line before the null terminator */ + if (*buffer == '\n') { + *buffer = '\0'; + buffer++; + + if (*buffer) + return -EINVAL; + + break; + } + + /* any chars after our unit indicates a malformed string */ + if (hit_unit) + return -EINVAL; + + /* ensure we only hit one decimal */ + if (*buffer == '.') { + if (hit_decimal) + return -EINVAL; + + /* if past start, there's a whole part */ + if (start != buffer) + *whole = start; + + *buffer = '\0'; + start = buffer + 1; + hit_decimal = true; + } else if (!isdigit(*buffer) && + !(*base == 16 && isxdigit(*buffer))) { + if (allow_units) { + /* if we allow units, attempt to get mult */ + hit_unit = true; + rc = get_mult(*buffer, mult); + if (rc) + return rc; + + /* string stops here, but keep processing */ + *buffer = '\0'; + } else { + /* bad string */ + return -EINVAL; + } + } + + buffer++; + } + + if (hit_decimal) { + /* hit a decimal, make sure there's a fractional part */ + if (!*start) + return -EINVAL; + + *frac = start; + } else { + /* didn't hit a decimal, but may have a whole part */ + if (start != buffer && *start) + *whole = start; + } + + /* malformed string if we didn't get anything */ + if (!*frac && !*whole) + return -EINVAL; + + return 0; } -EXPORT_SYMBOL(lprocfs_write_u64_helper); -int lprocfs_write_frac_u64_helper(const char __user *buffer, - unsigned long count, - __u64 *val, int mult) +/* + * Parses a numeric string which can contain a whole and fraction portion + * into a __u64. Accepts a multiplier to apply to the value parsed. Also + * allows the string to have a unit at the end. The function handles + * wrapping of the final unsigned value. + */ +static int str_to_u64_parse(char *buffer, unsigned long count, + __u64 *val, __u64 def_mult, bool allow_units) { - char kernbuf[22], *end, *pbuf; - __u64 whole, frac = 0, units; - unsigned frac_d = 1; + __u64 whole = 0; + __u64 frac = 0; + unsigned int frac_d = 1; + __u64 wrap_indicator = ULLONG_MAX; + int rc = 0; + __u64 mult; + char *strwhole; + char *strfrac; + unsigned int base = 10; - if (count > (sizeof(kernbuf) - 1)) - return -EINVAL; + rc = preprocess_numeric_str(buffer, &mult, def_mult, allow_units, + &strwhole, &strfrac, &base); - if (copy_from_user(kernbuf, buffer, count)) - return -EFAULT; - - kernbuf[count] = '\0'; - pbuf = kernbuf; - if (*pbuf == '-') { - mult = -mult; - pbuf++; - } - - whole = simple_strtoull(pbuf, &end, 10); - if (pbuf == end) - return -EINVAL; - - if (end != NULL && *end == '.') { - int i; - pbuf = end + 1; - - /* need to limit frac_d to a __u32 */ - if (strlen(pbuf) > 10) - pbuf[10] = '\0'; - - frac = simple_strtoull(pbuf, &end, 10); - /* count decimal places */ - for (i = 0; i < (end - pbuf); i++) - frac_d *= 10; - } - - units = 1; - if (end != NULL) { - switch (*end) { - case 'p': case 'P': - units <<= 10; - case 't': case 'T': - units <<= 10; - case 'g': case 'G': - units <<= 10; - case 'm': case 'M': - units <<= 10; - case 'k': case 'K': - units <<= 10; + if (rc) + return rc; + + if (mult == 0) { + *val = 0; + return 0; + } + + /* the multiplier limits how large the value can be */ + wrap_indicator = div64_u64(wrap_indicator, mult); + + if (strwhole) { + rc = kstrtoull(strwhole, base, &whole); + if (rc) + return rc; + + if (whole > wrap_indicator) + return -ERANGE; + + whole *= mult; + } + + if (strfrac) { + if (strlen(strfrac) > 10) + strfrac[10] = '\0'; + + rc = kstrtoull(strfrac, base, &frac); + if (rc) + return rc; + + /* determine power of fractional portion */ + while (*strfrac) { + frac_d *= base; + strfrac++; } + + /* fractional portion is too large to perform calculation */ + if (frac > wrap_indicator) + return -ERANGE; + + frac *= mult; + do_div(frac, frac_d); + } + + /* check that the sum of whole and fraction fits in u64 */ + if (whole > (ULLONG_MAX - frac)) + return -ERANGE; + + *val = whole + frac; + + return 0; +} + +/* + * This function parses numeric/hex strings into __s64. It accepts a multiplier + * which will apply to the value parsed. It also can allow the string to + * have a unit as the last character. The function handles overflow/underflow + * of the signed integer. + */ +static int str_to_s64_internal(const char __user *buffer, unsigned long count, + __s64 *val, __u64 def_mult, bool allow_units) +{ + char kernbuf[22]; + __u64 tmp; + unsigned int offset = 0; + int signed sign = 1; + __u64 max = LLONG_MAX; + int rc = 0; + + if (count > (sizeof(kernbuf) - 1)) + return -EINVAL; + + if (copy_from_user(kernbuf, buffer, count)) + return -EFAULT; + + kernbuf[count] = '\0'; + + /* keep track of our sign */ + if (*kernbuf == '-') { + sign = -1; + offset++; + /* equivalent to max = -LLONG_MIN, avoids overflow */ + max++; } - /* Specified units override the multiplier */ - if (units > 1) - mult = mult < 0 ? -units : units; - frac *= mult; - do_div(frac, frac_d); - *val = whole * mult + frac; - return 0; + rc = str_to_u64_parse(kernbuf + offset, count - offset, + &tmp, def_mult, allow_units); + if (rc) + return rc; + + /* check for overflow/underflow */ + if (max < tmp) + return -ERANGE; + + *val = (__s64)tmp * sign; + + return 0; } -EXPORT_SYMBOL(lprocfs_write_frac_u64_helper); -static char *lprocfs_strnstr(const char *s1, const char *s2, size_t len) +/** + * Convert a user string into a signed 64 bit number. This function produces + * an error when the value parsed from the string times multiplier underflows or + * overflows. This function only accepts strings that contains digits, an + * optional decimal, and a char representing a unit at the end. If a unit is + * specified in the string, the multiplier provided by the caller is ignored. + * This function can also accept hexadecimal strings which are prefixed with + * "0x". + * + * \param[in] buffer string consisting of numbers, a decimal, and a unit + * \param[in] count buffer length + * \param[in] val if successful, the value represented by the string + * \param[in] defunit default unit if string doesn't contain one + * + * \retval 0 on success + * \retval negative number on error + */ +int lprocfs_str_with_units_to_s64(const char __user *buffer, + unsigned long count, __s64 *val, char defunit) +{ + __u64 mult = 1; + int rc; + + if (defunit != '1') { + rc = get_mult(defunit, &mult); + if (rc) + return rc; + } + + return str_to_s64_internal(buffer, count, val, mult, true); +} +EXPORT_SYMBOL(lprocfs_str_with_units_to_s64); + +char *lprocfs_strnstr(const char *s1, const char *s2, size_t len) { size_t l2; @@ -1944,6 +2153,7 @@ static char *lprocfs_strnstr(const char *s1, const char *s2, size_t len) } return NULL; } +EXPORT_SYMBOL(lprocfs_strnstr); /** * Find the string \a name in the input \a buffer, and return a pointer to the @@ -1958,7 +2168,7 @@ char *lprocfs_find_named_value(const char *buffer, const char *name, /* there is no strnstr() in rhel5 and ubuntu kernels */ val = lprocfs_strnstr(buffer, name, buflen); - if (val == NULL) + if (!val) return (char *)buffer; val += strlen(name); /* skip prefix */ @@ -1975,6 +2185,22 @@ char *lprocfs_find_named_value(const char *buffer, const char *name, } EXPORT_SYMBOL(lprocfs_find_named_value); +int ldebugfs_seq_create(struct dentry *parent, const char *name, umode_t mode, + const struct file_operations *seq_fops, void *data) +{ + struct dentry *entry; + + /* Disallow secretly (un)writable entries. */ + LASSERT((!seq_fops->write) == (!(mode & 0222))); + + entry = debugfs_create_file(name, mode, parent, data, seq_fops); + if (IS_ERR_OR_NULL(entry)) + return entry ? PTR_ERR(entry) : -ENOMEM; + + return 0; +} +EXPORT_SYMBOL_GPL(ldebugfs_seq_create); + int lprocfs_seq_create(struct proc_dir_entry *parent, const char *name, mode_t mode, @@ -1989,7 +2215,7 @@ int lprocfs_seq_create(struct proc_dir_entry *parent, entry = proc_create_data(name, mode, parent, seq_fops, data); - if (entry == NULL) + if (!entry) RETURN(-ENOMEM); RETURN(0); @@ -2031,12 +2257,12 @@ EXPORT_SYMBOL(lprocfs_oh_tally_log2); unsigned long lprocfs_oh_sum(struct obd_histogram *oh) { - unsigned long ret = 0; - int i; + unsigned long ret = 0; + int i; - for (i = 0; i < OBD_HIST_MAX; i++) - ret += oh->oh_buckets[i]; - return ret; + for (i = 0; i < OBD_HIST_MAX; i++) + ret += oh->oh_buckets[i]; + return ret; } EXPORT_SYMBOL(lprocfs_oh_sum); @@ -2048,32 +2274,133 @@ void lprocfs_oh_clear(struct obd_histogram *oh) } EXPORT_SYMBOL(lprocfs_oh_clear); -int lprocfs_obd_rd_max_pages_per_rpc(char *page, char **start, off_t off, - int count, int *eof, void *data) +ssize_t lustre_attr_show(struct kobject *kobj, + struct attribute *attr, char *buf) +{ + struct lustre_attr *a = container_of(attr, struct lustre_attr, attr); + + return a->show ? a->show(kobj, attr, buf) : 0; +} +EXPORT_SYMBOL_GPL(lustre_attr_show); + +ssize_t lustre_attr_store(struct kobject *kobj, struct attribute *attr, + const char *buf, size_t len) { - struct obd_device *dev = data; - struct client_obd *cli = &dev->u.cli; - int rc; + struct lustre_attr *a = container_of(attr, struct lustre_attr, attr); - client_obd_list_lock(&cli->cl_loi_list_lock); - rc = snprintf(page, count, "%d\n", cli->cl_max_pages_per_rpc); - client_obd_list_unlock(&cli->cl_loi_list_lock); - return rc; + return a->store ? a->store(kobj, attr, buf, len) : len; } -EXPORT_SYMBOL(lprocfs_obd_rd_max_pages_per_rpc); +EXPORT_SYMBOL_GPL(lustre_attr_store); + +const struct sysfs_ops lustre_sysfs_ops = { + .show = lustre_attr_show, + .store = lustre_attr_store, +}; +EXPORT_SYMBOL_GPL(lustre_sysfs_ops); int lprocfs_obd_max_pages_per_rpc_seq_show(struct seq_file *m, void *data) { struct obd_device *dev = data; struct client_obd *cli = &dev->u.cli; + + spin_lock(&cli->cl_loi_list_lock); + seq_printf(m, "%d\n", cli->cl_max_pages_per_rpc); + spin_unlock(&cli->cl_loi_list_lock); + return 0; +} +EXPORT_SYMBOL(lprocfs_obd_max_pages_per_rpc_seq_show); + +ssize_t lprocfs_obd_max_pages_per_rpc_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct obd_device *dev = + ((struct seq_file *)file->private_data)->private; + struct client_obd *cli = &dev->u.cli; + struct obd_connect_data *ocd = &cli->cl_import->imp_connect_data; + int chunk_mask, rc; + s64 val; + + rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1'); + if (rc) + return rc; + if (val < 0) + return -ERANGE; + + /* if the max_pages is specified in bytes, convert to pages */ + if (val >= ONE_MB_BRW_SIZE) + val >>= PAGE_SHIFT; + + LPROCFS_CLIMP_CHECK(dev); + + chunk_mask = ~((1 << (cli->cl_chunkbits - PAGE_SHIFT)) - 1); + /* max_pages_per_rpc must be chunk aligned */ + val = (val + ~chunk_mask) & chunk_mask; + if (val == 0 || (ocd->ocd_brw_size != 0 && + val > ocd->ocd_brw_size >> PAGE_SHIFT)) { + LPROCFS_CLIMP_EXIT(dev); + return -ERANGE; + } + spin_lock(&cli->cl_loi_list_lock); + cli->cl_max_pages_per_rpc = val; + client_adjust_max_dirty(cli); + spin_unlock(&cli->cl_loi_list_lock); + + LPROCFS_CLIMP_EXIT(dev); + return count; +} +EXPORT_SYMBOL(lprocfs_obd_max_pages_per_rpc_seq_write); + +ssize_t short_io_bytes_show(struct kobject *kobj, struct attribute *attr, + char *buf) +{ + struct obd_device *dev = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct client_obd *cli = &dev->u.cli; int rc; - client_obd_list_lock(&cli->cl_loi_list_lock); - rc = seq_printf(m, "%d\n", cli->cl_max_pages_per_rpc); - client_obd_list_unlock(&cli->cl_loi_list_lock); + spin_lock(&cli->cl_loi_list_lock); + rc = sprintf(buf, "%d\n", cli->cl_max_short_io_bytes); + spin_unlock(&cli->cl_loi_list_lock); return rc; } -EXPORT_SYMBOL(lprocfs_obd_max_pages_per_rpc_seq_show); +EXPORT_SYMBOL(short_io_bytes_show); + +/* Used to catch people who think they're specifying pages. */ +#define MIN_SHORT_IO_BYTES 64U + +ssize_t short_io_bytes_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count) +{ + struct obd_device *dev = container_of(kobj, struct obd_device, + obd_kset.kobj); + struct client_obd *cli = &dev->u.cli; + u32 val; + int rc; + + LPROCFS_CLIMP_CHECK(dev); + + rc = kstrtouint(buffer, 0, &val); + if (rc) + GOTO(out, rc); + + if (val && (val < MIN_SHORT_IO_BYTES || val > OBD_MAX_SHORT_IO_BYTES)) + GOTO(out, rc = -ERANGE); + + rc = count; + + spin_lock(&cli->cl_loi_list_lock); + if (val > (cli->cl_max_pages_per_rpc << PAGE_SHIFT)) + rc = -ERANGE; + else + cli->cl_max_short_io_bytes = val; + spin_unlock(&cli->cl_loi_list_lock); + +out: + LPROCFS_CLIMP_EXIT(dev); + return rc; +} +EXPORT_SYMBOL(short_io_bytes_store); int lprocfs_wr_root_squash(const char __user *buffer, unsigned long count, struct root_squash_info *squash, char *name) @@ -2095,7 +2422,7 @@ int lprocfs_wr_root_squash(const char __user *buffer, unsigned long count, /* look for uid gid separator */ tmp = strchr(kernbuf, ':'); - if (tmp == NULL) { + if (!tmp) { errmsg = "needs uid:gid format"; GOTO(failed, rc = -EINVAL); } @@ -2122,7 +2449,7 @@ int lprocfs_wr_root_squash(const char __user *buffer, unsigned long count, RETURN(count); failed: - if (tmp != NULL) { + if (tmp) { tmp--; *tmp = ':'; } @@ -2144,6 +2471,7 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count, char *kernbuf = NULL; char *errmsg; struct list_head tmp; + int len = count; ENTRY; if (count > 4096) { @@ -2152,7 +2480,7 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count, } OBD_ALLOC(kernbuf, count + 1); - if (kernbuf == NULL) { + if (!kernbuf) { errmsg = "no memory"; GOTO(failed, rc = -ENOMEM); } @@ -2163,9 +2491,10 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count, kernbuf[count] = '\0'; if (count > 0 && kernbuf[count - 1] == '\n') - kernbuf[count - 1] = '\0'; + len = count - 1; - if (strcmp(kernbuf, "NONE") == 0 || strcmp(kernbuf, "clear") == 0) { + if ((len == 4 && strncmp(kernbuf, "NONE", len) == 0) || + (len == 5 && strncmp(kernbuf, "clear", len) == 0)) { /* empty string is special case */ down_write(&squash->rsi_sem); if (!list_empty(&squash->rsi_nosquash_nids)) @@ -2207,4 +2536,4 @@ failed: } EXPORT_SYMBOL(lprocfs_wr_nosquash_nids); -#endif /* LPROCFS*/ +#endif /* CONFIG_PROC_FS*/