LPLX||%#lx
LPPID||%d
LPROCFS||CONFIG_PROC_FS
+lprocfs_str_to_s64||kstrtoxxx_from_user
mktemp||mkstemp
sprintf||snprintf
strcpy||strncpy
]) # LIBCFS_FPU_API
#
+# Kernel version 4.4 commit ef951599074ba4fad2d0efa0a977129b41e6d203
+# introduced kstrtobool and kstrtobool_from_user.
+#
+AC_DEFUN([LIBCFS_KSTRTOBOOL_FROM_USER], [
+LB_CHECK_COMPILE([if Linux kernel has 'kstrtobool_from_user'],
+kstrtobool_from_user, [
+ #include <linux/kernel.h>
+],[
+ bool result;
+ return kstrtobool_from_user(NULL, 0, &result);
+],[
+ AC_DEFINE(HAVE_KSTRTOBOOL_FROM_USER, 1,
+ [kernel has kstrtobool_from_user])
+])
+]) # LIBCFS_KSTRTOBOOL_FROM_USER
+
+#
# Kernel version 4.5-rc1 commit d12481bc58fba89427565f8592e88446ec084a24
# added crypto hash helpers
#
# 4.2
LIBCFS_HAVE_TOPOLOGY_SIBLING_CPUMASK
LIBCFS_FPU_API
+# 4.4
+LIBCFS_KSTRTOBOOL_FROM_USER
# 4.5
LIBCFS_CRYPTO_HASH_HELPERS
LIBCFS_EXPORT_KSET_FIND_OBJ
}
#endif /* !HAVE_KSTRTOUL */
+#ifndef HAVE_KSTRTOBOOL_FROM_USER
+
+#define kstrtobool strtobool
+
+int kstrtobool_from_user(const char __user *s, size_t count, bool *res);
+#endif
#endif
EXPORT_SYMBOL_GPL(kset_find_obj);
#endif
+#ifndef HAVE_KSTRTOBOOL_FROM_USER
+int kstrtobool_from_user(const char __user *s, size_t count, bool *res)
+{
+ /* Longest string needed to differentiate, newline, terminator */
+ char buf[4];
+
+ count = min(count, sizeof(buf) - 1);
+ if (copy_from_user(buf, s, count))
+ return -EFAULT;
+ buf[count] = '\0';
+ return strtobool(buf, res);
+}
+EXPORT_SYMBOL(kstrtobool_from_user);
+#endif /* !HAVE_KSTRTOBOOL_FROM_USER */
+
sigset_t
cfs_block_allsigs(void)
{
lprocfs_server_fid_width_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
- struct lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
+ struct seq_file *m = file->private_data;
+ struct lu_server_seq *seq = m->private;
int rc;
- __s64 val;
ENTRY;
LASSERT(seq != NULL);
mutex_lock(&seq->lss_mutex);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoull_from_user(buffer, count, 0, &seq->lss_width);
if (rc) {
CERROR("%s: invalid FID sequence width: rc = %d\n",
seq->lss_name, rc);
GOTO(out_unlock, count = rc);
}
- if (val < 0) {
- CERROR("%s: invalid FID sequence width: rc = %d\n",
- seq->lss_name, -ERANGE);
- GOTO(out_unlock, count = -ERANGE);
- }
-
- seq->lss_width = val;
-
CDEBUG(D_INFO, "%s: Width: %llu\n",
seq->lss_name, seq->lss_width);
out_unlock:
lprocfs_client_fid_width_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
- struct lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
- __u64 max;
+ struct seq_file *m = file->private_data;
+ struct lu_client_seq *seq = m->private;
+ u64 val;
+ u64 max;
int rc;
- __s64 val;
- ENTRY;
+ ENTRY;
LASSERT(seq != NULL);
mutex_lock(&seq->lcs_mutex);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoull_from_user(buffer, count, 0, &val);
if (rc) {
GOTO(out_unlock, count = rc);
}
else
max = LUSTRE_METADATA_SEQ_MAX_WIDTH;
- if (val <= max && val > 0) {
+ if (val <= max) {
seq->lcs_width = val;
CDEBUG(D_INFO, "%s: Sequence size: %llu\n",
void *data);
/* Generic callbacks */
-extern int lprocfs_u64_seq_show(struct seq_file *m, void *data);
-extern int lprocfs_atomic_seq_show(struct seq_file *m, void *data);
-extern ssize_t lprocfs_atomic_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off);
-extern int lprocfs_uint_seq_show(struct seq_file *m, void *data);
-extern ssize_t lprocfs_uint_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off);
-extern int lprocfs_wr_uint(struct file *file, const char __user *buffer,
- unsigned long count, void *data);
extern int lprocfs_uuid_seq_show(struct seq_file *m, void *data);
extern int lprocfs_name_seq_show(struct seq_file *m, void *data);
extern int lprocfs_server_uuid_seq_show(struct seq_file *m, void *data);
extern int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult);
extern int lprocfs_read_frac_helper(char *buffer, unsigned long count,
long val, int mult);
-extern int lprocfs_str_to_s64(const char __user *buffer, unsigned long count,
- __s64 *val);
extern int lprocfs_str_with_units_to_s64(const char __user *buffer,
unsigned long count, __s64 *val,
char defunit);
int lfsck_get_speed(struct seq_file *m, struct dt_device *key);
int lfsck_set_speed(struct dt_device *key, __u32 val);
int lfsck_get_windows(struct seq_file *m, struct dt_device *key);
-int lfsck_set_windows(struct dt_device *key, int val);
+int lfsck_set_windows(struct dt_device *key, unsigned int val);
int lfsck_dump(struct seq_file *m, struct dt_device *key, enum lfsck_type type);
}
LPROC_SEQ_FOPS_WR_ONLY(ldlm, dump_ns);
-LPROC_SEQ_FOPS_RW_TYPE(ldlm_rw, uint);
+static int ldlm_rw_uint_seq_show(struct seq_file *m, void *v)
+{
+ seq_printf(m, "%u\n", *(unsigned int *)m->private);
+ return 0;
+}
+
+static ssize_t
+ldlm_rw_uint_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
+{
+ struct seq_file *seq = file->private_data;
+
+ if (!count)
+ return 0;
+
+ return kstrtouint_from_user(buffer, count, 0,
+ (unsigned int *)seq->private);
+}
+
+LPROC_SEQ_FOPS(ldlm_rw_uint);
#ifdef HAVE_SERVER_SUPPORT
}
EXPORT_SYMBOL(lfsck_get_windows);
-int lfsck_set_windows(struct dt_device *key, int val)
+int lfsck_set_windows(struct dt_device *key, unsigned int val)
{
struct lu_env env;
struct lfsck_instance *lfsck;
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
- __s64 val;
+ unsigned int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
- __s64 val;
+ bool val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val != 0 && val != 1)
- return -ERANGE;
-
- if (val == 1 && !(sbi->ll_flags & LL_SBI_XATTR_CACHE))
+ if (val && !(sbi->ll_flags & LL_SBI_XATTR_CACHE))
return -ENOTSUPP;
sbi->ll_xattr_cache_enabled = val;
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
+ bool val;
+ int tmp;
int rc;
- __s64 val;
if (!sbi->ll_dt_exp)
/* Not set up yet */
return -EAGAIN;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
if (val)
sbi->ll_flags |= LL_SBI_CHECKSUM;
else
sbi->ll_flags &= ~LL_SBI_CHECKSUM;
+ tmp = val;
rc = obd_set_info_async(NULL, sbi->ll_dt_exp, sizeof(KEY_CHECKSUM),
- KEY_CHECKSUM, sizeof(val), &val, NULL);
+ KEY_CHECKSUM, sizeof(tmp), &tmp, NULL);
if (rc)
CWARN("Failed to set OSC checksum flags: %d\n", rc);
void *data, enum stats_track_type type)
{
struct super_block *sb = data;
+ unsigned int pid;
int rc;
- __s64 pid;
- rc = lprocfs_str_to_s64(buffer, count, &pid);
+ rc = kstrtouint_from_user(buffer, count, 0, &pid);
if (rc)
return rc;
- if (pid > INT_MAX || pid < 0)
- return -ERANGE;
ll_s2sbi(sb)->ll_stats_track_id = pid;
if (pid == 0)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
+ unsigned int val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val >= 0 && val <= LL_SA_RPC_MAX)
+ if (val <= LL_SA_RPC_MAX)
sbi->ll_sa_max = val;
else
- CERROR("Bad statahead_max value %lld. Valid values are in "
+ CERROR("Bad statahead_max value %u. Valid values are in "
"the range [0, %d]\n", val, LL_SA_RPC_MAX);
return count;
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
struct seq_file *seq = file->private_data;
struct super_block *sb = (struct super_block *)seq->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
- __s64 val;
+ unsigned int val;
int rc;
if (count == 0)
return 0;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
rc = ll_set_default_mdsize(sbi, val);
if (rc)
struct seq_file *m = file->private_data;
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
spin_lock(&sbi->ll_lock);
- if (val == 1)
+ if (val)
sbi->ll_flags |= LL_SBI_FAST_READ;
else
sbi->ll_flags &= ~LL_SBI_FAST_READ;
struct seq_file *m = file->private_data;
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
spin_lock(&sbi->ll_lock);
- if (val == 1)
+ if (val)
sbi->ll_flags |= LL_SBI_PIO;
else
sbi->ll_flags &= ~LL_SBI_PIO;
struct seq_file *seq = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)seq->private);
char kernbuf[128];
+ bool val;
int rc;
- __s64 val;
if (count == 0)
return 0;
buffer += lprocfs_find_named_value(kernbuf, "unstable_check:", &count) -
kernbuf;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc < 0)
return rc;
/* borrow lru lock to set the value */
spin_lock(&sbi->ll_cache->ccc_lru_lock);
- sbi->ll_cache->ccc_unstable_check = !!val;
+ sbi->ll_cache->ccc_unstable_check = val;
spin_unlock(&sbi->ll_cache->ccc_lru_lock);
return count;
*/
static __s64 ll_stats_pid_write(const char __user *buf, size_t len)
{
- __s64 value = 1;
+ unsigned long long value = 1;
int rc;
char kernbuf[16];
- rc = lprocfs_str_to_s64(buf, len, &value);
-
+ rc = kstrtoull_from_user(buf, len, 0, &value);
if (rc < 0 && len < sizeof(kernbuf)) {
if (copy_from_user(kernbuf, buf, len))
struct lod_device *lod;
LASSERT(dev != NULL);
- lod = lu2lod_dev(dev->obd_lu_dev);
+ lod = lu2lod_dev(dev->obd_lu_dev);
seq_printf(m, "%u\n", lod->lod_dom_max_stripesize);
return 0;
}
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct lod_device *lod;
- __s64 val;
+ s64 val;
int rc;
LASSERT(dev != NULL);
- lod = lu2lod_dev(dev->obd_lu_dev);
+ lod = lu2lod_dev(dev->obd_lu_dev);
rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1');
if (rc)
return rc;
if (val < 0)
return -ERANGE;
- /* */
+ /* 1GB is the limit */
if (val > (1ULL << 30))
return -ERANGE;
else if (val > 0)
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct lod_device *lod;
- __s64 val;
+ s64 val;
int rc;
LASSERT(dev != NULL);
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct lod_device *lod;
- __s64 val;
+ long val;
int rc;
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtol_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < -1)
+ if (val < -1 || val > LOV_MAX_STRIPE_COUNT)
return -ERANGE;
lod->lod_desc.ld_default_stripe_offset = val;
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct lod_device *lod;
+ u32 pattern;
int rc;
- __u32 pattern;
- __s64 val;
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &pattern);
if (rc)
return rc;
- if (val < 0)
- return -ERANGE;
- pattern = val;
lod_fix_desc_pattern(&pattern);
lod->lod_desc.ld_pattern = pattern;
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct lod_device *lod;
+ u32 stripe_count;
int rc;
- __s64 val;
- __u32 stripe_count;
LASSERT(dev != NULL);
- lod = lu2lod_dev(dev->obd_lu_dev);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ lod = lu2lod_dev(dev->obd_lu_dev);
+ rc = kstrtouint_from_user(buffer, count, 0, &stripe_count);
if (rc)
return rc;
- if (val < -1)
- return -ERANGE;
- stripe_count = val;
lod_fix_desc_stripe_count(&stripe_count);
lod->lod_desc.ld_default_stripe_count = stripe_count;
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct lod_device *lod;
+ unsigned int val;
int rc;
- __s64 val;
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > 100)
+ if (val > 100)
return -EINVAL;
lod->lod_qos.lq_prio_free = (val << 8) / 100;
lod->lod_qos.lq_dirty = 1;
char str[32];
unsigned int i;
int rc;
- __s64 val;
+ u32 val;
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
* propogate the value down to OSPs
*/
lustre_cfg_bufs_reset(&bufs, NULL);
- snprintf(str, 32, "%smaxage=%u", PARAM_OSP, (__u32)val);
+ snprintf(str, 32, "%smaxage=%u", PARAM_OSP, val);
lustre_cfg_bufs_set_string(&bufs, 1, str);
OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
if (lcfg == NULL)
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct lod_device *lod;
- __s64 val = 0;
+ bool val = 0;
int rc;
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- lod->lod_lmv_failout = !!val;
+ lod->lod_lmv_failout = val;
return count;
}
{
struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
struct lov_desc *desc;
- __s64 val;
+ s64 val;
int rc;
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1');
if (rc)
return rc;
if (val < 0)
{
struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
struct lov_desc *desc;
- __s64 val;
+ long val;
int rc;
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtol_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < -1)
+ if (val < -1 || val > LOV_MAX_STRIPE_COUNT)
return -ERANGE;
desc->ld_default_stripe_offset = val;
{
struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
struct lov_desc *desc;
- int pattern, rc;
- __s64 val;
+ u32 pattern;
+ int rc;
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &pattern);
if (rc)
return rc;
- if (val < INT_MIN || val > INT_MAX)
- return -ERANGE;
- pattern = val;
lov_fix_desc_pattern(&pattern);
desc->ld_pattern = pattern;
{
struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
struct lov_desc *desc;
+ int stripe_count;
int rc;
- __u32 stripe_count;
- __s64 val;
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &stripe_count);
if (rc)
return rc;
- if (val < -1)
+
+ if (stripe_count < -1)
return -ERANGE;
- stripe_count = val;
lov_fix_desc_stripe_count(&stripe_count);
desc->ld_default_stripe_count = stripe_count;
size_t count, loff_t *off)
{
struct obd_device *dev;
+ bool val;
int rc;
- __s64 val;
dev = ((struct seq_file *)file->private_data)->private;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val < 0 || val > 1)
- return -ERANGE;
/* opposite senses */
if (dev->u.cli.cl_import->imp_deactive == val)
rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val);
else
- CDEBUG(D_CONFIG, "activate %llu: ignoring repeat request\n",
+ CDEBUG(D_CONFIG, "activate %u: ignoring repeat request\n",
val);
return count;
struct seq_file *sfl = file->private_data;
struct obd_device *obd = sfl->private;
struct osc_device *od = obd2osc_dev(obd);
+ time64_t val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoll_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
od->od_contention_time = val;
size_t count, loff_t *off)
{
struct obd_device *dev;
- __s64 val;
+ unsigned int val;
int rc;
dev = ((struct seq_file *)file->private_data)->private;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > UINT_MAX)
- return -ERANGE;
-
rc = obd_set_max_rpcs_in_flight(&dev->u.cli, val);
if (rc)
return rc;
size_t count, loff_t *off)
{
struct obd_device *dev;
- __s64 val;
+ u16 val;
int rc;
dev = ((struct seq_file *)file->private_data)->private;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtou16_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > USHRT_MAX)
- return -ERANGE;
-
rc = obd_set_max_mod_rpcs_in_flight(&dev->u.cli, val);
if (rc)
count = rc;
struct proc_dir_entry *mdd_proc_entry;
struct mdd_changelog mdd_cl;
unsigned int mdd_changelog_gc;
- unsigned int mdd_changelog_max_idle_time;
+ time64_t mdd_changelog_max_idle_time;
unsigned long mdd_changelog_max_idle_indexes;
- unsigned int mdd_changelog_min_gc_interval;
+ time64_t mdd_changelog_min_gc_interval;
unsigned int mdd_changelog_min_free_cat_entries;
- unsigned long mdd_atime_diff;
+ time64_t mdd_atime_diff;
struct mdd_object *mdd_dot_lustre;
struct mdd_dot_lustre_objs mdd_dot_lustre_objs;
unsigned int mdd_sync_permission;
{
struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
- char kernbuf[20], *end;
- unsigned long diff = 0;
-
- if (count > (sizeof(kernbuf) - 1))
- return -EINVAL;
-
- if (copy_from_user(kernbuf, buffer, count))
- return -EFAULT;
-
- kernbuf[count] = '\0';
+ time64_t diff = 0;
+ int rc;
- diff = simple_strtoul(kernbuf, &end, 0);
- if (kernbuf == end)
- return -EINVAL;
+ rc = kstrtoll_from_user(buffer, count, 0, &diff);
+ if (rc)
+ return rc;
mdd->mdd_atime_diff = diff;
return count;
{
struct mdd_device *mdd = m->private;
- seq_printf(m, "%lu\n", mdd->mdd_atime_diff);
+ seq_printf(m, "%lld\n", mdd->mdd_atime_diff);
return 0;
}
LPROC_SEQ_FOPS(mdd_atime_diff);
{
struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
+ bool val;
int rc;
- __s64 val;
LASSERT(mdd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- mdd->mdd_changelog_gc = !!val;
+ mdd->mdd_changelog_gc = val;
return count;
}
struct mdd_device *mdd = m->private;
LASSERT(mdd != NULL);
- seq_printf(m, "%u\n", mdd->mdd_changelog_max_idle_time);
+ seq_printf(m, "%lld\n", mdd->mdd_changelog_max_idle_time);
return 0;
}
{
struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
+ time64_t val;
int rc;
- __s64 val;
LASSERT(mdd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+
+ rc = kstrtoll_from_user(buffer, count, 0, &val);
if (rc)
return rc;
/* XXX may need to limit with reasonable elapsed/idle times */
- if (val < 1 || val > INT_MAX)
+ if (val < 1)
return -ERANGE;
mdd->mdd_changelog_max_idle_time = val;
{
struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
+ unsigned long val;
int rc;
- __s64 val;
LASSERT(mdd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoul_from_user(buffer, count, 0, &val);
if (rc)
return rc;
struct mdd_device *mdd = m->private;
LASSERT(mdd != NULL);
- seq_printf(m, "%u\n", mdd->mdd_changelog_min_gc_interval);
+ seq_printf(m, "%lld\n", mdd->mdd_changelog_min_gc_interval);
return 0;
}
{
struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
+ time64_t val;
int rc;
- __s64 val;
LASSERT(mdd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoll_from_user(buffer, count, 0, &val);
if (rc)
return rc;
/* XXX may need to limit with reasonable elapsed/interval times */
- if (val < 1 || val > UINT_MAX)
+ if (val < 1)
return -ERANGE;
mdd->mdd_changelog_min_gc_interval = val;
{
struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
+ unsigned int val;
int rc;
- __s64 val;
LASSERT(mdd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
/* XXX may need to limit with more reasonable number of free entries */
- if (val < 1 || (__u64)val > UINT_MAX)
+ if (val < 1)
return -ERANGE;
mdd->mdd_changelog_min_free_cat_entries = val;
{
struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
+ bool val;
int rc;
- __s64 val;
LASSERT(mdd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- mdd->mdd_sync_permission = !!val;
+ mdd->mdd_sync_permission = val;
return count;
}
{
struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
- __s64 val;
+ unsigned int val;
int rc;
LASSERT(mdd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc != 0)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
rc = lfsck_set_speed(mdd->mdd_bottom, val);
return rc != 0 ? rc : count;
mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
- struct seq_file *m = file->private_data;
+ struct seq_file *m = file->private_data;
struct mdd_device *mdd = m->private;
- __s64 val;
- int rc;
+ unsigned int val;
+ int rc;
LASSERT(mdd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
rc = lfsck_set_windows(mdd->mdd_bottom, val);
struct seq_file *m = file->private_data; \
struct mdt_device *mdt = m->private; \
struct coordinator *cdt = &mdt->mdt_coordinator; \
- __s64 val; \
- int rc; \
- ENTRY; \
+ unsigned int val; \
+ int rc; \
\
- rc = lprocfs_str_to_s64(buffer, count, &val); \
+ ENTRY; \
+ rc = kstrtouint_from_user(buffer, count, 0, &val); \
if (rc) \
RETURN(rc); \
- if (val > 0 && val < INT_MAX) { \
+ \
+ if (val != 0) { \
cdt->VAR = val; \
RETURN(count); \
} \
struct seq_file *m = file->private_data;
struct mdt_device *mdt = m->private;
struct coordinator *cdt = &mdt->mdt_coordinator;
- __s64 val;
+ bool val;
int rc;
- ENTRY;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ ENTRY;
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc < 0)
RETURN(rc);
* \param mdt mdt device
* \param val 0 disables COS, other values enable COS
*/
-void mdt_enable_cos(struct mdt_device *mdt, int val)
+void mdt_enable_cos(struct mdt_device *mdt, bool val)
{
struct lu_env env;
int rc;
- mdt->mdt_opts.mo_cos = !!val;
+ mdt->mdt_opts.mo_cos = val;
rc = lu_env_init(&env, LCT_LOCAL);
if (unlikely(rc != 0)) {
CWARN("%s: lu_env initialization failed, cannot "
int mdt_dom_lvbo_update(struct ldlm_resource *res, struct ldlm_lock *lock,
struct ptlrpc_request *req, bool increase_only);
-void mdt_enable_cos(struct mdt_device *, int);
+void mdt_enable_cos(struct mdt_device *dev, bool enable);
int mdt_cos_is_enabled(struct mdt_device *);
/* lprocfs stuff */
time64_t val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoll_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > INT_MAX)
+ if (val < 0)
return -ERANGE;
mdt->mdt_identity_cache->uc_entry_expire = val;
time64_t val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoll_from_user(buffer, count, 0, &val);
if (rc)
return rc;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+ int uid;
int rc;
- __s64 uid;
- rc = lprocfs_str_to_s64(buffer, count, &uid);
+ rc = kstrtoint_from_user(buffer, count, 0, &uid);
if (rc)
return rc;
- if (uid < INT_MIN || uid > INT_MAX)
- return -ERANGE;
mdt_flush_identity(mdt->mdt_identity_cache, uid);
return count;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
- __s64 val;
+ bool val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- mdt->mdt_opts.mo_evict_tgt_nids = !!val;
+
+ mdt->mdt_opts.mo_evict_tgt_nids = val;
return count;
}
LPROC_SEQ_FOPS(mdt_evict_tgt_nids);
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val < INT_MIN || val > INT_MAX)
- return -ERANGE;
mdt_enable_cos(mdt, val);
return count;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
- __s64 val;
+ bool val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val > 1 || val < 0)
- return -ERANGE;
-
mdt->mdt_enable_remote_dir = val;
return count;
}
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
- __s64 val;
+ int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
- __s64 val;
+ int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < INT_MIN || val > INT_MAX)
- return -ERANGE;
-
atomic_set(&mdt->mdt_async_commit_count, val);
return count;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct lu_target *tgt = obd->u.obt.obt_lut;
- __s64 val;
+ int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < INT_MIN || val > INT_MAX)
- return -ERANGE;
-
atomic_set(&tgt->lut_sync_count, val);
return count;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
- __s64 val;
+ bool val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- mdt->mdt_opts.mo_dom_lock = !!val;
+ mdt->mdt_opts.mo_dom_lock = val;
return count;
}
LPROC_SEQ_FOPS(mdt_dom_lock);
int lprocfs_ir_timeout_seq_show(struct seq_file *m, void *data)
{
- return lprocfs_u64_seq_show(m, &ir_timeout);
+ seq_printf(m, "%lld\n", ir_timeout);
+ return 0;
}
ssize_t lprocfs_ir_timeout_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
- return lprocfs_wr_uint(file, buffer, count, &ir_timeout);
+ return kstrtoll_from_user(buffer, count, 0, &ir_timeout);
}
/* --------------- Handle non IR support clients --------------- */
{
struct obd_device *obd;
struct obd_job_stats *stats;
+ unsigned int val;
int rc;
- __s64 val;
obd = ((struct seq_file *)file->private_data)->private;
if (obd == NULL)
stats = &obd->u.obt.obt_jobstats;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > UINT_MAX)
- return -ERANGE;
stats->ojs_cleanup_interval = val;
lprocfs_job_cleanup(stats, stats->ojs_cleanup_interval);
EXPORT_SYMBOL(lprocfs_register);
/* Generic callbacks */
-int lprocfs_uint_seq_show(struct seq_file *m, void *data)
-{
- seq_printf(m, "%u\n", *(unsigned int *)data);
- return 0;
-}
-EXPORT_SYMBOL(lprocfs_uint_seq_show);
-
-int lprocfs_wr_uint(struct file *file, const char __user *buffer,
- unsigned long count, void *data)
-{
- unsigned *p = data;
- char dummy[MAX_STRING_SIZE + 1];
- char *end;
- unsigned long tmp;
-
- if (count >= sizeof(dummy))
- return -EINVAL;
-
- if (count == 0)
- return 0;
-
- if (copy_from_user(dummy, buffer, count))
- return -EFAULT;
-
- dummy[count] = 0;
-
- tmp = simple_strtoul(dummy, &end, 0);
- if (dummy == end)
- return -EINVAL;
-
- *p = (unsigned int)tmp;
- return count;
-}
-EXPORT_SYMBOL(lprocfs_wr_uint);
-
-ssize_t lprocfs_uint_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
-{
- int *data = ((struct seq_file *)file->private_data)->private;
- int rc;
- __s64 val = 0;
-
- rc = lprocfs_str_to_s64(buffer, count, &val);
- if (rc < 0)
- return rc;
-
- return lprocfs_wr_uint(file, buffer, count, data);
-}
-EXPORT_SYMBOL(lprocfs_uint_seq_write);
-
-int lprocfs_u64_seq_show(struct seq_file *m, void *data)
-{
- LASSERT(data != NULL);
- seq_printf(m, "%llu\n", *(__u64 *)data);
- return 0;
-}
-EXPORT_SYMBOL(lprocfs_u64_seq_show);
-
-int lprocfs_atomic_seq_show(struct seq_file *m, void *data)
-{
- atomic_t *atom = data;
- LASSERT(atom != NULL);
- seq_printf(m, "%d\n", atomic_read(atom));
- return 0;
-}
-EXPORT_SYMBOL(lprocfs_atomic_seq_show);
-
-ssize_t
-lprocfs_atomic_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
-{
- atomic_t *atm = ((struct seq_file *)file->private_data)->private;
- __s64 val = 0;
- int rc;
-
- rc = lprocfs_str_to_s64(buffer, count, &val);
- if (rc < 0)
- return rc;
-
- if (val <= 0 || val > INT_MAX)
- return -ERANGE;
-
- atomic_set(atm, val);
- return count;
-}
-EXPORT_SYMBOL(lprocfs_atomic_seq_write);
-
int lprocfs_uuid_seq_show(struct seq_file *m, void *data)
{
struct obd_device *obd = data;
/**
* 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
struct client_obd *cli = &dev->u.cli;
struct obd_connect_data *ocd = &cli->cl_import->imp_connect_data;
int chunk_mask, rc;
- __s64 val;
+ s64 val;
rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1');
if (rc)
}
EXPORT_SYMBOL(lprocfs_obd_short_io_bytes_seq_show);
-
/* Used to catch people who think they're specifying pages. */
#define MIN_SHORT_IO_BYTES 64
struct obd_device *dev = ((struct seq_file *)
file->private_data)->private;
struct client_obd *cli = &dev->u.cli;
+ int val;
int rc;
- __u64 val;
LPROCFS_CLIMP_CHECK(dev);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc)
GOTO(out, rc);
- if (val > OBD_MAX_SHORT_IO_BYTES || val < MIN_SHORT_IO_BYTES)
+ if (val < MIN_SHORT_IO_BYTES || val > OBD_MAX_SHORT_IO_BYTES)
GOTO(out, rc = -ERANGE);
rc = count;
{
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
+ int val;
int rc;
- __s64 val;
LASSERT(obd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 10, &val);
if (rc)
return rc;
{
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
+ bool val;
int rc;
- __s64 val;
LASSERT(obd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- obd->obd_checksum_dump = !!val;
+ obd->obd_checksum_dump = val;
return count;
}
EXPORT_SYMBOL(lprocfs_checksum_dump_seq_write);
{
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
+ unsigned int val;
int rc;
- __s64 val;
LASSERT(obd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
obd->obd_recovery_timeout = val;
return count;
{
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
+ unsigned int val;
int rc;
- __s64 val;
LASSERT(obd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
obd->obd_recovery_time_hard = val;
return count;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- __s64 val;
+ unsigned int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 1 || val > INT_MAX)
+ if (val < 1 || val > 65536)
return -EINVAL;
spin_lock(&ofd->ofd_batch_lock);
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- __s64 val;
+ int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val > 65536 || val < 1)
+ if (val < 1 || val > 65536)
return -EINVAL;
ofd->ofd_fmd_max_num = val;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- __s64 val;
- int rc;
+ time64_t val;
+ int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoll_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val > 65536 || val < 1)
+ if (val < 1 || val > 65536) /* ~ 18 hour max */
return -EINVAL;
ofd->ofd_fmd_max_age = val;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
spin_lock(&ofd->ofd_flags_lock);
- ofd->ofd_raid_degraded = !!val;
+ ofd->ofd_raid_degraded = val;
spin_unlock(&ofd->ofd_flags_lock);
return count;
}
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- __s64 val;
+ bool val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val < 0)
- return -EINVAL;
-
spin_lock(&ofd->ofd_flags_lock);
- ofd->ofd_syncjournal = !!val;
+ ofd->ofd_syncjournal = val;
ofd_slc_set(ofd);
spin_unlock(&ofd->ofd_flags_lock);
struct obd_device *obd = m->private;
struct lu_target *tgt = obd->u.obt.obt_lut;
char kernbuf[SYNC_STATES_MAXLEN];
- __s64 val = -1;
+ int val = -1;
int i;
if (count == 0 || count >= sizeof(kernbuf))
/* Legacy numeric codes */
if (val == -1) {
- int rc = lprocfs_str_to_s64(buffer, count, &val);
+ int rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
}
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
+ seq_printf(m, "%u\n", ofd->ofd_soft_sync_limit);
+ return 0;
}
/**
ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
- struct seq_file *m = file->private_data;
+ struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+ unsigned int val;
+ int rc;
- return lprocfs_uint_seq_write(file, buffer, count,
- (loff_t *) &ofd->ofd_soft_sync_limit);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
+ if (rc < 0)
+ return rc;
+
+ ofd->ofd_soft_sync_limit = val;
+ return 0;
}
LPROC_SEQ_FOPS(ofd_soft_sync_limit);
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- __s64 val;
+ unsigned long long val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoull_from_user(buffer, count, 0, &val);
if (rc != 0)
return rc;
- if (val < 0)
- return -ERANGE;
-
rc = lfsck_set_speed(ofd->ofd_osd, val);
return rc != 0 ? rc : count;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- __s64 val;
+ bool val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
- if (rc != 0)
+ rc = kstrtobool_from_user(buffer, count, &val);
+ if (rc)
return rc;
- ofd->ofd_lfsck_verify_pfid = !!val;
+ ofd->ofd_lfsck_verify_pfid = val;
if (!ofd->ofd_lfsck_verify_pfid) {
ofd->ofd_inconsistency_self_detected = 0;
ofd->ofd_inconsistency_self_repaired = 0;
size_t count, loff_t *off)
{
struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val < 0 || val > 1)
- return -ERANGE;
/* opposite senses */
if (dev->u.cli.cl_import->imp_deactive == val)
{
struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
struct client_obd *cli = &dev->u.cli;
- int rc;
int adding, added, req_count;
- __s64 val;
+ unsigned int val;
+ int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 1 || val > OSC_MAX_RIF_MAX)
+
+ if (val == 0 || val > OSC_MAX_RIF_MAX)
return -ERANGE;
LPROCFS_CLIMP_CHECK(dev);
{
struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
struct client_obd *cli = &obd->u.cli;
- int rc;
- __s64 val;
+ s64 val;
+ int rc;
if (obd == NULL)
return 0;
size_t count, loff_t *off)
{
struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+ unsigned int val;
int rc;
- __s64 val;
if (obd == NULL)
return 0;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val <= 0 || val > INT_MAX)
+ if (val == 0)
return -ERANGE;
obd->u.cli.cl_grant_shrink_interval = val;
size_t count, loff_t *off)
{
struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+ bool val;
int rc;
- __s64 val;
if (obd == NULL)
return 0;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- obd->u.cli.cl_checksum = !!val;
+ obd->u.cli.cl_checksum = val;
return count;
}
size_t count, loff_t *off)
{
struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+ unsigned int val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 0 || val > INT_MAX)
- return -EINVAL;
-
atomic_set(&obd->u.cli.cl_resends, val);
return count;
size_t count, loff_t *off)
{
struct obd_device *obd;
+ bool val;
int rc;
- __s64 val;
obd = ((struct seq_file *)file->private_data)->private;
if (obd == NULL)
return 0;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- obd->u.cli.cl_checksum_dump = (val ? 1 : 0);
+ obd->u.cli.cl_checksum_dump = val;
return count;
}
{
struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
struct osc_device *od = obd2osc_dev(obd);
+ unsigned int val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
if (val < 0 || val > INT_MAX)
{
struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
struct osc_device *od = obd2osc_dev(obd);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val < 0)
- return -ERANGE;
- od->od_lockless_truncate = !!val;
+ od->od_lockless_truncate = val;
return count;
}
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *osd = osd_dt_dev(dt);
+ bool val;
int rc;
- __s64 val;
LASSERT(osd != NULL);
if (unlikely(osd->od_mnt == NULL))
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- osd->od_read_cache = !!val;
+ osd->od_read_cache = val;
return count;
}
LPROC_SEQ_FOPS(ldiskfs_osd_cache);
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *osd = osd_dt_dev(dt);
+ bool val;
int rc;
- __s64 val;
LASSERT(osd != NULL);
if (unlikely(osd->od_mnt == NULL))
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- osd->od_writethrough_cache = !!val;
+ osd->od_writethrough_cache = val;
return count;
}
LPROC_SEQ_FOPS(ldiskfs_osd_wcache);
ldiskfs_osd_pdo_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
+ bool pdo;
int rc;
- __s64 pdo;
- rc = lprocfs_str_to_s64(buffer, count, &pdo);
+ rc = kstrtobool_from_user(buffer, count, &pdo);
if (rc != 0)
return rc;
- ldiskfs_pdo = !!pdo;
+ ldiskfs_pdo = pdo;
return count;
}
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *dev = osd_dt_dev(dt);
+ s64 val;
int rc;
- __s64 val;
LASSERT(dev != NULL);
if (unlikely(dev->od_mnt == NULL))
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoll_from_user(buffer, count, 0, &val);
if (rc)
return rc;
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *dev = osd_dt_dev(dt);
+ s64 val;
int rc;
- __s64 val;
LASSERT(dev != NULL);
if (unlikely(dev->od_mnt == NULL))
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoll_from_user(buffer, count, 0, &val);
if (rc != 0)
return rc;
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *dev = osd_dt_dev(dt);
+ u64 val;
int rc;
- __s64 val;
LASSERT(dev != NULL);
if (unlikely(dev->od_mnt == NULL))
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoull_from_user(buffer, count, 0, &val);
if (rc != 0)
return rc;
- if (val < 0)
- return -EINVAL;
-
dev->od_full_scrub_threshold_rate = val;
return count;
}
const char __user *buffer,
size_t count, loff_t *off)
{
- __s64 track_declares_assert;
+ bool track_declares_assert;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &track_declares_assert);
- if (rc != 0)
+ rc = kstrtobool_from_user(buffer, count, &track_declares_assert);
+ if (rc)
return rc;
- ldiskfs_track_declares_assert = !!track_declares_assert;
+ ldiskfs_track_declares_assert = track_declares_assert;
return count;
}
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *osd = osd_dt_dev(dt);
- __s64 val;
+ s64 val;
int rc;
LASSERT(osd != NULL);
struct dt_device *dt = m->private;
struct osd_device *dev = osd_dt_dev(dt);
struct lu_target *tgt;
- __s64 val;
+ bool val;
int rc;
LASSERT(dev != NULL);
if (unlikely(dev->od_mnt == NULL))
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc != 0)
return rc;
if (dev->od_index_in_idif) {
- if (val != 0)
+ if (val)
return count;
LCONSOLE_WARN("%s: OST-index in IDIF has been enabled, "
return -EPERM;
}
- if (val == 0)
+ if (!val)
return count;
rc = lu_env_init(&env, LCT_DT_THREAD);
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *dev = osd_dt_dev(dt);
- __s64 val;
+ int val;
int rc;
LASSERT(dev != NULL);
if (unlikely(dev->od_mnt == NULL))
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
if (!dev->od_os)
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoull_from_user(buffer, count, 0, &val);
if (rc)
return rc;
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *dev = osd_dt_dev(dt);
- __s64 val;
+ int val;
int rc;
LASSERT(dev != NULL);
if (!dev->od_os)
return -EINPROGRESS;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
{
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val < 0 || val > 1)
- return -ERANGE;
LPROCFS_CLIMP_CHECK(dev);
/* opposite senses */
if (dev->u.cli.cl_import->imp_deactive == val)
rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val);
else
- CDEBUG(D_CONFIG, "activate %lld: ignoring repeat request\n",
+ CDEBUG(D_CONFIG, "activate %d: ignoring repeat request\n",
val);
LPROCFS_CLIMP_EXIT(dev);
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
+ unsigned int val;
int rc;
- __s64 val;
if (osp == NULL)
return -EINVAL;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 1 || val > INT_MAX)
+ if (val == 0)
return -ERANGE;
osp->opd_sync_max_rpcs_in_flight = val;
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
+ unsigned int val;
int rc;
- __s64 val;
if (osp == NULL)
return -EINVAL;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 1 || val > INT_MAX)
+ if (val == 0)
return -ERANGE;
osp->opd_sync_max_rpcs_in_progress = val;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
+ unsigned int val;
int rc, i;
- __s64 val;
if (osp == NULL || osp->opd_pre == NULL)
return 0;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
+ unsigned int val;
int rc;
- __s64 val;
if (osp == NULL || osp->opd_pre == NULL)
return 0;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
+ unsigned int val;
int rc;
- __s64 val;
if (osp == NULL)
return -EINVAL;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc)
return rc;
- if (val < 1 || val > INT_MAX)
+ if (val == 0)
return -ERANGE;
osp->opd_statfs_maxage = val;
{
struct seq_file *m = file->private_data;
struct obd_device *dev = m->private;
- __s64 val;
+ unsigned int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
- if (rc == 0) {
- if (val < 0)
- return -ERANGE;
-
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
+ if (!rc)
rc = obd_set_max_rpcs_in_flight(&dev->u.cli, val);
- } else {
+ else
count = rc;
- }
return count;
}
gss_lk_proc_dl_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
+ unsigned int val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint_from_user(buffer, count, 0, &val);
if (rc < 0)
return rc;
- if (val < 0 || val > 4)
+ if (val > 4)
return -ERANGE;
gss_lk_debug_level = val;
{
struct seq_file *m = file->private_data;
struct ptlrpc_service *svc = m->private;
+ unsigned long long val;
int bufpages;
- __s64 val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoull_from_user(buffer, count, 0, &val);
if (rc < 0)
return rc;
{
struct seq_file *m = file->private_data;
struct ptlrpc_service *svc = m->private;
- __s64 val;
+ int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc < 0)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
-
if (val < svc->srv_nbuf_per_group)
return -ERANGE;
struct obd_device *obd = m->private;
struct client_obd *cli = &obd->u.cli;
struct obd_import *imp = cli->cl_import;
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc < 0)
return rc;
- if (val != 0 && val != 1)
- return -ERANGE;
-
LPROCFS_CLIMP_CHECK(obd);
spin_lock(&imp->imp_lock);
imp->imp_no_pinger_recover = !val;
qpi_soft_least_qunit_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
- struct qmt_pool_info *pool;
- int qunit, rc;
- s64 least_qunit;
+ struct qmt_pool_info *pool;
+ long long least_qunit;
+ int qunit, rc;
pool = ((struct seq_file *)file->private_data)->private;
LASSERT(pool != NULL);
if (pool->qpi_key >> 16 != LQUOTA_RES_DT)
return -EINVAL;
- rc = lprocfs_str_to_s64(buffer, count, &least_qunit);
+ rc = kstrtoll_from_user(buffer, count, 0, &least_qunit);
if (rc)
return rc;
size_t count, loff_t *off)
{
struct qsd_instance *qsd = ((struct seq_file *)file->private_data)->private;
+ time64_t timeout;
int rc;
- __s64 timeout;
- LASSERT(qsd != NULL);
- rc = lprocfs_str_to_s64(buffer, count, &timeout);
+ LASSERT(qsd != NULL);
+ rc = kstrtoll_from_user(buffer, count, 0, &timeout);
if (rc)
return rc;
- if (timeout < 0 || timeout > INT_MAX)
+
+ if (timeout < 0)
return -EINVAL;
qsd->qsd_timeout = timeout;
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
- __s64 val;
+ bool val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc)
return rc;
- if (val < 0)
- return -EINVAL;
-
- tgd->tgd_grant_compat_disable = !!val;
+ tgd->tgd_grant_compat_disable = val;
return count;
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff