X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=7b8aff959006d936afe3bcf0e963fbc13b514188;hp=87d2af899f0cb3e1b10c18f2f73b267e9c2ad645;hb=f07508d17b49574c7ea47a855c6e8af2b23c3add;hpb=9c028e74c2202a8a481557c4cb22225734aaf19f diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index 87d2af8..7b8aff9 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -207,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); @@ -425,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); } @@ -782,12 +773,13 @@ static const char *obd_connect_names[] = { "wbc", /* 0x40 */ "lock_convert", /* 0x80 */ "archive_id_array", /* 0x100 */ - "unknown", /* 0x200 */ + "increasing_xid", /* 0x200 */ "selinux_policy", /* 0x400 */ "lsom", /* 0x800 */ "pcc", /* 0x1000 */ - "plain_layout", /* 0x2000 */ + "crush", /* 0x2000 */ "async_discard", /* 0x4000 */ + "client_encryption", /* 0x8000 */ NULL }; @@ -989,12 +981,9 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data) 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" @@ -1033,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", @@ -1047,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; @@ -1252,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); @@ -1279,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) @@ -1773,6 +1758,185 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc, } EXPORT_SYMBOL(lprocfs_read_helper); +/** + * 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; + } + + 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(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) { @@ -1783,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; @@ -1986,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; @@ -2025,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 @@ -2046,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; @@ -2055,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) { @@ -2235,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; @@ -2296,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: @@ -2391,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; @@ -2417,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); @@ -2436,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);