*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*
* lustre/obdclass/lprocfs_status.c
*
#ifdef CONFIG_PROC_FS
+/* enable start/elapsed_time in stats headers by default */
+unsigned int obd_enable_stats_header = 1;
+
static int lprocfs_no_percpu_stats = 0;
module_param(lprocfs_no_percpu_stats, int, 0644);
MODULE_PARM_DESC(lprocfs_no_percpu_stats, "Do not alloc percpu data for lprocfs stats");
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);
-struct dentry *ldebugfs_add_simple(struct dentry *root,
- char *name, void *data,
- const struct file_operations *fops)
+static umode_t default_mode(const struct proc_ops *ops)
{
- struct dentry *entry;
umode_t mode = 0;
- if (!root || !name || !fops)
- return ERR_PTR(-EINVAL);
-
- if (fops->read)
+ if (ops->proc_read)
mode = 0444;
- if (fops->write)
+ if (ops->proc_write)
mode |= 0200;
- entry = debugfs_create_file(name, mode, root, data, fops);
- if (IS_ERR_OR_NULL(entry)) {
- CERROR("LprocFS: No memory to create <debugfs> entry %s", name);
- return entry ?: ERR_PTR(-ENOMEM);
- }
- return entry;
+
+ return mode;
}
-EXPORT_SYMBOL(ldebugfs_add_simple);
struct proc_dir_entry *
lprocfs_add_simple(struct proc_dir_entry *root, char *name,
- void *data, const struct file_operations *fops)
+ void *data, const struct proc_ops *fops)
{
struct proc_dir_entry *proc;
- mode_t mode = 0;
+ umode_t mode;
- if (root == NULL || name == NULL || fops == NULL)
- return ERR_PTR(-EINVAL);
+ if (!root || !name || !fops)
+ return ERR_PTR(-EINVAL);
- if (fops->read)
- mode = 0444;
- if (fops->write)
- mode |= 0200;
+ mode = default_mode(fops);
proc = proc_create_data(name, mode, root, fops, data);
if (!proc) {
CERROR("LprocFS: No memory to create /proc entry %s\n",
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);
-static const struct file_operations lprocfs_generic_fops = { };
+static const struct file_operations ldebugfs_empty_ops = { };
-int ldebugfs_add_vars(struct dentry *parent, struct lprocfs_vars *list,
- void *data)
+void ldebugfs_add_vars(struct dentry *parent, struct ldebugfs_vars *list,
+ void *data)
{
if (IS_ERR_OR_NULL(parent) || IS_ERR_OR_NULL(list))
- return -EINVAL;
+ return;
while (list->name) {
- struct dentry *entry;
umode_t mode = 0;
if (list->proc_mode != 0000) {
if (list->fops->write)
mode |= 0200;
}
- entry = debugfs_create_file(list->name, mode, parent,
- list->data ? : data,
- list->fops ? : &lprocfs_generic_fops);
- if (IS_ERR_OR_NULL(entry))
- return entry ? PTR_ERR(entry) : -ENOMEM;
+ debugfs_create_file(list->name, mode, parent,
+ list->data ? : data,
+ list->fops ? : &ldebugfs_empty_ops);
list++;
}
- return 0;
}
EXPORT_SYMBOL_GPL(ldebugfs_add_vars);
+static const struct proc_ops lprocfs_empty_ops = { };
+
/**
* Add /proc entries.
*
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;
+ umode_t mode = 0;
- if (list->proc_mode != 0000) {
+ if (list->proc_mode)
mode = list->proc_mode;
- } else if (list->fops) {
- if (list->fops->read)
- mode = 0444;
- if (list->fops->write)
- mode |= 0200;
- }
+ else if (list->fops)
+ mode = default_mode(list->fops);
proc = proc_create_data(list->name, mode, root,
- list->fops ?: &lprocfs_generic_fops,
+ list->fops ?: &lprocfs_empty_ops,
list->data ?: data);
- if (proc == NULL)
+ if (!proc)
return -ENOMEM;
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);
-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 == NULL || IS_ERR(root))
- return;
-
- parent = root->parent;
- LASSERT(parent != NULL);
-
- while (1) {
- while (temp->subdir != NULL)
- 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)
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);
}
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)
{
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);
}
{
struct obd_device *obd = container_of(kobj, struct obd_device,
obd_kset.kobj);
+ struct obd_import *imp;
struct ptlrpc_connection *conn;
ssize_t count;
- LPROCFS_CLIMP_CHECK(obd);
- conn = obd->u.cli.cl_import->imp_connection;
- if (conn && obd->u.cli.cl_import)
- count = sprintf(buf, "%s\n", conn->c_remote_uuid.uuid);
- else
- count = sprintf(buf, "%s\n", "<none>");
+ with_imp_locked(obd, imp, count) {
+ conn = imp->imp_connection;
+ if (conn)
+ count = sprintf(buf, "%s\n", conn->c_remote_uuid.uuid);
+ else
+ count = sprintf(buf, "%s\n", "<none>");
+ }
- LPROCFS_CLIMP_EXIT(obd);
return count;
}
EXPORT_SYMBOL(conn_uuid_show);
{
struct obd_device *obd = data;
struct obd_import *imp;
- char *imp_state_name = NULL;
+ const char *imp_state_name = NULL;
int rc = 0;
LASSERT(obd != NULL);
- LPROCFS_CLIMP_CHECK(obd);
- imp = obd->u.cli.cl_import;
- imp_state_name = ptlrpc_import_state_name(imp->imp_state);
- seq_printf(m, "%s\t%s%s\n", obd2cli_tgt(obd), imp_state_name,
- imp->imp_deactive ? "\tDEACTIVATED" : "");
+ with_imp_locked(obd, imp, rc) {
+ imp_state_name = ptlrpc_import_state_name(imp->imp_state);
+ seq_printf(m, "%s\t%s%s\n", obd2cli_tgt(obd), imp_state_name,
+ imp->imp_deactive ? "\tDEACTIVATED" : "");
+ }
- LPROCFS_CLIMP_EXIT(obd);
return rc;
}
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", "<none>");
-
- LPROCFS_CLIMP_EXIT(obd);
- return rc;
-}
-EXPORT_SYMBOL(lprocfs_conn_uuid_seq_show);
-
/** add up per-cpu counters */
/**
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;
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);
flag2str(imp, pingable);
flag2str(imp, resend_replay);
flag2str(imp, no_pinger_recover);
- flag2str(imp, need_mne_swab);
flag2str(imp, connect_tried);
}
-static const char *obd_connect_names[] = {
- /* flags names */
- "read_only",
- "lov_index",
- "connect_from_mds",
- "write_grant",
- "server_lock",
- "version",
- "request_portal",
- "acl",
- "xattr",
- "create_on_write",
- "truncate_lock",
- "initial_transno",
- "inode_bit_locks",
- "barrier",
- "getattr_by_fid",
- "no_oh_for_devices",
- "remote_client",
- "remote_client_by_force",
- "max_byte_per_rpc",
- "64bit_qdata",
- "mds_capability",
- "oss_capability",
- "early_lock_cancel",
- "som",
- "adaptive_timeouts",
- "lru_resize",
- "mds_mds_connection",
- "real_conn",
- "change_qunit_size",
- "alt_checksum_algorithm",
- "fid_is_enabled",
- "version_recovery",
- "pools",
- "grant_shrink",
- "skip_orphan",
- "large_ea",
- "full20",
- "layout_lock",
- "64bithash",
- "object_max_bytes",
- "imp_recov",
- "jobstats",
- "umask",
- "einprogress",
- "grant_param",
- "flock_owner",
- "lvb_type",
- "nanoseconds_times",
- "lightweight_conn",
- "short_io",
- "pingless",
- "flock_deadlock",
- "disp_stripe",
- "open_by_fid",
- "lfsck",
- "unknown",
- "unlink_close",
- "multi_mod_rpcs",
- "dir_stripe",
- "subtree",
- "lockahead",
- "bulk_mbits",
- "compact_obdo",
- "second_flags",
- /* flags2 names */
- "file_secctx",
- "lockaheadv2",
+static const char *const obd_connect_names[] = {
+ "read_only", /* 0x01 */
+ "lov_index", /* 0x02 */
+ "connect_from_mds", /* 0x03 */
+ "write_grant", /* 0x04 */
+ "server_lock", /* 0x10 */
+ "version", /* 0x20 */
+ "request_portal", /* 0x40 */
+ "acl", /* 0x80 */
+ "xattr", /* 0x100 */
+ "create_on_write", /* 0x200 */
+ "truncate_lock", /* 0x400 */
+ "initial_transno", /* 0x800 */
+ "inode_bit_locks", /* 0x1000 */
+ "barrier", /* 0x2000 */
+ "getattr_by_fid", /* 0x4000 */
+ "no_oh_for_devices", /* 0x8000 */
+ "remote_client", /* 0x10000 */
+ "remote_client_by_force", /* 0x20000 */
+ "max_byte_per_rpc", /* 0x40000 */
+ "64bit_qdata", /* 0x80000 */
+ "mds_capability", /* 0x100000 */
+ "oss_capability", /* 0x200000 */
+ "early_lock_cancel", /* 0x400000 */
+ "som", /* 0x800000 */
+ "adaptive_timeouts", /* 0x1000000 */
+ "lru_resize", /* 0x2000000 */
+ "mds_mds_connection", /* 0x4000000 */
+ "real_conn", /* 0x8000000 */
+ "change_qunit_size", /* 0x10000000 */
+ "alt_checksum_algorithm", /* 0x20000000 */
+ "fid_is_enabled", /* 0x40000000 */
+ "version_recovery", /* 0x80000000 */
+ "pools", /* 0x100000000 */
+ "grant_shrink", /* 0x200000000 */
+ "skip_orphan", /* 0x400000000 */
+ "large_ea", /* 0x800000000 */
+ "full20", /* 0x1000000000 */
+ "layout_lock", /* 0x2000000000 */
+ "64bithash", /* 0x4000000000 */
+ "object_max_bytes", /* 0x8000000000 */
+ "imp_recov", /* 0x10000000000 */
+ "jobstats", /* 0x20000000000 */
+ "umask", /* 0x40000000000 */
+ "einprogress", /* 0x80000000000 */
+ "grant_param", /* 0x100000000000 */
+ "flock_owner", /* 0x200000000000 */
+ "lvb_type", /* 0x400000000000 */
+ "nanoseconds_times", /* 0x800000000000 */
+ "lightweight_conn", /* 0x1000000000000 */
+ "short_io", /* 0x2000000000000 */
+ "pingless", /* 0x4000000000000 */
+ "flock_deadlock", /* 0x8000000000000 */
+ "disp_stripe", /* 0x10000000000000 */
+ "open_by_fid", /* 0x20000000000000 */
+ "lfsck", /* 0x40000000000000 */
+ "unknown", /* 0x80000000000000 */
+ "unlink_close", /* 0x100000000000000 */
+ "multi_mod_rpcs", /* 0x200000000000000 */
+ "dir_stripe", /* 0x400000000000000 */
+ "subtree", /* 0x800000000000000 */
+ "lockahead", /* 0x1000000000000000 */
+ "bulk_mbits", /* 0x2000000000000000 */
+ "compact_obdo", /* 0x4000000000000000 */
+ "second_flags", /* 0x8000000000000000 */
+ /* ocd_connect_flags2 names */
+ "file_secctx", /* 0x01 */
+ "lockaheadv2", /* 0x02 */
+ "dir_migrate", /* 0x04 */
+ "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 */
+ "fidmap", /* 0x10000 */
+ "getattr_pfid", /* 0x20000 */
+ "lseek", /* 0x40000 */
+ "dom_lvb", /* 0x80000 */
+ "reply_mbits", /* 0x100000 */
+ "mode_convert", /* 0x200000 */
+ "batch_rpc", /* 0x400000 */
+ "pcc_ro", /* 0x800000 */
+ "mne_nid_type", /* 0x1000000 */
+ "lock_contend", /* 0x2000000 */
+ "atomic_open_lock", /* 0x4000000 */
+ "name_encryption", /* 0x8000000 */
+ "mkdir_replay", /* 0x10000000 */
+ "dmv_imp_inherit", /* 0x20000000 */
+ "encryption_fid2path", /* 0x40000000 */
+ "replay_create", /* 0x80000000 */
+ "large_nid", /* 0x100000000 */
+ "compressed_file", /* 0x200000000 */
+ "unaligned_dio", /* 0x400000000 */
+ "conn_policy", /* 0x800000000 */
NULL
};
ocd->ocd_maxmodrpcs);
}
-int lprocfs_import_seq_show(struct seq_file *m, void *data)
+static void lprocfs_import_seq_show_locked(struct seq_file *m,
+ struct obd_device *obd,
+ struct obd_import *imp)
{
- 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_import_conn *conn;
+ struct obd_connect_data *ocd;
+ int j;
+ int k;
+ int rw = 0;
- LASSERT(obd != NULL);
- LPROCFS_CLIMP_CHECK(obd);
- imp = obd->u.cli.cl_import;
ocd = &imp->imp_connect_data;
seq_printf(m, "import:\n"
spin_lock(&imp->imp_lock);
j = 0;
list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
- libcfs_nid2str_r(conn->oic_conn->c_peer.nid,
- nidstr, sizeof(nidstr));
- seq_printf(m, "%s%s", j ? ", " : "", nidstr);
+ libcfs_nidstr_r(&conn->oic_conn->c_peer.nid,
+ nidstr, sizeof(nidstr));
+ if (j)
+ seq_puts(m, ", ");
+ /* Place nidstr in quotes */
+ seq_printf(m, "\"%s\"", nidstr);
j++;
}
- if (imp->imp_connection != NULL)
- libcfs_nid2str_r(imp->imp_connection->c_peer.nid,
- nidstr, sizeof(nidstr));
+ if (imp->imp_connection)
+ libcfs_nidstr_r(&imp->imp_connection->c_peer.nid,
+ nidstr, sizeof(nidstr));
else
strncpy(nidstr, "<none>", sizeof(nidstr));
seq_printf(m, " ]\n"
- " current_connection: %s\n"
+ " current_connection: \"%s\"\n"
" connection_attempts: %u\n"
" generation: %u\n"
- " in-progress_invalidations: %u\n",
+ " in-progress_invalidations: %u\n"
+ " idle: %lld sec\n",
nidstr,
imp->imp_conn_cnt,
imp->imp_generation,
- atomic_read(&imp->imp_inval_count));
+ atomic_read(&imp->imp_inval_count),
+ ktime_get_real_seconds() - imp->imp_last_reply_time);
spin_unlock(&imp->imp_lock);
- if (obd->obd_svc_stats == NULL)
- goto out_climp;
+ if (!obd->obd_svc_stats)
+ return;
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"
if (imp->imp_at.iat_portal[j] == 0)
break;
k = max_t(unsigned int, k,
- at_get(&imp->imp_at.iat_service_estimate[j]));
+ obd_at_get(imp->imp_obd,
+ &imp->imp_at.iat_service_estimate[j]));
}
seq_printf(m, " service_estimates:\n"
" services: %u sec\n"
- " network: %u sec\n",
+ " network: %d sec\n",
k,
- at_get(&imp->imp_at.iat_net_latency));
+ obd_at_get(imp->imp_obd, &imp->imp_at.iat_net_latency));
seq_printf(m, " transactions:\n"
" last_replay: %llu\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;
k / j, (100 * k / j) % 100);
}
}
+}
-out_climp:
- LPROCFS_CLIMP_EXIT(obd);
- return 0;
+int lprocfs_import_seq_show(struct seq_file *m, void *data)
+{
+ struct obd_device *obd = (struct obd_device *)data;
+ struct obd_import *imp;
+ int rv;
+
+ LASSERT(obd != NULL);
+ with_imp_locked(obd, imp, rv)
+ lprocfs_import_seq_show_locked(m, obd, imp);
+ return rv;
}
EXPORT_SYMBOL(lprocfs_import_seq_show);
struct obd_device *obd = (struct obd_device *)data;
struct obd_import *imp;
int j, k;
+ int rc;
LASSERT(obd != NULL);
- LPROCFS_CLIMP_CHECK(obd);
- imp = obd->u.cli.cl_import;
-
- seq_printf(m, "current_state: %s\n",
- ptlrpc_import_state_name(imp->imp_state));
- seq_printf(m, "state_history:\n");
- k = imp->imp_state_hist_idx;
- for (j = 0; j < IMP_STATE_HIST_LEN; j++) {
- struct import_state_hist *ish =
- &imp->imp_state_hist[(k + j) % IMP_STATE_HIST_LEN];
- if (ish->ish_state == 0)
- continue;
- seq_printf(m, " - [ %lld, %s ]\n", (s64)ish->ish_time,
- ptlrpc_import_state_name(ish->ish_state));
+ with_imp_locked(obd, imp, rc) {
+ seq_printf(m, "current_state: %s\n",
+ ptlrpc_import_state_name(imp->imp_state));
+ seq_printf(m, "state_history:\n");
+ k = imp->imp_state_hist_idx;
+ for (j = 0; j < IMP_STATE_HIST_LEN; j++) {
+ struct import_state_hist *ish =
+ &imp->imp_state_hist[(k + j) % IMP_STATE_HIST_LEN];
+ if (ish->ish_state == 0)
+ continue;
+ seq_printf(m, " - [ %lld, %s ]\n", (s64)ish->ish_time,
+ ptlrpc_import_state_name(ish->ish_state));
+ }
}
- LPROCFS_CLIMP_EXIT(obd);
- return 0;
+ return rc;
}
EXPORT_SYMBOL(lprocfs_state_seq_show);
EXPORT_SYMBOL(lprocfs_at_hist_helper);
/* See also ptlrpc_lprocfs_timeouts_show_seq */
-int lprocfs_timeouts_seq_show(struct seq_file *m, void *data)
+static void lprocfs_timeouts_seq_show_locked(struct seq_file *m,
+ struct obd_device *obd,
+ struct obd_import *imp)
{
- struct obd_device *obd = (struct obd_device *)data;
- struct obd_import *imp;
- unsigned int cur, worst;
- time64_t now, worstt;
+ timeout_t cur_timeout, worst_timeout;
+ time64_t now, worst_timestamp;
int i;
LASSERT(obd != NULL);
- LPROCFS_CLIMP_CHECK(obd);
- imp = obd->u.cli.cl_import;
now = ktime_get_real_seconds();
"last reply", (s64)imp->imp_last_reply_time,
(s64)(now - imp->imp_last_reply_time));
- cur = at_get(&imp->imp_at.iat_net_latency);
- worst = imp->imp_at.iat_net_latency.at_worst_ever;
- worstt = imp->imp_at.iat_net_latency.at_worst_time;
+ cur_timeout = obd_at_get(imp->imp_obd, &imp->imp_at.iat_net_latency);
+ worst_timeout = imp->imp_at.iat_net_latency.at_worst_timeout_ever;
+ worst_timestamp = imp->imp_at.iat_net_latency.at_worst_timestamp;
seq_printf(m, "%-10s : cur %3u worst %3u (at %lld, %llds ago) ",
- "network", cur, worst, (s64)worstt, (s64)(now - worstt));
+ "network", cur_timeout, worst_timeout, worst_timestamp,
+ now - worst_timestamp);
lprocfs_at_hist_helper(m, &imp->imp_at.iat_net_latency);
for(i = 0; i < IMP_AT_MAX_PORTALS; i++) {
+ struct adaptive_timeout *service_est;
+
if (imp->imp_at.iat_portal[i] == 0)
break;
- cur = at_get(&imp->imp_at.iat_service_estimate[i]);
- worst = imp->imp_at.iat_service_estimate[i].at_worst_ever;
- worstt = imp->imp_at.iat_service_estimate[i].at_worst_time;
+
+ service_est = &imp->imp_at.iat_service_estimate[i];
+ cur_timeout = obd_at_get(imp->imp_obd, service_est);
+ worst_timeout = service_est->at_worst_timeout_ever;
+ worst_timestamp = service_est->at_worst_timestamp;
seq_printf(m, "portal %-2d : cur %3u worst %3u (at %lld, %llds ago) ",
- imp->imp_at.iat_portal[i], cur, worst, (s64)worstt,
- (s64)(now - worstt));
- lprocfs_at_hist_helper(m, &imp->imp_at.iat_service_estimate[i]);
+ imp->imp_at.iat_portal[i], cur_timeout,
+ worst_timeout, worst_timestamp,
+ now - worst_timestamp);
+ lprocfs_at_hist_helper(m, service_est);
}
+}
- LPROCFS_CLIMP_EXIT(obd);
- return 0;
+int lprocfs_timeouts_seq_show(struct seq_file *m, void *data)
+{
+ struct obd_device *obd = (struct obd_device *)data;
+ struct obd_import *imp;
+ int rc;
+
+ with_imp_locked(obd, imp, rc)
+ lprocfs_timeouts_seq_show_locked(m, obd, imp);
+ return rc;
}
EXPORT_SYMBOL(lprocfs_timeouts_seq_show);
struct obd_device *obd = data;
__u64 flags;
__u64 flags2;
+ struct obd_import *imp;
+ int rc;
- LPROCFS_CLIMP_CHECK(obd);
- flags = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags;
- flags2 = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags2;
- seq_printf(m, "flags=%#llx\n", flags);
- seq_printf(m, "flags2=%#llx\n", flags2);
- obd_connect_seq_flags2str(m, flags, flags2, "\n");
- seq_printf(m, "\n");
- LPROCFS_CLIMP_EXIT(obd);
- return 0;
+ with_imp_locked(obd, imp, rc) {
+ flags = imp->imp_connect_data.ocd_connect_flags;
+ flags2 = imp->imp_connect_data.ocd_connect_flags2;
+ seq_printf(m, "flags=%#llx\n", flags);
+ seq_printf(m, "flags2=%#llx\n", flags2);
+ obd_connect_seq_flags2str(m, flags, flags2, "\n");
+ seq_printf(m, "\n");
+ }
+
+ return rc;
}
EXPORT_SYMBOL(lprocfs_connect_flags_seq_show);
-static struct attribute *obd_def_uuid_attrs[] = {
+static const struct attribute *obd_def_uuid_attrs[] = {
&lustre_attr_uuid.attr,
NULL,
};
-static struct attribute *obd_def_attrs[] = {
+static const struct attribute *obd_def_attrs[] = {
&lustre_attr_blocksize.attr,
&lustre_attr_kbytestotal.attr,
&lustre_attr_kbytesfree.attr,
int lprocfs_obd_setup(struct obd_device *obd, bool uuid_only)
{
- struct lprocfs_vars *debugfs_vars = NULL;
+ struct ldebugfs_vars *debugfs_vars = NULL;
int rc;
if (!obd || obd->obd_magic != OBD_DEVICE_MAGIC)
obd->obd_ktype.sysfs_ops = &lustre_sysfs_ops;
obd->obd_ktype.release = obd_sysfs_release;
- if (obd->obd_attrs)
- obd->obd_ktype.default_attrs = obd->obd_attrs;
- 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);
return rc;
if (uuid_only)
- obd->obd_attrs_group.attrs = obd_def_uuid_attrs;
+ obd->obd_attrs = obd_def_uuid_attrs;
else
- obd->obd_attrs_group.attrs = obd_def_attrs;
+ obd->obd_attrs = obd_def_attrs;
- rc = sysfs_create_group(&obd->obd_kset.kobj, &obd->obd_attrs_group);
+ rc = sysfs_create_files(&obd->obd_kset.kobj, obd->obd_attrs);
if (rc) {
kset_unregister(&obd->obd_kset);
return rc;
}
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;
- lprocfs_obd_cleanup(obd);
- return rc;
- }
+ debugfs_vars = obd->obd_debugfs_vars;
+ 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);
rc = PTR_ERR(obd->obd_proc_entry);
CERROR("error %d setting up lprocfs for %s\n",rc,obd->obd_name);
obd->obd_proc_entry = NULL;
- lprocfs_obd_cleanup(obd);
+
+ 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);
+ return rc;
}
already_registered:
return rc;
if (!obd)
return -EINVAL;
+ debugfs_remove_recursive(obd->obd_debugfs_gss_dir);
+ obd->obd_debugfs_gss_dir = NULL;
+
if (obd->obd_proc_exports_entry) {
/* Should be no exports left */
lprocfs_remove(&obd->obd_proc_exports_entry);
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)
+ return 0;
+
+ if (obd->obd_attrs) {
+ sysfs_remove_files(&obd->obd_kset.kobj, obd->obd_attrs);
+ obd->obd_attrs = NULL;
+ }
- sysfs_remove_group(&obd->obd_kset.kobj, &obd->obd_attrs_group);
kset_unregister(&obd->obd_kset);
wait_for_completion(&obd->obd_kobj_unregister);
-
return 0;
}
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)
return rc;
}
-struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num,
+struct lprocfs_stats *lprocfs_stats_alloc(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;
/* 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;
stats->ls_flags = flags;
+ stats->ls_init = ktime_get_real();
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));
- if (stats->ls_cnt_header == NULL)
+ CFS_ALLOC_PTR_ARRAY(stats->ls_cnt_header, stats->ls_num);
+ 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) {
return stats;
fail:
- lprocfs_free_stats(&stats);
+ lprocfs_stats_free(&stats);
return NULL;
}
-EXPORT_SYMBOL(lprocfs_alloc_stats);
+EXPORT_SYMBOL(lprocfs_stats_alloc);
-void lprocfs_free_stats(struct lprocfs_stats **statsh)
+void lprocfs_stats_free(struct lprocfs_stats **statsh)
{
struct lprocfs_stats *stats = *statsh;
unsigned int num_entry;
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;
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)
- LIBCFS_FREE(stats->ls_cnt_header, stats->ls_num *
- sizeof(struct lprocfs_counter_header));
+
+ if (stats->ls_cnt_header) {
+ for (i = 0; i < stats->ls_num; i++)
+ if (stats->ls_cnt_header[i].lc_hist != NULL)
+ CFS_FREE_PTR(stats->ls_cnt_header[i].lc_hist);
+ 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);
+EXPORT_SYMBOL(lprocfs_stats_free);
u64 lprocfs_stats_collector(struct lprocfs_stats *stats, int idx,
enum lprocfs_fields_flags field)
}
EXPORT_SYMBOL(lprocfs_stats_collector);
-void lprocfs_clear_stats(struct lprocfs_stats *stats)
+void lprocfs_stats_clear(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;
+ unsigned int num_entry;
+ unsigned long flags = 0;
+ int i, j;
num_entry = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags);
+ /* clear histogram if exists */
+ for (j = 0; j < stats->ls_num; j++) {
+ struct obd_histogram *hist = stats->ls_cnt_header[j].lc_hist;
+
+ if (hist != NULL)
+ lprocfs_oh_clear(hist);
+ }
+
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);
percpu_cntr->lc_sum_irq = 0;
}
}
+ stats->ls_init = ktime_get_real();
lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
}
-EXPORT_SYMBOL(lprocfs_clear_stats);
+EXPORT_SYMBOL(lprocfs_stats_clear);
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_stats_clear(stats);
- return len;
+ return len;
}
static void *lprocfs_stats_seq_start(struct seq_file *p, loff_t *pos)
return lprocfs_stats_seq_start(p, pos);
}
+/**
+ * print header of stats including snapshot_time, start_time and elapsed_time.
+ *
+ * \param seq the file to print content to
+ * \param now end time to calculate elapsed_time
+ * \param ts_init start time to calculate elapsed_time
+ * \param width the width of key to align them well
+ * \param colon "" or ":"
+ * \param show_units show units or not
+ * \param prefix prefix (indent) before printing each line of header
+ * to align them with other content
+ */
+void lprocfs_stats_header(struct seq_file *seq, ktime_t now, ktime_t ts_init,
+ int width, const char *colon, bool show_units,
+ const char *prefix)
+{
+ const char *units = show_units ? " secs.nsecs" : "";
+ struct timespec64 ts;
+ const char *field;
+
+ field = (colon && colon[0]) ? "snapshot_time:" : "snapshot_time";
+ ts = ktime_to_timespec64(now);
+ seq_printf(seq, "%s%-*s %llu.%09lu%s\n", prefix, width, field,
+ (s64)ts.tv_sec, ts.tv_nsec, units);
+
+ if (!obd_enable_stats_header)
+ return;
+
+ field = (colon && colon[0]) ? "start_time:" : "start_time";
+ ts = ktime_to_timespec64(ts_init);
+ seq_printf(seq, "%s%-*s %llu.%09lu%s\n", prefix, width, field,
+ (s64)ts.tv_sec, ts.tv_nsec, units);
+
+ field = (colon && colon[0]) ? "elapsed_time:" : "elapsed_time";
+ ts = ktime_to_timespec64(ktime_sub(now, ts_init));
+ seq_printf(seq, "%s%-*s %llu.%09lu%s\n", prefix, width, field,
+ (s64)ts.tv_sec, ts.tv_nsec, units);
+}
+EXPORT_SYMBOL(lprocfs_stats_header);
+
/* 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;
-
- if (idx == 0) {
- struct timespec64 now;
+ struct lprocfs_stats *stats = p->private;
+ struct lprocfs_counter_header *hdr;
+ struct lprocfs_counter ctr;
+ int idx = *(loff_t *)v;
- ktime_get_real_ts64(&now);
- seq_printf(p, "%-25s %llu.%09lu secs.nsecs\n",
- "snapshot_time", (s64)now.tv_sec, now.tv_nsec);
- }
+ if (idx == 0)
+ lprocfs_stats_header(p, ktime_get_real(), stats->ls_init, 25,
+ "", true, "");
hdr = &stats->ls_cnt_header[idx];
lprocfs_stats_collect(stats, idx, &ctr);
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;
seq = file->private_data;
- seq->private = inode->i_private ? inode->i_private : PDE_DATA(inode);
+ seq->private = inode->i_private ? inode->i_private : pde_data(inode);
return 0;
}
-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,
+const struct file_operations ldebugfs_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,
+};
+EXPORT_SYMBOL(ldebugfs_stats_seq_fops);
+
+static const struct proc_ops lprocfs_stats_seq_fops = {
+ PROC_OWNER(THIS_MODULE)
+ .proc_open = lprocfs_stats_seq_open,
+ .proc_read = seq_read,
+ .proc_write = lprocfs_stats_seq_write,
+ .proc_lseek = seq_lseek,
+ .proc_release = lprocfs_seq_release,
};
-int ldebugfs_register_stats(struct dentry *parent, const char *name,
- struct lprocfs_stats *stats)
-{
- struct dentry *entry;
-
- LASSERT(!IS_ERR_OR_NULL(parent));
-
- entry = debugfs_create_file(name, 0644, parent, stats,
- &lprocfs_stats_seq_fops);
- if (IS_ERR_OR_NULL(entry))
- return entry ? PTR_ERR(entry) : -ENOMEM;
-
- return 0;
-}
-EXPORT_SYMBOL_GPL(ldebugfs_register_stats);
-
-int lprocfs_register_stats(struct proc_dir_entry *root, const char *name,
- struct lprocfs_stats *stats)
+int lprocfs_stats_register(struct proc_dir_entry *root, const char *name,
+ struct lprocfs_stats *stats)
{
struct proc_dir_entry *entry;
- LASSERT(root != NULL);
+ LASSERT(root != NULL);
entry = proc_create_data(name, 0644, root,
&lprocfs_stats_seq_fops, stats);
- if (entry == NULL)
+ if (!entry)
return -ENOMEM;
+
return 0;
}
-EXPORT_SYMBOL(lprocfs_register_stats);
+EXPORT_SYMBOL(lprocfs_stats_register);
-void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
- unsigned conf, const char *name, const char *units)
+static const char *lprocfs_counter_config_units(const char *name,
+ enum lprocfs_counter_config config)
{
- struct lprocfs_counter_header *header;
- struct lprocfs_counter *percpu_cntr;
- unsigned long flags = 0;
- unsigned int i;
- unsigned int num_cpu;
+ const char *units;
+
+ switch (config & LPROCFS_TYPE_MASK) {
+ default:
+ units = "reqs"; break;
+ case LPROCFS_TYPE_BYTES:
+ units = "bytes"; break;
+ case LPROCFS_TYPE_PAGES:
+ units = "pages"; break;
+ case LPROCFS_TYPE_LOCKS:
+ units = "locks"; break;
+ case LPROCFS_TYPE_LOCKSPS:
+ units = "locks/s"; break;
+ case LPROCFS_TYPE_SECS:
+ units = "secs"; break;
+ case LPROCFS_TYPE_USECS:
+ units = "usecs"; break;
+ }
+
+ return units;
+}
+
+void lprocfs_counter_init_units(struct lprocfs_stats *stats, int index,
+ enum lprocfs_counter_config config,
+ 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;
LASSERT(stats != NULL);
LASSERTF(header != NULL, "Failed to allocate stats header:[%d]%s/%s\n",
index, name, units);
- header->lc_config = conf;
- header->lc_name = name;
- header->lc_units = units;
+ header->lc_config = config;
+ header->lc_name = name;
+ header->lc_units = units;
+ if (config & LPROCFS_CNTR_HISTOGRAM) {
+ CFS_ALLOC_PTR(stats->ls_cnt_header[index].lc_hist);
+ if (stats->ls_cnt_header[index].lc_hist == NULL)
+ CERROR("LprocFS: Failed to allocate histogram:[%d]%s/%s\n",
+ index, name, units);
+ else
+ spin_lock_init(&stats->ls_cnt_header[index].lc_hist->oh_lock);
+ }
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;
}
lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
}
-EXPORT_SYMBOL(lprocfs_counter_init);
+EXPORT_SYMBOL(lprocfs_counter_init_units);
-/* Note that we only init md counters for ops whose offset is less
- * than NUM_MD_STATS. This is explained in a comment in the definition
- * of struct md_ops. */
-#define LPROCFS_MD_OP_INIT(base, stats, op) \
- do { \
- unsigned int _idx = base + MD_COUNTER_OFFSET(op); \
- \
- if (MD_COUNTER_OFFSET(op) < NUM_MD_STATS) { \
- LASSERT(_idx < stats->ls_num); \
- lprocfs_counter_init(stats, _idx, 0, #op, "reqs"); \
- } \
- } while (0)
-
-void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats)
-{
- LPROCFS_MD_OP_INIT(num_private_stats, stats, get_root);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, null_inode);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, close);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, create);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, enqueue);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, getattr);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, getattr_name);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, intent_lock);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, link);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, rename);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, setattr);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, fsync);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, read_page);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, unlink);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, setxattr);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, getxattr);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, init_ea_size);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, get_lustre_md);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, free_lustre_md);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, merge_attr);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, set_open_replay_data);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, clear_open_replay_data);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, set_lock_data);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, lock_match);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, cancel_unused);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, intent_getattr_async);
- LPROCFS_MD_OP_INIT(num_private_stats, stats, revalidate_lock);
+void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
+ enum lprocfs_counter_config config,
+ const char *name)
+{
+ lprocfs_counter_init_units(stats, index, config, name,
+ lprocfs_counter_config_units(name, config));
}
+EXPORT_SYMBOL(lprocfs_counter_init);
+
+static const char * const mps_stats[] = {
+ [LPROC_MD_CLOSE] = "close",
+ [LPROC_MD_CREATE] = "create",
+ [LPROC_MD_ENQUEUE] = "enqueue",
+ [LPROC_MD_GETATTR] = "getattr",
+ [LPROC_MD_INTENT_LOCK] = "intent_lock",
+ [LPROC_MD_LINK] = "link",
+ [LPROC_MD_RENAME] = "rename",
+ [LPROC_MD_SETATTR] = "setattr",
+ [LPROC_MD_FSYNC] = "fsync",
+ [LPROC_MD_READ_PAGE] = "read_page",
+ [LPROC_MD_UNLINK] = "unlink",
+ [LPROC_MD_SETXATTR] = "setxattr",
+ [LPROC_MD_GETXATTR] = "getxattr",
+ [LPROC_MD_INTENT_GETATTR_ASYNC] = "intent_getattr_async",
+ [LPROC_MD_REVALIDATE_LOCK] = "revalidate_lock",
+};
int lprocfs_alloc_md_stats(struct obd_device *obd,
unsigned int num_private_stats)
unsigned int num_stats;
int rc, i;
- CLASSERT(offsetof(struct md_ops, MD_STATS_FIRST_OP) == 0);
- CLASSERT(_MD_COUNTER_OFFSET(MD_STATS_FIRST_OP) == 0);
- CLASSERT(_MD_COUNTER_OFFSET(MD_STATS_LAST_OP) > 0);
-
- /* 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
*/
LASSERT(obd->obd_proc_entry != NULL);
LASSERT(obd->obd_md_stats == NULL);
- LASSERT(obd->obd_md_cntr_base == 0);
- num_stats = NUM_MD_STATS + num_private_stats;
- stats = lprocfs_alloc_stats(num_stats, 0);
- if (stats == NULL)
+ num_stats = ARRAY_SIZE(mps_stats) + num_private_stats;
+ stats = lprocfs_stats_alloc(num_stats, 0);
+ if (!stats)
return -ENOMEM;
- lprocfs_init_mps_stats(num_private_stats, stats);
-
- for (i = num_private_stats; i < num_stats; i++) {
- if (stats->ls_cnt_header[i].lc_name == NULL) {
- CERROR("Missing md_stat initializer md_op "
- "operation at offset %d. Aborting.\n",
- i - num_private_stats);
+ for (i = 0; i < ARRAY_SIZE(mps_stats); i++) {
+ lprocfs_counter_init(stats, i, LPROCFS_TYPE_REQS,
+ mps_stats[i]);
+ if (!stats->ls_cnt_header[i].lc_name) {
+ CERROR("Missing md_stat initializer md_op operation at offset %d. Aborting.\n",
+ i);
LBUG();
}
}
- rc = lprocfs_register_stats(obd->obd_proc_entry, "md_stats", stats);
+ rc = lprocfs_stats_register(obd->obd_proc_entry, "md_stats", stats);
if (rc < 0) {
- lprocfs_free_stats(&stats);
+ lprocfs_stats_free(&stats);
} else {
obd->obd_md_stats = stats;
- obd->obd_md_cntr_base = num_private_stats;
}
return rc;
{
struct lprocfs_stats *stats = obd->obd_md_stats;
- if (stats != NULL) {
+ if (stats) {
obd->obd_md_stats = NULL;
- obd->obd_md_cntr_base = 0;
- lprocfs_free_stats(&stats);
+ lprocfs_stats_free(&stats);
}
}
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,
+ LPROCFS_TYPE_REQS, "ldlm_enqueue");
+ lprocfs_counter_init(ldlm_stats, LDLM_CONVERT - LDLM_FIRST_OPC,
+ LPROCFS_TYPE_REQS, "ldlm_convert");
+ lprocfs_counter_init(ldlm_stats, LDLM_CANCEL - LDLM_FIRST_OPC,
+ LPROCFS_TYPE_REQS, "ldlm_cancel");
+ lprocfs_counter_init(ldlm_stats, LDLM_BL_CALLBACK - LDLM_FIRST_OPC,
+ LPROCFS_TYPE_REQS, "ldlm_bl_callback");
+ lprocfs_counter_init(ldlm_stats, LDLM_CP_CALLBACK - LDLM_FIRST_OPC,
+ LPROCFS_TYPE_REQS, "ldlm_cp_callback");
+ lprocfs_counter_init(ldlm_stats, LDLM_GL_CALLBACK - LDLM_FIRST_OPC,
+ LPROCFS_TYPE_REQS, "ldlm_gl_callback");
}
EXPORT_SYMBOL(lprocfs_init_ldlm_stats);
{
__s64 ret = 0;
- if (lc == NULL || header == NULL)
+ if (!lc || !header)
RETURN(0);
switch (field) {
ret = lc->lc_max;
break;
case LPROCFS_FIELDS_FLAGS_AVG:
- ret = (lc->lc_max - lc->lc_min) / 2;
+ ret = div64_u64((flags & LPROCFS_STATS_FLAG_IRQ_SAFE ?
+ lc->lc_sum_irq : 0) + lc->lc_sum,
+ lc->lc_count);
break;
case LPROCFS_FIELDS_FLAGS_SUMSQUARE:
ret = lc->lc_sumsquare;
}
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);
- }
-
- seq_printf(m, "\n");
- return 0;
-}
-EXPORT_SYMBOL(lprocfs_seq_read_frac_helper);
-
-/* Obtains the conversion factor for the unit specified */
-static int get_mult(char unit, __u64 *mult)
-{
- __u64 units = 1;
-
- switch (unit) {
- /* peta, tera, giga, mega, and kilo */
- case 'p':
- case 'P':
- units <<= 10;
- case 't':
- case 'T':
- units <<= 10;
- case 'g':
- case 'G':
- units <<= 10;
- case 'm':
- case 'M':
- units <<= 10;
- case 'k':
- case 'K':
- units <<= 10;
- break;
- /* some tests expect % to be accepted */
- case '%':
- units = 1;
- break;
- default:
- return -EINVAL;
- }
-
- *mult = units;
-
- return 0;
-}
-
-/*
- * Ensures the numeric string is valid. The function provides the final
- * multiplier in the case a unit exists at the end of the string. It also
- * locates the start of the whole and fractional parts (if any). This
- * function modifies the string so kstrtoull can be used to parse both
- * the whole and fraction portions. This function also figures out
- * the base of the number.
+/**
+ * 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 too large (not a valid number)
*/
-static int preprocess_numeric_str(char *buffer, __u64 *mult, __u64 def_mult,
- bool allow_units, char **whole, char **frac,
- unsigned int *base)
+int string_to_size(u64 *size, const char *buffer, size_t count)
{
- bool hit_decimal = false;
- bool hit_unit = false;
- int rc = 0;
- char *start;
- *mult = def_mult;
- *whole = NULL;
- *frac = NULL;
- *base = 10;
+ /* 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[] = {
+ "K", "M", "G", "T", "P", "E",
+ };
+ 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 = STRING_UNITS_2;
+ u64 whole, blk_size = 1;
+ char kernbuf[22], *end;
+ size_t len = count;
+ int rc;
+ int i;
- /* a hex string if it starts with "0x" */
- if (buffer[0] == '0' && tolower(buffer[1]) == 'x') {
- *base = 16;
- buffer += 2;
+ if (count >= sizeof(kernbuf)) {
+ CERROR("count %zd > buffer %zd\n", count, sizeof(kernbuf));
+ return -E2BIG;
}
- start = buffer;
-
- while (*buffer) {
- /* allow for a single new line before the null terminator */
- if (*buffer == '\n') {
- *buffer = '\0';
- buffer++;
-
- if (*buffer)
- return -EINVAL;
-
+ *size = 0;
+ /* 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.
+ */
+ 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 = strnstr(buffer, units_str[unit][i], count);
+ if (end) {
+ for (; i >= 0; i--)
+ blk_size *= coeff[unit];
+ len = end - buffer;
break;
}
+ } while (i--);
- /* any chars after our unit indicates a malformed string */
- if (hit_unit)
- return -EINVAL;
-
- /* ensure we only hit one decimal */
- if (*buffer == '.') {
- if (hit_decimal)
- return -EINVAL;
-
- /* if past start, there's a whole part */
- if (start != buffer)
- *whole = start;
-
- *buffer = '\0';
- start = buffer + 1;
- hit_decimal = true;
- } else if (!isdigit(*buffer) &&
- !(*base == 16 && isxdigit(*buffer))) {
- if (allow_units) {
- /* if we allow units, attempt to get mult */
- hit_unit = true;
- rc = get_mult(*buffer, mult);
- if (rc)
- return rc;
-
- /* string stops here, but keep processing */
- *buffer = '\0';
- } else {
- /* bad string */
+ /* 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 = strnchr(buffer, count, 'B');
+ if (end) {
+ len = end - buffer;
+
+ if (count - len > 2 ||
+ (count - len == 2 && strcmp(end, "B\n") != 0)) {
+ CDEBUG(D_INFO, "unknown suffix '%s'\n", buffer);
return -EINVAL;
}
}
-
- buffer++;
+ /* kstrtoull will error out if it has non digits */
+ goto numbers_only;
}
- if (hit_decimal) {
- /* hit a decimal, make sure there's a fractional part */
- if (!*start)
- return -EINVAL;
-
- *frac = start;
- } else {
- /* didn't hit a decimal, but may have a whole part */
- if (start != buffer && *start)
- *whole = start;
- }
-
- /* malformed string if we didn't get anything */
- if (!*frac && !*whole)
- return -EINVAL;
-
- return 0;
-}
-
-/*
- * Parses a numeric string which can contain a whole and fraction portion
- * into a __u64. Accepts a multiplier to apply to the value parsed. Also
- * allows the string to have a unit at the end. The function handles
- * wrapping of the final unsigned value.
- */
-static int str_to_u64_parse(char *buffer, unsigned long count,
- __u64 *val, __u64 def_mult, bool allow_units)
-{
- __u64 whole = 0;
- __u64 frac = 0;
- unsigned int frac_d = 1;
- __u64 wrap_indicator = ULLONG_MAX;
- int rc = 0;
- __u64 mult;
- char *strwhole;
- char *strfrac;
- unsigned int base = 10;
-
- rc = preprocess_numeric_str(buffer, &mult, def_mult, allow_units,
- &strwhole, &strfrac, &base);
+ end = strnchr(buffer, count, '.');
+ if (end) {
+ /* need to limit 3 decimal places */
+ char rem[4] = "000";
+ u64 frac = 0;
+ size_t off;
- if (rc)
- return rc;
+ len = end - buffer;
+ end++;
- if (mult == 0) {
- *val = 0;
- return 0;
- }
-
- /* the multiplier limits how large the value can be */
- wrap_indicator /= mult;
-
- if (strwhole) {
- rc = kstrtoull(strwhole, base, &whole);
+ /* 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 (whole > wrap_indicator)
- return -ERANGE;
-
- whole *= mult;
- }
-
- if (strfrac) {
- if (strlen(strfrac) > 10)
- strfrac[10] = '\0';
-
- rc = kstrtoull(strfrac, base, &frac);
- if (rc)
- return rc;
-
- /* determine power of fractional portion */
- while (*strfrac) {
- frac_d *= base;
- strfrac++;
- }
-
- /* fractional portion is too large to perform calculation */
- if (frac > wrap_indicator)
- return -ERANGE;
-
- frac *= mult;
- do_div(frac, frac_d);
- }
-
- /* check that the sum of whole and fraction fits in u64 */
- if (whole > (ULLONG_MAX - frac))
- return -ERANGE;
-
- *val = whole + frac;
-
- return 0;
-}
-
-/*
- * This function parses numeric/hex strings into __s64. It accepts a multiplier
- * which will apply to the value parsed. It also can allow the string to
- * 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)
-{
- char kernbuf[22];
- __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 (fls64(frac) + fls64(blk_size) - 1 > 64)
+ return -EOVERFLOW;
- /* keep track of our sign */
- if (*kernbuf == '-') {
- sign = -1;
- offset++;
- /* equivalent to max = -LLONG_MIN, avoids overflow */
- max++;
+ frac *= blk_size;
+ do_div(frac, 1000);
+ *size += frac;
}
-
- rc = str_to_u64_parse(kernbuf + offset, count - offset,
- &tmp, def_mult, allow_units);
+numbers_only:
+ snprintf(kernbuf, sizeof(kernbuf), "%.*s", (int)len, buffer);
+ rc = kstrtoull(kernbuf, 10, &whole);
if (rc)
return rc;
- /* check for overflow/underflow */
- if (max < tmp)
- return -ERANGE;
+ if (whole != 0 && fls64(whole) + fls64(blk_size) - 1 > 64)
+ return -EOVERFLOW;
- *val = (__s64)tmp * sign;
+ *size += whole * blk_size;
- return 0;
+ return count;
}
+EXPORT_SYMBOL(string_to_size);
/**
- * 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
- * specified in the string, the multiplier provided by the caller is ignored.
- * This function can also accept hexadecimal strings which are prefixed with
- * "0x".
+ * 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
*
- * \param[in] buffer string consisting of numbers, a decimal, and a unit
- * \param[in] count buffer length
- * \param[in] val if successful, the value represented by the string
- * \param[in] defunit default unit if string doesn't contain one
+ * 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.
*
- * \retval 0 on success
- * \retval negative number on error
+ * Returns: 0 on success or -errno on failure.
*/
-int lprocfs_str_with_units_to_s64(const char __user *buffer,
- unsigned long count, __s64 *val, char defunit)
+int sysfs_memparse(const char *buffer, size_t count, u64 *val,
+ const char *defunit)
{
- __u64 mult = 1;
+ const char *param = buffer;
+ char tmp_buf[23];
int rc;
- if (defunit != '1') {
- rc = get_mult(defunit, &mult);
- if (rc)
- return rc;
+ count = strlen(buffer);
+ while (count > 0 && isspace(buffer[count - 1]))
+ count--;
+
+ if (!count)
+ RETURN(-EINVAL);
+
+ /* 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);
+ }
+
+ scnprintf(tmp_buf, sizeof(tmp_buf), "%.*s%s", (int)count,
+ buffer, defunit);
+ param = tmp_buf;
+ count = strlen(param);
}
- return str_to_s64_internal(buffer, count, val, mult, true);
+ rc = string_to_size(val, param, count);
+
+ return rc < 0 ? rc : 0;
}
-EXPORT_SYMBOL(lprocfs_str_with_units_to_s64);
+EXPORT_SYMBOL(sysfs_memparse);
-static char *lprocfs_strnstr(const char *s1, const char *s2, size_t len)
+char *lprocfs_strnstr(const char *s1, const char *s2, size_t len)
{
size_t l2;
}
return NULL;
}
+EXPORT_SYMBOL(lprocfs_strnstr);
/**
* Find the string \a name in the input \a buffer, and return a pointer to the
/* 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 */
}
EXPORT_SYMBOL(lprocfs_find_named_value);
-int ldebugfs_seq_create(struct dentry *parent, const char *name, umode_t mode,
- const struct file_operations *seq_fops, void *data)
-{
- struct dentry *entry;
-
- /* Disallow secretly (un)writable entries. */
- LASSERT((!seq_fops->write) == (!(mode & 0222)));
-
- entry = debugfs_create_file(name, mode, parent, data, seq_fops);
- if (IS_ERR_OR_NULL(entry))
- return entry ? PTR_ERR(entry) : -ENOMEM;
-
- return 0;
-}
-EXPORT_SYMBOL_GPL(ldebugfs_seq_create);
-
int lprocfs_seq_create(struct proc_dir_entry *parent,
const char *name,
mode_t mode,
- const struct file_operations *seq_fops,
+ const struct proc_ops *seq_fops,
void *data)
{
struct proc_dir_entry *entry;
ENTRY;
/* Disallow secretly (un)writable entries. */
- LASSERT((seq_fops->write == NULL) == ((mode & 0222) == 0));
+ LASSERT(!seq_fops->proc_write == !(mode & 0222));
entry = proc_create_data(name, mode, parent, seq_fops, data);
- if (entry == NULL)
+ if (!entry)
RETURN(-ENOMEM);
RETURN(0);
}
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,
+ const struct proc_ops *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);
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);
}
EXPORT_SYMBOL(lprocfs_oh_clear);
+void lprocfs_oh_tally_pcpu(struct obd_hist_pcpu *oh,
+ unsigned int value)
+{
+ if (value >= OBD_HIST_MAX)
+ value = OBD_HIST_MAX - 1;
+
+ percpu_counter_inc(&oh->oh_pc_buckets[value]);
+}
+EXPORT_SYMBOL(lprocfs_oh_tally_pcpu);
+
+void lprocfs_oh_tally_log2_pcpu(struct obd_hist_pcpu *oh,
+ unsigned int value)
+{
+ unsigned int val = 0;
+
+ if (likely(value != 0))
+ val = min(fls(value - 1), OBD_HIST_MAX);
+
+ lprocfs_oh_tally_pcpu(oh, val);
+}
+EXPORT_SYMBOL(lprocfs_oh_tally_log2_pcpu);
+
+unsigned long lprocfs_oh_counter_pcpu(struct obd_hist_pcpu *oh,
+ unsigned int value)
+{
+ return percpu_counter_sum(&oh->oh_pc_buckets[value]);
+}
+EXPORT_SYMBOL(lprocfs_oh_counter_pcpu);
+
+unsigned long lprocfs_oh_sum_pcpu(struct obd_hist_pcpu *oh)
+{
+ unsigned long ret = 0;
+ int i;
+
+ for (i = 0; i < OBD_HIST_MAX; i++)
+ ret += percpu_counter_sum(&oh->oh_pc_buckets[i]);
+
+ return ret;
+}
+EXPORT_SYMBOL(lprocfs_oh_sum_pcpu);
+
+int lprocfs_oh_alloc_pcpu(struct obd_hist_pcpu *oh)
+{
+ int i, rc;
+
+ if (oh->oh_initialized)
+ return 0;
+
+ for (i = 0; i < OBD_HIST_MAX; i++) {
+ rc = percpu_counter_init(&oh->oh_pc_buckets[i], 0, GFP_KERNEL);
+ if (rc)
+ goto out;
+ }
+
+ oh->oh_initialized = true;
+
+ return 0;
+
+out:
+ for (i--; i >= 0; i--)
+ percpu_counter_destroy(&oh->oh_pc_buckets[i]);
+
+ return rc;
+}
+EXPORT_SYMBOL(lprocfs_oh_alloc_pcpu);
+
+void lprocfs_oh_clear_pcpu(struct obd_hist_pcpu *oh)
+{
+ int i;
+
+ for (i = 0; i < OBD_HIST_MAX; i++)
+ percpu_counter_set(&oh->oh_pc_buckets[i], 0);
+}
+EXPORT_SYMBOL(lprocfs_oh_clear_pcpu);
+
+void lprocfs_oh_release_pcpu(struct obd_hist_pcpu *oh)
+{
+ int i;
+
+ if (!oh->oh_initialized)
+ return;
+
+ for (i = 0; i < OBD_HIST_MAX; i++)
+ percpu_counter_destroy(&oh->oh_pc_buckets[i]);
+
+ oh->oh_initialized = false;
+}
+EXPORT_SYMBOL(lprocfs_oh_release_pcpu);
+
ssize_t lustre_attr_show(struct kobject *kobj,
struct attribute *attr, char *buf)
{
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);
const char __user *buffer,
size_t count, loff_t *off)
{
- struct obd_device *dev =
- ((struct seq_file *)file->private_data)->private;
- struct client_obd *cli = &dev->u.cli;
- struct obd_connect_data *ocd = &cli->cl_import->imp_connect_data;
+ struct seq_file *m = file->private_data;
+ 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;
- LPROCFS_CLIMP_CHECK(dev);
-
- chunk_mask = ~((1 << (cli->cl_chunkbits - PAGE_SHIFT)) - 1);
- /* max_pages_per_rpc must be chunk aligned */
- val = (val + ~chunk_mask) & chunk_mask;
- if (val == 0 || (ocd->ocd_brw_size != 0 &&
- val > ocd->ocd_brw_size >> PAGE_SHIFT)) {
- LPROCFS_CLIMP_EXIT(dev);
- return -ERANGE;
+ 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 */
+ val = (val + ~chunk_mask) & chunk_mask;
+ if (val == 0 || (ocd->ocd_brw_size != 0 &&
+ val > ocd->ocd_brw_size >> PAGE_SHIFT)) {
+ rc = -ERANGE;
+ } else {
+ spin_lock(&cli->cl_loi_list_lock);
+ cli->cl_max_pages_per_rpc = val;
+ client_adjust_max_dirty(cli);
+ spin_unlock(&cli->cl_loi_list_lock);
+ }
}
- spin_lock(&cli->cl_loi_list_lock);
- cli->cl_max_pages_per_rpc = val;
- client_adjust_max_dirty(cli);
- spin_unlock(&cli->cl_loi_list_lock);
- LPROCFS_CLIMP_EXIT(dev);
- return count;
+ return rc ?: count;
}
EXPORT_SYMBOL(lprocfs_obd_max_pages_per_rpc_seq_write);
-int lprocfs_obd_short_io_bytes_seq_show(struct seq_file *m, void *data)
+ssize_t short_io_bytes_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
{
- struct obd_device *dev = data;
- struct client_obd *cli = &dev->u.cli;
+ struct obd_device *obd = container_of(kobj, struct obd_device,
+ obd_kset.kobj);
+ struct client_obd *cli = &obd->u.cli;
+ int rc;
spin_lock(&cli->cl_loi_list_lock);
- seq_printf(m, "%d\n", cli->cl_short_io_bytes);
+ rc = sprintf(buf, "%d\n", cli->cl_max_short_io_bytes);
spin_unlock(&cli->cl_loi_list_lock);
- return 0;
+ return rc;
}
-EXPORT_SYMBOL(lprocfs_obd_short_io_bytes_seq_show);
+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 lprocfs_obd_short_io_bytes_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+ssize_t short_io_bytes_store(struct kobject *kobj, struct attribute *attr,
+ const char *buffer, size_t count)
{
- struct obd_device *dev = ((struct seq_file *)
- file->private_data)->private;
- struct client_obd *cli = &dev->u.cli;
- int val;
+ struct obd_device *obd = container_of(kobj, struct obd_device,
+ obd_kset.kobj);
+ struct client_obd *cli = &obd->u.cli;
+ u64 val;
int rc;
- LPROCFS_CLIMP_CHECK(dev);
-
- rc = kstrtoint_from_user(buffer, count, 0, &val);
- if (rc)
- GOTO(out, rc);
+ 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 < MIN_SHORT_IO_BYTES || val > OBD_MAX_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_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:
- LPROCFS_CLIMP_EXIT(dev);
return rc;
}
-EXPORT_SYMBOL(lprocfs_obd_short_io_bytes_seq_write);
+EXPORT_SYMBOL(short_io_bytes_store);
int lprocfs_wr_root_squash(const char __user *buffer, unsigned long count,
struct root_squash_info *squash, char *name)
/* look for uid gid separator */
tmp = strchr(kernbuf, ':');
- if (tmp == NULL) {
+ if (!tmp) {
errmsg = "needs uid:gid format";
GOTO(failed, rc = -EINVAL);
}
RETURN(count);
failed:
- if (tmp != NULL) {
+ if (tmp) {
tmp--;
*tmp = ':';
}
int rc;
char *kernbuf = NULL;
char *errmsg;
- struct list_head tmp;
+ LIST_HEAD(tmp);
int len = count;
ENTRY;
}
OBD_ALLOC(kernbuf, count + 1);
- if (kernbuf == NULL) {
+ if (!kernbuf) {
errmsg = "no memory";
GOTO(failed, rc = -ENOMEM);
}
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) {
+ if (cfs_parse_nidlist(kernbuf, &tmp) < 0) {
errmsg = "can't parse";
GOTO(failed, rc = -EINVAL);
}
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);