}
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);
"selinux_policy", /* 0x400 */
"lsom", /* 0x800 */
"pcc", /* 0x1000 */
- "plain_layout", /* 0x2000 */
+ "crush", /* 0x2000 */
"async_discard", /* 0x4000 */
+ "client_encryption", /* 0x8000 */
NULL
};
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"
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",
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;
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);
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)
}
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)
{
* 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;
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,
int lprocfs_str_with_units_to_s64(const char __user *buffer,
unsigned long count, __s64 *val, char defunit)
{
- __u64 mult = 1;
- int rc;
+ char kernbuf[22];
- if (defunit != '1') {
- rc = get_mult(defunit, &mult);
- if (rc)
- return rc;
- }
+ if (count > (sizeof(kernbuf) - 1))
+ return -EINVAL;
+
+ if (copy_from_user(kernbuf, buffer, count))
+ return -EFAULT;
+
+ kernbuf[count] = '\0';
- return str_to_s64_internal(buffer, count, val, mult, true);
+ return lu_str_to_s64(kernbuf, count, val, defunit);
}
EXPORT_SYMBOL(lprocfs_str_with_units_to_s64);
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;
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:
int rc;
char *kernbuf = NULL;
char *errmsg;
- struct list_head tmp;
+ LIST_HEAD(tmp);
int len = count;
ENTRY;
RETURN(count);
}
- INIT_LIST_HEAD(&tmp);
if (cfs_parse_nidlist(kernbuf, count, &tmp) <= 0) {
errmsg = "can't parse";
GOTO(failed, rc = -EINVAL);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff