}
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);
{
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);
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);
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;
- LASSERT(obd != NULL);
- LPROCFS_CLIMP_CHECK(obd);
- imp = obd->u.cli.cl_import;
ocd = &imp->imp_connect_data;
seq_printf(m, "import:\n"
spin_unlock(&imp->imp_lock);
if (!obd->obd_svc_stats)
- goto out_climp;
+ return;
header = &obd->obd_svc_stats->ls_cnt_header[PTLRPC_REQWAIT_CNTR];
lprocfs_stats_collect(obd->obd_svc_stats, PTLRPC_REQWAIT_CNTR, &ret);
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;
int i;
LASSERT(obd != NULL);
- LPROCFS_CLIMP_CHECK(obd);
- imp = obd->u.cli.cl_import;
now = ktime_get_real_seconds();
(s64)(now - worstt));
lprocfs_at_hist_helper(m, &imp->imp_at.iat_service_estimate[i]);
}
+}
- 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);
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;
const char __user *buffer,
size_t count, loff_t *off)
{
- struct obd_device *dev =
- ((struct seq_file *)file->private_data)->private;
+ struct seq_file *m = file->private_data;
+ struct obd_device *dev = m->private;
struct client_obd *cli = &dev->u.cli;
- struct obd_connect_data *ocd = &cli->cl_import->imp_connect_data;
+ struct obd_import *imp;
+ struct obd_connect_data *ocd;
int chunk_mask, rc;
- s64 val;
+ char kernbuf[22];
+ u64 val;
+
+ if (count > sizeof(kernbuf) - 1)
+ return -EINVAL;
+
+ if (copy_from_user(kernbuf, buffer, count))
+ return -EFAULT;
- rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1');
+ 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(dev, 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);
struct obd_device *dev = container_of(kobj, struct obd_device,
obd_kset.kobj);
struct client_obd *cli = &dev->u.cli;
- char kernbuf[32];
- s64 val;
+ u64 val;
int rc;
- if (count >= sizeof(kernbuf))
- return -EINVAL;
-
- LPROCFS_CLIMP_CHECK(dev);
-
- 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);
spin_unlock(&cli->cl_loi_list_lock);
out:
- LPROCFS_CLIMP_EXIT(dev);
return rc;
}
EXPORT_SYMBOL(short_io_bytes_store);
int rc;
char *kernbuf = NULL;
char *errmsg;
- struct list_head tmp;
+ LIST_HEAD(tmp);
int len = count;
ENTRY;
RETURN(count);
}
- INIT_LIST_HEAD(&tmp);
if (cfs_parse_nidlist(kernbuf, count, &tmp) <= 0) {
errmsg = "can't parse";
GOTO(failed, rc = -EINVAL);