}
EXPORT_SYMBOL(lprocfs_add_vars);
-#ifndef HAVE_REMOVE_PROC_SUBTREE
-/* for b=10866, global variable */
-DECLARE_RWSEM(_lprocfs_lock);
-EXPORT_SYMBOL(_lprocfs_lock);
-
-static void lprocfs_remove_nolock(struct proc_dir_entry **proot)
-{
- struct proc_dir_entry *root = *proot;
- struct proc_dir_entry *temp = root;
- struct proc_dir_entry *rm_entry;
- struct proc_dir_entry *parent;
-
- *proot = NULL;
- if (!root || IS_ERR(root))
- return;
-
- parent = root->parent;
- LASSERT(parent != NULL);
-
- while (1) {
- while (temp->subdir)
- temp = temp->subdir;
-
- 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));
-
- 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;
-
- LASSERT(parent != NULL);
- len = strlen(name);
-
- down_write(&_lprocfs_lock);
- /* lookup target name */
- for (p = &parent->subdir; *p; p = &(*p)->next) {
- if ((*p)->namelen != len)
- continue;
- if (memcmp(name, (*p)->name, len))
- continue;
- t = *p;
- break;
- }
-
- if (t) {
- /* verify it's empty: do not count "num_refs" */
- for (p = &t->subdir; *p; p = &(*p)->next) {
- if ((*p)->namelen != strlen("num_refs")) {
- busy = 1;
- break;
- }
- if (memcmp("num_refs", (*p)->name,
- strlen("num_refs"))) {
- busy = 1;
- break;
- }
- }
- }
-
- if (busy == 0)
- lprocfs_remove_nolock(&t);
-
- up_write(&_lprocfs_lock);
- return 0;
-}
-#endif /* !HAVE_REMOVE_PROC_SUBTREE */
-
-#ifndef HAVE_PROC_REMOVE
-void proc_remove(struct proc_dir_entry *de)
-{
-#ifndef HAVE_REMOVE_PROC_SUBTREE
- down_write(&_lprocfs_lock); /* search vs remove race */
- lprocfs_remove_nolock(&de);
- up_write(&_lprocfs_lock);
-#else
- if (de)
- remove_proc_subtree(de->name, de->parent);
-#endif
-}
-#endif
-
void lprocfs_remove(struct proc_dir_entry **rooth)
{
proc_remove(*rooth);
}
EXPORT_SYMBOL(lprocfs_remove_proc_entry);
-struct dentry *ldebugfs_register(const char *name, struct dentry *parent,
- struct lprocfs_vars *list, void *data)
-{
- struct dentry *entry;
-
- entry = debugfs_create_dir(name, parent);
- if (IS_ERR_OR_NULL(entry)) {
- entry = entry ?: ERR_PTR(-ENOMEM);
- goto out;
- }
-
- if (!IS_ERR_OR_NULL(list)) {
- int rc;
-
- rc = ldebugfs_add_vars(entry, list, data);
- if (rc) {
- debugfs_remove(entry);
- entry = ERR_PTR(rc);
- }
- }
-out:
- return entry;
-}
-EXPORT_SYMBOL_GPL(ldebugfs_register);
-
struct proc_dir_entry *
lprocfs_register(const char *name, struct proc_dir_entry *parent,
struct lprocfs_vars *list, void *data)
if (!obd->obd_type->typ_procroot)
debugfs_vars = obd->obd_vars;
- obd->obd_debugfs_entry = ldebugfs_register(obd->obd_name,
- obd->obd_type->typ_debugfs_entry,
- debugfs_vars, obd);
- if (IS_ERR_OR_NULL(obd->obd_debugfs_entry)) {
- rc = obd->obd_debugfs_entry ? PTR_ERR(obd->obd_debugfs_entry)
- : -ENOMEM;
- CERROR("error %d setting up debugfs for %s\n",
- rc, obd->obd_name);
- obd->obd_debugfs_entry = NULL;
-
- sysfs_remove_files(&obd->obd_kset.kobj, obd->obd_attrs);
- obd->obd_attrs = NULL;
- kset_unregister(&obd->obd_kset);
- return rc;
- }
+ obd->obd_debugfs_entry = debugfs_create_dir(
+ obd->obd_name, obd->obd_type->typ_debugfs_entry);
+ ldebugfs_add_vars(obd->obd_debugfs_entry, debugfs_vars, obd);
if (obd->obd_proc_entry || !obd->obd_type->typ_procroot)
GOTO(already_registered, rc);
spin_lock_init(&stats->ls_lock);
/* alloc num of counter headers */
- LIBCFS_ALLOC(stats->ls_cnt_header,
- stats->ls_num * sizeof(struct lprocfs_counter_header));
+ CFS_ALLOC_PTR_ARRAY(stats->ls_cnt_header, stats->ls_num);
if (!stats->ls_cnt_header)
goto fail;
if (stats->ls_percpu[i])
LIBCFS_FREE(stats->ls_percpu[i], percpusize);
if (stats->ls_cnt_header)
- LIBCFS_FREE(stats->ls_cnt_header, stats->ls_num *
- sizeof(struct lprocfs_counter_header));
+ CFS_FREE_PTR_ARRAY(stats->ls_cnt_header, stats->ls_num);
LIBCFS_FREE(stats, offsetof(typeof(*stats), ls_percpu[num_entry]));
}
EXPORT_SYMBOL(lprocfs_free_stats);
struct seq_file *seq;
int rc;
- rc = LPROCFS_ENTRY_CHECK(inode);
- if (rc < 0)
- return rc;
-
rc = seq_open(file, &lprocfs_stats_seq_sops);
if (rc)
return rc;
*
* - ``-EINVAL``: @buffer is not a proper numerical string
* - ``-EOVERFLOW``: results does not fit into 64 bits.
- * - ``-E2BIG ``: @buffer is not large
+ * - ``-E2BIG ``: @buffer is too large (not a valid number)
*/
int string_to_size(u64 *size, const char *buffer, size_t count)
{
* 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"
+ "kB", "MB", "GB", "TB", "PB", "EB",
};
static const char *const units_2[] = {
- "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"
+ "K", "M", "G", "T", "P", "E",
};
static const char *const *const units_str[] = {
[STRING_UNITS_2] = units_2,
[STRING_UNITS_10] = 1000,
[STRING_UNITS_2] = 1024,
};
- enum string_size_units unit;
+ enum string_size_units unit = STRING_UNITS_2;
u64 whole, blk_size = 1;
char kernbuf[22], *end;
size_t len = count;
int rc;
int i;
- if (count >= sizeof(kernbuf))
+ if (count >= sizeof(kernbuf)) {
+ CERROR("count %zd > buffer %zd\n", 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.
+ /* The "iB" suffix is optionally allowed for indicating base-2 numbers.
+ * If suffix is only "B" and not "iB" then we treat it as base-10.
*/
- unit = strstr(buffer, "iB") ? STRING_UNITS_2 : STRING_UNITS_10;
+ end = strstr(buffer, "B");
+ if (end && *(end - 1) != 'i')
+ unit = 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]);
+ end = strnstr(buffer, units_str[unit][i], count);
if (end) {
for (; i >= 0; i--)
blk_size *= coeff[unit];
- len -= strlen(end);
+ len = end - buffer;
break;
}
} while (i--);
*/
if (!end) {
/* 'B' is only acceptable letter at this point */
- end = strchr(buffer, 'B');
+ end = strnchr(buffer, count, 'B');
if (end) {
- len -= strlen(end);
+ len = end - buffer;
if (count - len > 2 ||
- (count - len == 2 && strcmp(end, "B\n") != 0))
+ (count - len == 2 && strcmp(end, "B\n") != 0)) {
+ CDEBUG(D_INFO, "unknown suffix '%s'\n", buffer);
return -EINVAL;
+ }
}
/* kstrtoull will error out if it has non digits */
goto numbers_only;
}
- end = strchr(buffer, '.');
+ end = strnchr(buffer, count, '.');
if (end) {
/* need to limit 3 decimal places */
char rem[4] = "000";
int sysfs_memparse(const char *buffer, size_t count, u64 *val,
const char *defunit)
{
- char param[23];
+ const char *param = buffer;
+ char tmp_buf[23];
int rc;
- if (count >= sizeof(param))
- return -E2BIG;
-
count = strlen(buffer);
- if (count && buffer[count - 1] == '\n')
+ while (count > 0 && isspace(buffer[count - 1]))
count--;
if (!count)
- return -EINVAL;
+ 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));
+ /* If there isn't already a unit on this value, append @defunit.
+ * Units of 'B' don't affect the value, so don't bother adding.
+ */
+ if (!isalpha(buffer[count - 1]) && defunit[0] != 'B') {
+ if (count + 3 >= sizeof(tmp_buf)) {
+ CERROR("count %zd > size %zd\n", count, sizeof(param));
+ RETURN(-E2BIG);
}
- } else {
- scnprintf(param, sizeof(param), "%.*s%s", (int)count,
+
+ scnprintf(tmp_buf, sizeof(tmp_buf), "%.*s%s", (int)count,
buffer, defunit);
+ param = tmp_buf;
+ count = strlen(param);
}
- rc = string_to_size(val, param, strlen(param));
+ rc = string_to_size(val, param, count);
+
return rc < 0 ? rc : 0;
}
EXPORT_SYMBOL(sysfs_memparse);
}
EXPORT_SYMBOL(lprocfs_seq_create);
-int lprocfs_obd_seq_create(struct obd_device *dev,
+int lprocfs_obd_seq_create(struct obd_device *obd,
const char *name,
mode_t mode,
const struct file_operations *seq_fops,
void *data)
{
- return (lprocfs_seq_create(dev->obd_proc_entry, name,
- mode, seq_fops, data));
+ return lprocfs_seq_create(obd->obd_proc_entry, name,
+ mode, seq_fops, data);
}
EXPORT_SYMBOL(lprocfs_obd_seq_create);
int lprocfs_obd_max_pages_per_rpc_seq_show(struct seq_file *m, void *data)
{
- struct obd_device *dev = data;
- struct client_obd *cli = &dev->u.cli;
+ struct obd_device *obd = data;
+ struct client_obd *cli = &obd->u.cli;
spin_lock(&cli->cl_loi_list_lock);
seq_printf(m, "%d\n", cli->cl_max_pages_per_rpc);
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
- struct obd_device *dev = m->private;
- struct client_obd *cli = &dev->u.cli;
+ struct obd_device *obd = m->private;
+ struct client_obd *cli = &obd->u.cli;
struct obd_import *imp;
struct obd_connect_data *ocd;
int chunk_mask, rc;
- s64 val;
+ char kernbuf[22];
+ u64 val;
- rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1');
+ if (count > sizeof(kernbuf) - 1)
+ return -EINVAL;
+
+ if (copy_from_user(kernbuf, buffer, count))
+ return -EFAULT;
+
+ kernbuf[count] = '\0';
+
+ rc = sysfs_memparse(kernbuf, count, &val, "B");
if (rc)
return rc;
- if (val < 0)
- return -ERANGE;
/* if the max_pages is specified in bytes, convert to pages */
if (val >= ONE_MB_BRW_SIZE)
val >>= PAGE_SHIFT;
- with_imp_locked(dev, imp, rc) {
+ with_imp_locked(obd, imp, rc) {
ocd = &imp->imp_connect_data;
chunk_mask = ~((1 << (cli->cl_chunkbits - PAGE_SHIFT)) - 1);
/* max_pages_per_rpc must be chunk aligned */
ssize_t short_io_bytes_show(struct kobject *kobj, struct attribute *attr,
char *buf)
{
- struct obd_device *dev = container_of(kobj, struct obd_device,
+ struct obd_device *obd = container_of(kobj, struct obd_device,
obd_kset.kobj);
- struct client_obd *cli = &dev->u.cli;
+ struct client_obd *cli = &obd->u.cli;
int rc;
spin_lock(&cli->cl_loi_list_lock);
ssize_t short_io_bytes_store(struct kobject *kobj, struct attribute *attr,
const char *buffer, size_t count)
{
- struct obd_device *dev = container_of(kobj, struct obd_device,
+ struct obd_device *obd = container_of(kobj, struct obd_device,
obd_kset.kobj);
- struct client_obd *cli = &dev->u.cli;
- char kernbuf[32];
- s64 val;
+ struct client_obd *cli = &obd->u.cli;
+ u64 val;
int rc;
- if (count >= sizeof(kernbuf))
- return -EINVAL;
-
- memcpy(kernbuf, buffer, count);
- kernbuf[count] = '\0';
- rc = lu_str_to_s64(kernbuf, count, &val, '1');
- if (rc)
- GOTO(out, rc);
-
- if (val == -1)
+ if (strcmp(buffer, "-1") == 0) {
val = OBD_DEF_SHORT_IO_BYTES;
+ } else {
+ rc = sysfs_memparse(buffer, count, &val, "B");
+ if (rc)
+ GOTO(out, rc);
+ }
if (val && (val < MIN_SHORT_IO_BYTES || val > LNET_MTU))
GOTO(out, rc = -ERANGE);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff