X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=7d7299c68de4844c47407c97cd2937a3d572c8c3;hp=95c701970ec42246420f0116f296282b1218999f;hb=0c51fa10d3b36eb9810d219a273738f02e56783f;hpb=e0ece89e1ac014a8443fe95860c4a43b88f16f63 diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index 95c7019..7d7299c 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -27,7 +27,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, 2015, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -40,16 +40,15 @@ #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 @@ -117,204 +116,7 @@ struct proc_dir_entry *lprocfs_add_symlink(const char *name, } 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) -{ - struct proc_dir_entry *temp; - - if (head == NULL) - return NULL; - - temp = head->subdir; - while (temp != NULL) { - if (strcmp(temp->name, name) == 0) - return temp; - temp = temp->next; - } - 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; -} -EXPORT_SYMBOL(lprocfs_add_vars); -#endif /** * Add /proc entries. @@ -328,8 +130,8 @@ 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) return -EINVAL; @@ -355,9 +157,13 @@ lprocfs_seq_add_vars(struct proc_dir_entry *root, struct lprocfs_seq_vars *list, } return 0; } -EXPORT_SYMBOL(lprocfs_seq_add_vars); +EXPORT_SYMBOL(lprocfs_add_vars); + +#ifndef HAVE_REMOVE_PROC_SUBTREE +/* for b=10866, global variable */ +DECLARE_RWSEM(_lprocfs_lock); +EXPORT_SYMBOL(_lprocfs_lock); -#ifndef HAVE_ONLY_PROCFS_SEQ static void lprocfs_remove_nolock(struct proc_dir_entry **proot) { struct proc_dir_entry *root = *proot; @@ -390,31 +196,8 @@ static void lprocfs_remove_nolock(struct proc_dir_entry **proot) break; } } -#endif - -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); - -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); -#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; @@ -423,8 +206,7 @@ void lprocfs_try_remove_proc_entry(const char *name, 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,47 +235,42 @@ void lprocfs_try_remove_proc_entry(const char *name, if (busy == 0) lprocfs_remove_nolock(&t); - LPROCFS_WRITE_EXIT(); - - return; + up_write(&_lprocfs_lock); + return 0; } -EXPORT_SYMBOL(lprocfs_try_remove_proc_entry); +#endif /* !HAVE_REMOVE_PROC_SUBTREE */ -struct proc_dir_entry *lprocfs_register(const char *name, - struct proc_dir_entry *parent, - struct lprocfs_vars *list, void *data) +#ifndef HAVE_PROC_REMOVE +void proc_remove(struct proc_dir_entry *de) { - struct proc_dir_entry *entry; - int rc; - - LPROCFS_WRITE_ENTRY(); - entry = __lprocfs_srch(parent, name); - if (entry != NULL) { - CERROR("entry '%s' already registered\n", name); - GOTO(out, entry = ERR_PTR(-EALREADY)); - } +#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 +} +#endif - entry = proc_mkdir(name, parent); - if (entry == NULL) - GOTO(out, entry = ERR_PTR(-ENOMEM)); +void lprocfs_remove(struct proc_dir_entry **rooth) +{ + proc_remove(*rooth); + *rooth = NULL; +} +EXPORT_SYMBOL(lprocfs_remove); - if (list != NULL) { - rc = __lprocfs_add_vars(entry, list, data); - if (rc != 0) { - lprocfs_remove_nolock(&entry); - GOTO(out, entry = ERR_PTR(rc)); - } - } -out: - LPROCFS_WRITE_EXIT(); - return entry; +void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent) +{ + LASSERT(parent != NULL); + remove_proc_entry(name, parent); } -EXPORT_SYMBOL(lprocfs_register); -#endif +EXPORT_SYMBOL(lprocfs_remove_proc_entry); 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; @@ -502,7 +279,7 @@ lprocfs_seq_register(const char *name, struct proc_dir_entry *parent, return ERR_PTR(-ENOMEM); if (list != NULL) { - int rc = lprocfs_seq_add_vars(newchild, list, data); + int rc = lprocfs_add_vars(newchild, list, data); if (rc) { lprocfs_remove(&newchild); return ERR_PTR(rc); @@ -510,12 +287,13 @@ 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); + seq_printf(m, "%u\n", *(unsigned int *)data); + return 0; } EXPORT_SYMBOL(lprocfs_uint_seq_show); @@ -543,9 +321,10 @@ 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; + int rc; + __s64 val = 0; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc < 0) return rc; @@ -556,7 +335,8 @@ 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); + seq_printf(m, LPU64"\n", *(__u64 *)data); + return 0; } EXPORT_SYMBOL(lprocfs_u64_seq_show); @@ -564,7 +344,8 @@ 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)); + seq_printf(m, "%d\n", atomic_read(atom)); + return 0; } EXPORT_SYMBOL(lprocfs_atomic_seq_show); @@ -573,14 +354,14 @@ 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; + __s64 val = 0; int rc; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc < 0) return rc; - if (val <= 0) + if (val <= 0 || val > INT_MAX) return -ERANGE; atomic_set(atm, val); @@ -593,7 +374,8 @@ 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); @@ -602,7 +384,8 @@ int lprocfs_name_seq_show(struct seq_file *m, void *data) struct obd_device *dev = data; LASSERT(dev != NULL); - return seq_printf(m, "%s\n", dev->obd_name); + seq_printf(m, "%s\n", dev->obd_name); + return 0; } EXPORT_SYMBOL(lprocfs_name_seq_show); @@ -614,7 +397,7 @@ int lprocfs_blksize_seq_show(struct seq_file *m, void *data) cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) - rc = seq_printf(m, "%u\n", osfs.os_bsize); + seq_printf(m, "%u\n", osfs.os_bsize); return rc; } EXPORT_SYMBOL(lprocfs_blksize_seq_show); @@ -633,7 +416,7 @@ int lprocfs_kbytestotal_seq_show(struct seq_file *m, void *data) while (blk_size >>= 1) result <<= 1; - rc = seq_printf(m, LPU64"\n", result); + seq_printf(m, LPU64"\n", result); } return rc; } @@ -653,7 +436,7 @@ int lprocfs_kbytesfree_seq_show(struct seq_file *m, void *data) while (blk_size >>= 1) result <<= 1; - rc = seq_printf(m, LPU64"\n", result); + seq_printf(m, LPU64"\n", result); } return rc; } @@ -673,7 +456,7 @@ int lprocfs_kbytesavail_seq_show(struct seq_file *m, void *data) while (blk_size >>= 1) result <<= 1; - rc = seq_printf(m, LPU64"\n", result); + seq_printf(m, LPU64"\n", result); } return rc; } @@ -687,7 +470,7 @@ int lprocfs_filestotal_seq_show(struct seq_file *m, void *data) cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) - rc = seq_printf(m, LPU64"\n", osfs.os_files); + seq_printf(m, LPU64"\n", osfs.os_files); return rc; } EXPORT_SYMBOL(lprocfs_filestotal_seq_show); @@ -700,7 +483,7 @@ int lprocfs_filesfree_seq_show(struct seq_file *m, void *data) cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) - rc = seq_printf(m, LPU64"\n", osfs.os_ffree); + seq_printf(m, LPU64"\n", osfs.os_ffree); return rc; } EXPORT_SYMBOL(lprocfs_filesfree_seq_show); @@ -716,8 +499,8 @@ 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; @@ -735,9 +518,9 @@ int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data) 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); + seq_printf(m, "%s\n", conn->c_remote_uuid.uuid); else - rc = seq_printf(m, "%s\n", ""); + seq_printf(m, "%s\n", ""); LPROCFS_CLIMP_EXIT(obd); return rc; @@ -781,7 +564,6 @@ 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. @@ -817,6 +599,7 @@ static void obd_import_flags2str(struct obd_import *imp, struct seq_file *m) #undef flag2str static const char *obd_connect_names[] = { + /* flags names */ "read_only", "lov_index", "connect_from_mds", @@ -874,44 +657,88 @@ static const char *obd_connect_names[] = { "lfsck", "unknown", "unlink_close", - "unknown", + "multi_mod_rpcs", "dir_stripe", - "unknown", + "subtree", + "lock_ahead", + "bulk_mbits", + "compact_obdo", + "second_flags", + /* flags2 names */ + "file_secctx", NULL }; -static void obd_connect_seq_flags2str(struct seq_file *m, __u64 flags, char *sep) +static 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)) + + if (flags & ~(mask - 1)) { seq_printf(m, "%sunknown_"LPX64, 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_"LPX64, + first ? "" : sep, flags2 & ~(mask - 1)); + first = false; + } } -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, 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_"LPX64, + ret ? sep : "", flags2 & ~(mask - 1)); + return ret; } EXPORT_SYMBOL(obd_connect_flags2str); @@ -919,22 +746,22 @@ EXPORT_SYMBOL(obd_connect_flags2str); static 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: "LPX64"\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) @@ -945,29 +772,35 @@ static void obd_connect_data_seqprint(struct seq_file *m, 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); + 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); + 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); + 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) { + char nidstr[LNET_NIDSTR_SIZE]; struct lprocfs_counter ret; struct lprocfs_counter_header *header; struct obd_device *obd = (struct obd_device *)data; @@ -984,40 +817,46 @@ 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 != NULL) + 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", + nidstr, + imp->imp_conn_cnt, + imp->imp_generation, + atomic_read(&imp->imp_inval_count)); spin_unlock(&imp->imp_lock); if (obd->obd_svc_stats == NULL) @@ -1033,14 +872,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: "LPU64" %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 +889,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: "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); /* avg data rates */ for (rw = 0; rw <= 1; rw++) { @@ -1074,9 +913,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: "LPU64"\n", + rw ? "write" : "read", + ret.lc_sum); } k = (int)ret.lc_sum; j = opcode_offset(OST_READ + rw) + EXTRA_MAX_OPCODES; @@ -1088,11 +927,11 @@ 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_per_rpc: "LPU64"\n", - header->lc_units, ret.lc_sum); + 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); } } @@ -1131,7 +970,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 +978,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) @@ -1168,7 +1007,7 @@ int lprocfs_timeouts_seq_show(struct seq_file *m, void *data) 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); + 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) @@ -1180,7 +1019,7 @@ int lprocfs_timeouts_seq_show(struct seq_file *m, void *data) 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]); + lprocfs_at_hist_helper(m, &imp->imp_at.iat_service_estimate[i]); } LPROCFS_CLIMP_EXIT(obd); @@ -1192,11 +1031,14 @@ 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; + flags2 = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags2; seq_printf(m, "flags="LPX64"\n", flags); - obd_connect_seq_flags2str(m, flags, "\n"); + seq_printf(m, "flags2="LPX64"\n", flags2); + obd_connect_seq_flags2str(m, flags, flags2, "\n"); seq_printf(m, "\n"); LPROCFS_CLIMP_EXIT(obd); return 0; @@ -1212,9 +1054,9 @@ lprocfs_obd_setup(struct obd_device *obd) LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC); LASSERT(obd->obd_type->typ_procroot != NULL); - obd->obd_proc_entry = lprocfs_seq_register(obd->obd_name, - obd->obd_type->typ_procroot, - obd->obd_vars, obd); + 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); @@ -1428,42 +1270,32 @@ static int lprocfs_stats_seq_show(struct seq_file *p, void *v) struct lprocfs_counter_header *hdr; struct lprocfs_counter ctr; int idx = *(loff_t *)v; - int rc = 0; if (idx == 0) { struct timeval 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; + seq_printf(p, "%-25s %lu.%lu secs.usecs\n", + "snapshot_time", now.tv_sec, now.tv_usec); } 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 "LPD64" 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, " "LPD64" "LPD64" "LPD64, + 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, " "LPD64, ctr.lc_sumsquare); } - rc = seq_printf(p, "\n"); -out: - return (rc < 0) ? rc : 0; + seq_putc(p, '\n'); + return 0; } static const struct seq_operations lprocfs_stats_seq_sops = { @@ -1478,10 +1310,10 @@ 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; @@ -1564,12 +1396,10 @@ EXPORT_SYMBOL(lprocfs_counter_init); 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, get_root); 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); @@ -1585,20 +1415,16 @@ void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats) 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); int lprocfs_alloc_md_stats(struct obd_device *obd, unsigned int num_private_stats) @@ -1727,56 +1553,6 @@ __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) -{ - 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; - - if (pbuf < end) { - for (i = 0; i < (end - pbuf); i++) - pow *= 10; - - *val += temp_val / pow; - } - } - return 0; -} -EXPORT_SYMBOL(lprocfs_write_frac_helper); - int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val, int mult) { @@ -1830,7 +1606,6 @@ int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val, buffer[prtn++] ='\n'; return prtn; } -EXPORT_SYMBOL(lprocfs_read_frac_helper); int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult) { @@ -1857,77 +1632,309 @@ 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; + if (rc) + return rc; - kernbuf[count] = '\0'; - pbuf = kernbuf; - if (*pbuf == '-') { - mult = -mult; - pbuf++; - } + if (mult == 0) { + *val = 0; + return 0; + } - whole = simple_strtoull(pbuf, &end, 10); - if (pbuf == end) - return -EINVAL; + /* the multiplier limits how large the value can be */ + wrap_indicator /= mult; - if (end != NULL && *end == '.') { - int i; - pbuf = end + 1; + if (strwhole) { + rc = kstrtoull(strwhole, base, &whole); + if (rc) + return rc; - /* need to limit frac_d to a __u32 */ - if (strlen(pbuf) > 10) - pbuf[10] = '\0'; + if (whole > wrap_indicator) + return -ERANGE; - frac = simple_strtoull(pbuf, &end, 10); - /* count decimal places */ - for (i = 0; i < (end - pbuf); i++) - frac_d *= 10; - } + whole *= mult; + } - 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 (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); } - /* 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; + /* check that the sum of whole and fraction fits in u64 */ + if (whole > (ULLONG_MAX - frac)) + return -ERANGE; + + *val = whole + frac; + + return 0; } -EXPORT_SYMBOL(lprocfs_write_frac_u64_helper); + +/* + * 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++; + } + + 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; +} + +/** + * Convert a user string into a signed 64 bit number. This function produces + * an error when the value parsed from the string underflows or + * overflows. This function accepts strings which contain digits and + * optionally a decimal or hex strings which are prefixed with "0x". + * + * \param[in] buffer string consisting of numbers and optionally a decimal + * \param[in] count buffer length + * \param[in] val if successful, the value represented by the string + * + * \retval 0 on success + * \retval negative number on error + */ +int lprocfs_str_to_s64(const char __user *buffer, unsigned long count, + __s64 *val) +{ + return str_to_s64_internal(buffer, count, val, 1, false); +} +EXPORT_SYMBOL(lprocfs_str_to_s64); + +/** + * 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; + int rc; + + 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); static char *lprocfs_strnstr(const char *s1, const char *s2, size_t len) { @@ -2061,18 +2068,16 @@ int lprocfs_obd_rd_max_pages_per_rpc(char *page, char **start, off_t off, return rc; } -EXPORT_SYMBOL(lprocfs_obd_rd_max_pages_per_rpc); 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; - int rc; spin_lock(&cli->cl_loi_list_lock); - rc = seq_printf(m, "%d\n", cli->cl_max_pages_per_rpc); + seq_printf(m, "%d\n", cli->cl_max_pages_per_rpc); spin_unlock(&cli->cl_loi_list_lock); - return rc; + return 0; } EXPORT_SYMBOL(lprocfs_obd_max_pages_per_rpc_seq_show); @@ -2145,6 +2150,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) { @@ -2164,9 +2170,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)) @@ -2208,4 +2215,4 @@ failed: } EXPORT_SYMBOL(lprocfs_wr_nosquash_nids); -#endif /* LPROCFS*/ +#endif /* CONFIG_PROC_FS*/