X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=7b8aff959006d936afe3bcf0e963fbc13b514188;hp=1f064ff2d806b163541a70096b52e4839315e349;hb=f07508d17b49574c7ea47a855c6e8af2b23c3add;hpb=b90812a674f6ebaa9de592a4a4d97a35ed38a24e diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index 1f064ff..7b8aff9 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -49,13 +49,13 @@ MODULE_PARM_DESC(lprocfs_no_percpu_stats, "Do not alloc percpu data for lprocfs 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); @@ -89,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; @@ -102,35 +102,36 @@ 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); @@ -180,10 +181,10 @@ int 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; @@ -198,7 +199,7 @@ lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_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++; } @@ -206,13 +207,6 @@ lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, } EXPORT_SYMBOL(lprocfs_add_vars); -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); @@ -226,36 +220,38 @@ static 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); + parent = root->parent; + LASSERT(parent != NULL); - while (1) { - while (temp->subdir != NULL) - temp = temp->subdir; + while (1) { + while (temp->subdir) + temp = temp->subdir; - rm_entry = temp; - temp = temp->parent; + rm_entry = temp; + temp = temp->parent; - /* 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)); + /* + * 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)); - remove_proc_entry(rm_entry->name, temp); - if (temp == parent) - break; - } + remove_proc_entry(rm_entry->name, temp); + if (temp == parent) + break; + } } 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); @@ -354,10 +350,10 @@ lprocfs_register(const char *name, struct proc_dir_entry *parent, struct proc_dir_entry *newchild; newchild = proc_mkdir(name, parent); - if (newchild == NULL) + if (!newchild) return ERR_PTR(-ENOMEM); - if (list != NULL) { + if (list) { int rc = lprocfs_add_vars(newchild, list, data); if (rc) { lprocfs_remove(&newchild); @@ -389,16 +385,6 @@ static ssize_t uuid_show(struct kobject *kobj, struct attribute *attr, } LUSTRE_RO_ATTR(uuid); -int lprocfs_name_seq_show(struct seq_file *m, void *data) -{ - struct obd_device *dev = data; - - LASSERT(dev != NULL); - seq_printf(m, "%s\n", dev->obd_name); - return 0; -} -EXPORT_SYMBOL(lprocfs_name_seq_show); - static ssize_t blocksize_show(struct kobject *kobj, struct attribute *attr, char *buf) { @@ -432,9 +418,7 @@ static ssize_t kbytestotal_show(struct kobject *kobj, struct attribute *attr, u32 blk_size = osfs.os_bsize >> 10; u64 result = osfs.os_blocks; - while (blk_size >>= 1) - result <<= 1; - + result *= rounddown_pow_of_two(blk_size ?: 1); return sprintf(buf, "%llu\n", result); } @@ -566,26 +550,6 @@ int lprocfs_server_uuid_seq_show(struct seq_file *m, void *data) } EXPORT_SYMBOL(lprocfs_server_uuid_seq_show); -int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data) -{ - struct obd_device *obd = data; - struct ptlrpc_connection *conn; - int rc = 0; - - LASSERT(obd != NULL); - - LPROCFS_CLIMP_CHECK(obd); - conn = obd->u.cli.cl_import->imp_connection; - if (conn && obd->u.cli.cl_import) - seq_printf(m, "%s\n", conn->c_remote_uuid.uuid); - else - seq_printf(m, "%s\n", ""); - - LPROCFS_CLIMP_EXIT(obd); - return rc; -} -EXPORT_SYMBOL(lprocfs_conn_uuid_seq_show); - /** add up per-cpu counters */ /** @@ -679,14 +643,14 @@ void lprocfs_stats_unlock(struct lprocfs_stats *stats, 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; @@ -697,7 +661,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); @@ -803,12 +767,19 @@ static const char *obd_connect_names[] = { "file_secctx", /* 0x01 */ "lockaheadv2", /* 0x02 */ "dir_migrate", /* 0x04 */ - "unknown", /* 0x08 */ - "unknown", /* 0x10 */ + "sum_statfs", /* 0x08 */ + "overstriping", /* 0x10 */ "flr", /* 0x20 */ "wbc", /* 0x40 */ "lock_convert", /* 0x80 */ "archive_id_array", /* 0x100 */ + "increasing_xid", /* 0x200 */ + "selinux_policy", /* 0x400 */ + "lsom", /* 0x800 */ + "pcc", /* 0x1000 */ + "crush", /* 0x2000 */ + "async_discard", /* 0x4000 */ + "client_encryption", /* 0x8000 */ NULL }; @@ -944,16 +915,16 @@ obd_connect_data_seqprint(struct seq_file *m, struct obd_connect_data *ocd) 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; - 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); @@ -987,7 +958,7 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) seq_printf(m, "%s%s", j ? ", " : "", nidstr); j++; } - if (imp->imp_connection != NULL) + if (imp->imp_connection) libcfs_nid2str_r(imp->imp_connection->c_peer.nid, nidstr, sizeof(nidstr)); else @@ -1005,17 +976,14 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) 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]; lprocfs_stats_collect(obd->obd_svc_stats, PTLRPC_REQWAIT_CNTR, &ret); - if (ret.lc_count != 0) { - /* first argument to do_div MUST be __u64 */ - __u64 sum = ret.lc_sum; - do_div(sum, ret.lc_count); - ret.lc_sum = sum; - } else + if (ret.lc_count != 0) + ret.lc_sum = div64_s64(ret.lc_sum, ret.lc_count); + else ret.lc_sum = 0; seq_printf(m, " rpcs:\n" " inflight: %u\n" @@ -1054,10 +1022,7 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) PTLRPC_LAST_CNTR + BRW_READ_BYTES + rw, &ret); if (ret.lc_sum > 0 && ret.lc_count > 0) { - /* first argument to do_div MUST be __u64 */ - __u64 sum = ret.lc_sum; - do_div(sum, ret.lc_count); - ret.lc_sum = sum; + ret.lc_sum = div64_s64(ret.lc_sum, ret.lc_count); seq_printf(m, " %s_data_averages:\n" " bytes_per_rpc: %llu\n", rw ? "write" : "read", @@ -1068,10 +1033,7 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) header = &obd->obd_svc_stats->ls_cnt_header[j]; lprocfs_stats_collect(obd->obd_svc_stats, j, &ret); if (ret.lc_sum > 0 && ret.lc_count != 0) { - /* first argument to do_div MUST be __u64 */ - __u64 sum = ret.lc_sum; - do_div(sum, ret.lc_count); - ret.lc_sum = sum; + ret.lc_sum = div64_s64(ret.lc_sum, ret.lc_count); seq_printf(m, " %s_per_rpc: %llu\n", header->lc_units, ret.lc_sum); j = (int)ret.lc_sum; @@ -1226,7 +1188,7 @@ int lprocfs_obd_setup(struct obd_device *obd, bool uuid_only) 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.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); @@ -1273,7 +1235,9 @@ int lprocfs_obd_setup(struct obd_device *obd, bool uuid_only) CERROR("error %d setting up lprocfs for %s\n",rc,obd->obd_name); obd->obd_proc_entry = NULL; - ldebugfs_remove(&obd->obd_debugfs_entry); + debugfs_remove_recursive(obd->obd_debugfs_entry); + obd->obd_debugfs_entry = NULL; + sysfs_remove_files(&obd->obd_kset.kobj, obd->obd_attrs); obd->obd_attrs = NULL; kset_unregister(&obd->obd_kset); @@ -1300,8 +1264,8 @@ int lprocfs_obd_cleanup(struct obd_device *obd) obd->obd_proc_entry = NULL; } - if (!IS_ERR_OR_NULL(obd->obd_debugfs_entry)) - ldebugfs_remove(&obd->obd_debugfs_entry); + debugfs_remove_recursive(obd->obd_debugfs_entry); + obd->obd_debugfs_entry = NULL; /* obd device never allocated a kset */ if (!obd->obd_kset.kobj.state_initialized) @@ -1320,18 +1284,18 @@ 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) @@ -1358,16 +1322,16 @@ int lprocfs_stats_alloc_one(struct lprocfs_stats *stats, unsigned int cpuid) 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; @@ -1376,7 +1340,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; @@ -1386,14 +1350,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) { @@ -1418,9 +1382,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; @@ -1429,9 +1393,9 @@ 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])); @@ -1466,16 +1430,16 @@ 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); @@ -1497,12 +1461,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) @@ -1526,10 +1490,10 @@ 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; + struct lprocfs_stats *stats = p->private; + struct lprocfs_counter_header *hdr; + struct lprocfs_counter ctr; + int idx = *(loff_t *)v; if (idx == 0) { struct timespec64 now; @@ -1583,12 +1547,12 @@ static int lprocfs_stats_seq_open(struct inode *inode, struct file *file) } 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, + .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, @@ -1615,7 +1579,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; } @@ -1624,11 +1588,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); @@ -1642,7 +1606,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; @@ -1682,7 +1646,8 @@ int lprocfs_alloc_md_stats(struct obd_device *obd, unsigned int num_stats; int rc, i; - /* 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 @@ -1722,7 +1687,7 @@ 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; lprocfs_free_stats(&stats); } @@ -1731,24 +1696,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); @@ -1759,7 +1724,7 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc, { __s64 ret = 0; - if (lc == NULL || header == NULL) + if (!lc || !header) RETURN(0); switch (field) { @@ -1793,85 +1758,184 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc, } EXPORT_SYMBOL(lprocfs_read_helper); -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; -} -EXPORT_SYMBOL(lprocfs_read_frac_helper); - -int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult) -{ - long decimal_val, frac_val; - - decimal_val = val / mult; - seq_printf(m, "%ld", decimal_val); - frac_val = val % mult; - - if (frac_val > 0) { - frac_val *= 100; - frac_val /= mult; - } - if (frac_val > 0) { - /* Three cases: x0, xx, 0x */ - if ((frac_val % 10) != 0) - seq_printf(m, ".%ld", frac_val); - else - seq_printf(m, ".%ld", frac_val / 10); +/** + * string_to_size - convert ASCII string representing a numerical + * value with optional units to 64-bit binary value + * + * @size: The numerical value extract out of @buffer + * @buffer: passed in string to parse + * @count: length of the @buffer + * + * This function returns a 64-bit binary value if @buffer contains a valid + * numerical string. The string is parsed to 3 significant figures after + * the decimal point. Support the string containing an optional units at + * the end which can be base 2 or base 10 in value. If no units are given + * the string is assumed to just a numerical value. + * + * Returns: @count if the string is successfully parsed, + * -errno on invalid input strings. Error values: + * + * - ``-EINVAL``: @buffer is not a proper numerical string + * - ``-EOVERFLOW``: results does not fit into 64 bits. + * - ``-E2BIG ``: @buffer is not large + */ +int string_to_size(u64 *size, const char *buffer, size_t count) +{ + /* For string_get_size() it can support values above exabytes, + * (ZiB, YiB) due to breaking the return value into a size and + * bulk size to avoid 64 bit overflow. We don't break the size + * up into block size units so we don't support ZiB or YiB. + */ + static const char *const units_10[] = { + "kB", "MB", "GB", "TB", "PB", "EB" + }; + static const char *const units_2[] = { + "KiB", "MiB", "GiB", "TiB", "PiB", "EiB" + }; + static const char *const *const units_str[] = { + [STRING_UNITS_2] = units_2, + [STRING_UNITS_10] = units_10, + }; + static const unsigned int coeff[] = { + [STRING_UNITS_10] = 1000, + [STRING_UNITS_2] = 1024, + }; + enum string_size_units unit; + u64 whole, blk_size = 1; + char kernbuf[22], *end; + size_t len = count; + int rc; + int i; + + if (count >= sizeof(kernbuf)) + return -E2BIG; + + *size = 0; + /* 'iB' is used for based 2 numbers. If @buffer contains only a 'B' + * or only numbers then we treat it as a direct number which doesn't + * matter if its STRING_UNITS_2 or STRING_UNIT_10. + */ + unit = strstr(buffer, "iB") ? STRING_UNITS_2 : STRING_UNITS_10; + i = unit == STRING_UNITS_2 ? ARRAY_SIZE(units_2) - 1 : + ARRAY_SIZE(units_10) - 1; + do { + end = strstr(buffer, units_str[unit][i]); + if (end) { + for (; i >= 0; i--) + blk_size *= coeff[unit]; + len -= strlen(end); + break; + } + } while (i--); + + /* as 'B' is a substring of all units, we need to handle it + * separately. + */ + if (!end) { + /* 'B' is only acceptable letter at this point */ + end = strchr(buffer, 'B'); + if (end) { + len -= strlen(end); + + if (count - len > 2 || + (count - len == 2 && strcmp(end, "B\n") != 0)) + return -EINVAL; + } + /* kstrtoull will error out if it has non digits */ + goto numbers_only; } - seq_printf(m, "\n"); - return 0; + end = strchr(buffer, '.'); + if (end) { + /* need to limit 3 decimal places */ + char rem[4] = "000"; + u64 frac = 0; + size_t off; + + len = end - buffer; + end++; + + /* limit to 3 decimal points */ + off = min_t(size_t, 3, strspn(end, "0123456789")); + /* need to limit frac_d to a u32 */ + memcpy(rem, end, off); + rc = kstrtoull(rem, 10, &frac); + if (rc) + return rc; + + if (fls64(frac) + fls64(blk_size) - 1 > 64) + return -EOVERFLOW; + + frac *= blk_size; + do_div(frac, 1000); + *size += frac; + } +numbers_only: + snprintf(kernbuf, sizeof(kernbuf), "%.*s", (int)len, buffer); + rc = kstrtoull(kernbuf, 10, &whole); + if (rc) + return rc; + + if (whole != 0 && fls64(whole) + fls64(blk_size) - 1 > 64) + return -EOVERFLOW; + + *size += whole * blk_size; + + return count; } -EXPORT_SYMBOL(lprocfs_seq_read_frac_helper); +EXPORT_SYMBOL(string_to_size); + +/** + * sysfs_memparse - parse a ASCII string to 64-bit binary value, + * with optional units + * + * @buffer: kernel pointer to input string + * @count: number of bytes in the input @buffer + * @val: (output) binary value returned to caller + * @defunit: default unit suffix to use if none is provided + * + * Parses a string into a number. The number stored at @buffer is + * potentially suffixed with K, M, G, T, P, E. Besides these other + * valid suffix units are shown in the string_to_size() function. + * If the string lacks a suffix then the defunit is used. The defunit + * should be given as a binary unit (e.g. MiB) as that is the standard + * for tunables in Lustre. If no unit suffix is given (e.g. 'G'), then + * it is assumed to be in binary units. + * + * Returns: 0 on success or -errno on failure. + */ +int sysfs_memparse(const char *buffer, size_t count, u64 *val, + const char *defunit) +{ + char param[23]; + int rc; + + if (count >= sizeof(param)) + return -E2BIG; + + count = strlen(buffer); + if (count && buffer[count - 1] == '\n') + count--; + + if (!count) + return -EINVAL; + + if (isalpha(buffer[count - 1])) { + if (buffer[count - 1] != 'B') { + scnprintf(param, sizeof(param), "%.*siB", + (int)count, buffer); + } else { + memcpy(param, buffer, sizeof(param)); + } + } else { + scnprintf(param, sizeof(param), "%.*s%s", (int)count, + buffer, defunit); + } + + rc = string_to_size(val, param, strlen(param)); + return rc < 0 ? rc : 0; +} +EXPORT_SYMBOL(sysfs_memparse); /* Obtains the conversion factor for the unit specified */ static int get_mult(char unit, __u64 *mult) @@ -1883,15 +1947,19 @@ static int get_mult(char unit, __u64 *mult) case 'p': case 'P': units <<= 10; + /* fallthrough */ case 't': case 'T': units <<= 10; + /* fallthrough */ case 'g': case 'G': units <<= 10; + /* fallthrough */ case 'm': case 'M': units <<= 10; + /* fallthrough */ case 'k': case 'K': units <<= 10; @@ -2086,34 +2154,31 @@ static int str_to_u64_parse(char *buffer, unsigned long count, * 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) +int lu_str_to_s64(char *buffer, unsigned long count, __s64 *val, char defunit) { - char kernbuf[22]; + __u64 mult = 1; __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'; + if (defunit != '1') { + rc = get_mult(defunit, &mult); + if (rc) + return rc; + } /* keep track of our sign */ - if (*kernbuf == '-') { + if (*buffer == '-') { 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); + rc = str_to_u64_parse(buffer + offset, count - offset, + &tmp, mult, true); if (rc) return rc; @@ -2125,7 +2190,31 @@ static int str_to_s64_internal(const char __user *buffer, unsigned long count, return 0; } +EXPORT_SYMBOL(lu_str_to_s64); + +/* identical to s64 version, but does not handle overflow */ +static int str_to_u64_internal(const char __user *buffer, unsigned long count, + __u64 *val, __u64 def_mult, bool allow_units) +{ + char kernbuf[22]; + unsigned int offset = 0; + int rc = 0; + + if (count > (sizeof(kernbuf) - 1)) + return -EINVAL; + + if (copy_from_user(kernbuf, buffer, count)) + return -EFAULT; + + kernbuf[count] = '\0'; + rc = str_to_u64_parse(kernbuf + offset, count - offset, + val, def_mult, allow_units); + if (rc) + return rc; + + return 0; +} /** * 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 @@ -2146,6 +2235,24 @@ static int str_to_s64_internal(const char __user *buffer, unsigned long count, int lprocfs_str_with_units_to_s64(const char __user *buffer, unsigned long count, __s64 *val, char defunit) { + char kernbuf[22]; + + if (count > (sizeof(kernbuf) - 1)) + return -EINVAL; + + if (copy_from_user(kernbuf, buffer, count)) + return -EFAULT; + + kernbuf[count] = '\0'; + + return lu_str_to_s64(kernbuf, count, val, defunit); +} +EXPORT_SYMBOL(lprocfs_str_with_units_to_s64); + +/* identical to s64 version above, but does not handle overflow */ +int lprocfs_str_with_units_to_u64(const char __user *buffer, + unsigned long count, __u64 *val, char defunit) +{ __u64 mult = 1; int rc; @@ -2155,9 +2262,9 @@ int lprocfs_str_with_units_to_s64(const char __user *buffer, return rc; } - return str_to_s64_internal(buffer, count, val, mult, true); + return str_to_u64_internal(buffer, count, val, mult, true); } -EXPORT_SYMBOL(lprocfs_str_with_units_to_s64); +EXPORT_SYMBOL(lprocfs_str_with_units_to_u64); char *lprocfs_strnstr(const char *s1, const char *s2, size_t len) { @@ -2189,7 +2296,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 */ @@ -2236,7 +2343,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); @@ -2278,12 +2385,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); @@ -2335,8 +2442,8 @@ 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 seq_file *m = file->private_data; + struct obd_device *dev = m->private; struct client_obd *cli = &dev->u.cli; struct obd_connect_data *ocd = &cli->cl_import->imp_connect_data; int chunk_mask, rc; @@ -2388,7 +2495,7 @@ ssize_t short_io_bytes_show(struct kobject *kobj, struct attribute *attr, EXPORT_SYMBOL(short_io_bytes_show); /* Used to catch people who think they're specifying pages. */ -#define MIN_SHORT_IO_BYTES 64 +#define MIN_SHORT_IO_BYTES 64U ssize_t short_io_bytes_store(struct kobject *kobj, struct attribute *attr, const char *buffer, size_t count) @@ -2396,25 +2503,31 @@ ssize_t short_io_bytes_store(struct kobject *kobj, struct attribute *attr, struct obd_device *dev = container_of(kobj, struct obd_device, obd_kset.kobj); struct client_obd *cli = &dev->u.cli; - u32 val; + char kernbuf[32]; + s64 val; int rc; + if (count >= sizeof(kernbuf)) + return -EINVAL; + LPROCFS_CLIMP_CHECK(dev); - rc = kstrtouint(buffer, 0, &val); + memcpy(kernbuf, buffer, count); + kernbuf[count] = '\0'; + rc = lu_str_to_s64(kernbuf, count, &val, '1'); if (rc) GOTO(out, rc); - if (val && (val < MIN_SHORT_IO_BYTES || val > OBD_MAX_SHORT_IO_BYTES)) + if (val == -1) + val = OBD_DEF_SHORT_IO_BYTES; + + if (val && (val < MIN_SHORT_IO_BYTES || val > LNET_MTU)) 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; + cli->cl_max_short_io_bytes = min_t(u64, val, OST_MAX_SHORT_IO_BYTES); spin_unlock(&cli->cl_loi_list_lock); out: @@ -2443,7 +2556,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); } @@ -2470,7 +2583,7 @@ int lprocfs_wr_root_squash(const char __user *buffer, unsigned long count, RETURN(count); failed: - if (tmp != NULL) { + if (tmp) { tmp--; *tmp = ':'; } @@ -2491,7 +2604,7 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count, int rc; char *kernbuf = NULL; char *errmsg; - struct list_head tmp; + LIST_HEAD(tmp); int len = count; ENTRY; @@ -2501,7 +2614,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); } @@ -2517,16 +2630,15 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count, 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); + spin_lock(&squash->rsi_lock); if (!list_empty(&squash->rsi_nosquash_nids)) cfs_free_nidlist(&squash->rsi_nosquash_nids); - up_write(&squash->rsi_sem); + spin_unlock(&squash->rsi_lock); LCONSOLE_INFO("%s: nosquash_nids is cleared\n", name); OBD_FREE(kernbuf, count + 1); RETURN(count); } - INIT_LIST_HEAD(&tmp); if (cfs_parse_nidlist(kernbuf, count, &tmp) <= 0) { errmsg = "can't parse"; GOTO(failed, rc = -EINVAL); @@ -2536,11 +2648,11 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count, OBD_FREE(kernbuf, count + 1); kernbuf = NULL; - down_write(&squash->rsi_sem); + spin_lock(&squash->rsi_lock); if (!list_empty(&squash->rsi_nosquash_nids)) cfs_free_nidlist(&squash->rsi_nosquash_nids); list_splice(&tmp, &squash->rsi_nosquash_nids); - up_write(&squash->rsi_sem); + spin_unlock(&squash->rsi_lock); RETURN(count);