* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2014, 2015, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
int lprocfs_evict_client_open(struct inode *inode, struct file *f)
{
- struct obd_device *obd = PDE_DATA(f->f_dentry->d_inode);
+ struct obd_device *obd = PDE_DATA(f->f_path.dentry->d_inode);
atomic_inc(&obd->obd_evict_inprogress);
return 0;
int lprocfs_evict_client_release(struct inode *inode, struct file *f)
{
- struct obd_device *obd = PDE_DATA(f->f_dentry->d_inode);
+ struct obd_device *obd = PDE_DATA(f->f_path.dentry->d_inode);
atomic_dec(&obd->obd_evict_inprogress);
wake_up(&obd->obd_evict_inprogress_waitq);
#define BUFLEN (UUID_MAX + 5)
ssize_t
-lprocfs_evict_client_seq_write(struct file *file, const char *buffer,
+lprocfs_evict_client_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct obd_device *obd = data;
LASSERT(obd != NULL);
- return seq_printf(m, "%u\n", obd->obd_num_exports);
+ seq_printf(m, "%u\n", obd->obd_num_exports);
+ return 0;
}
EXPORT_SYMBOL(lprocfs_num_exports_seq_show);
void lprocfs_free_per_client_stats(struct obd_device *obd)
{
- cfs_hash_t *hash = obd->obd_nid_stats_hash;
+ struct cfs_hash *hash = obd->obd_nid_stats_hash;
struct nid_stat *stat;
ENTRY;
}
EXPORT_SYMBOL(lprocfs_free_per_client_stats);
-int lprocfs_exp_nid_seq_show(struct seq_file *m, void *data)
-{
- struct obd_export *exp = m->private;
- LASSERT(exp != NULL);
- return seq_printf(m, "%s\n", obd_export_nid2str(exp));
-}
-
-static int lprocfs_exp_print_uuid_seq(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- struct hlist_node *hnode, void *cb_data)
-
+static int
+lprocfs_exp_print_uuid_seq(struct cfs_hash *hs, struct cfs_hash_bd *bd,
+ struct hlist_node *hnode, void *cb_data)
{
struct seq_file *m = cb_data;
struct obd_export *exp = cfs_hash_object(hs, hnode);
return 0;
}
-static int lprocfs_exp_print_nodemap_seq(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- struct hlist_node *hnode, void *cb_data)
+static int
+lprocfs_exp_print_nodemap_seq(struct cfs_hash *hs, struct cfs_hash_bd *bd,
+ struct hlist_node *hnode, void *cb_data)
{
struct seq_file *m = cb_data;
struct obd_export *exp = cfs_hash_object(hs, hnode);
return 0;
}
-static int lprocfs_exp_nodemap_seq_show(struct seq_file *m, void *data)
+static int
+lprocfs_exp_nodemap_seq_show(struct seq_file *m, void *data)
{
struct nid_stat *stats = m->private;
struct obd_device *obd = stats->nid_obd;
}
LPROC_SEQ_FOPS_RO(lprocfs_exp_uuid);
-static int lprocfs_exp_print_hash_seq(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- struct hlist_node *hnode, void *cb_data)
+static int
+lprocfs_exp_print_hash_seq(struct cfs_hash *hs, struct cfs_hash_bd *bd,
+ struct hlist_node *hnode, void *cb_data)
{
struct seq_file *m = cb_data;
}
LPROC_SEQ_FOPS_RO(lprocfs_exp_hash);
+int lprocfs_exp_print_replydata_seq(struct cfs_hash *hs, struct cfs_hash_bd *bd,
+ struct hlist_node *hnode, void *cb_data)
+
+{
+ struct obd_export *exp = cfs_hash_object(hs, hnode);
+ struct seq_file *m = cb_data;
+ struct tg_export_data *ted = &exp->exp_target_data;
+
+ seq_printf(m, "reply_cnt: %d\n"
+ "reply_max: %d\n"
+ "reply_released_by_xid: %d\n"
+ "reply_released_by_tag: %d\n\n",
+ ted->ted_reply_cnt,
+ ted->ted_reply_max,
+ ted->ted_release_xid,
+ ted->ted_release_tag);
+ return 0;
+}
+
+int lprocfs_exp_replydata_seq_show(struct seq_file *m, void *data)
+{
+ struct nid_stat *stats = m->private;
+ struct obd_device *obd = stats->nid_obd;
+
+ cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
+ lprocfs_exp_print_replydata_seq, m);
+ return 0;
+}
+LPROC_SEQ_FOPS_RO(lprocfs_exp_replydata);
+
int lprocfs_nid_stats_clear_seq_show(struct seq_file *m, void *data)
{
- return seq_printf(m, "%s\n", "Write into this file to clear all nid "
- "stats and stale nid entries");
+ seq_puts(m, "Write into this file to clear all nid stats and stale nid entries\n");
+ return 0;
}
EXPORT_SYMBOL(lprocfs_nid_stats_clear_seq_show);
}
ssize_t
-lprocfs_nid_stats_clear_seq_write(struct file *file, const char *buffer,
+lprocfs_nid_stats_clear_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct nid_stat *new_stat, *old_stat;
struct obd_device *obd = NULL;
struct proc_dir_entry *entry;
- char *buffer = NULL;
+ char nidstr[LNET_NIDSTR_SIZE];
int rc = 0;
ENTRY;
if (nid == NULL || *nid == LNET_NID_ANY)
RETURN(-EALREADY);
+ libcfs_nid2str_r(*nid, nidstr, sizeof(nidstr));
+
spin_lock(&exp->exp_lock);
if (exp->exp_nid_stats != NULL) {
spin_unlock(&exp->exp_lock);
old_stat = cfs_hash_findadd_unique(obd->obd_nid_stats_hash,
nid, &new_stat->nid_hash);
CDEBUG(D_INFO, "Found stats %p for nid %s - ref %d\n",
- old_stat, libcfs_nid2str(*nid),
- atomic_read(&new_stat->nid_exp_ref_count));
+ old_stat, nidstr, atomic_read(&old_stat->nid_exp_ref_count));
/* Return -EALREADY here so that we know that the /proc
* entry already has been created */
GOTO(destroy_new, rc = -EALREADY);
}
/* not found - create */
- OBD_ALLOC(buffer, LNET_NIDSTR_SIZE);
- if (buffer == NULL)
- GOTO(destroy_new, rc = -ENOMEM);
-
- memcpy(buffer, libcfs_nid2str(*nid), LNET_NIDSTR_SIZE);
- new_stat->nid_proc = lprocfs_seq_register(buffer,
- obd->obd_proc_exports_entry,
- NULL, NULL);
- OBD_FREE(buffer, LNET_NIDSTR_SIZE);
+ new_stat->nid_proc = lprocfs_register(nidstr,
+ obd->obd_proc_exports_entry,
+ NULL, NULL);
if (IS_ERR(new_stat->nid_proc)) {
rc = PTR_ERR(new_stat->nid_proc);
new_stat->nid_proc = NULL;
CERROR("%s: cannot create proc entry for export %s: rc = %d\n",
- obd->obd_name, libcfs_nid2str(*nid), rc);
+ obd->obd_name, nidstr, rc);
GOTO(destroy_new_ns, rc);
}
GOTO(destroy_new_ns, rc);
}
+ entry = lprocfs_add_simple(new_stat->nid_proc, "reply_data", new_stat,
+ &lprocfs_exp_replydata_fops);
+ if (IS_ERR(entry)) {
+ rc = PTR_ERR(entry);
+ CWARN("%s: Error adding the reply_data file: rc = %d\n",
+ obd->obd_name, rc);
+ GOTO(destroy_new_ns, rc);
+ }
+
spin_lock(&exp->exp_lock);
exp->exp_nid_stats = new_stat;
spin_unlock(&exp->exp_lock);
return 0;
}
-EXPORT_SYMBOL(lprocfs_exp_cleanup);
#define LPROCFS_OBD_OP_INIT(base, stats, op) \
do { \
LPROCFS_OBD_OP_INIT(num_private_stats, stats, fid_alloc);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, statfs);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, statfs_async);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, packmd);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpackmd);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, create);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, setattr);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, setattr_async);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, getattr);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, getattr_async);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, preprw);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, commitrw);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, change_cbdata);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, find_cbdata);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, init_export);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy_export);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, import_event);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, notify);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, health_check);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, get_uuid);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, quotacheck);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, quotactl);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, ping);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_new);
int lprocfs_hash_seq_show(struct seq_file *m, void *data)
{
struct obd_device *obd = m->private;
- int c = 0;
if (obd == NULL)
return 0;
- c += cfs_hash_debug_header(m);
- c += cfs_hash_debug_str(obd->obd_uuid_hash, m);
- c += cfs_hash_debug_str(obd->obd_nid_hash, m);
- c += cfs_hash_debug_str(obd->obd_nid_stats_hash, m);
- return c;
+ cfs_hash_debug_header(m);
+ cfs_hash_debug_str(obd->obd_uuid_hash, m);
+ cfs_hash_debug_str(obd->obd_nid_hash, m);
+ cfs_hash_debug_str(obd->obd_nid_stats_hash, m);
+ return 0;
}
EXPORT_SYMBOL(lprocfs_hash_seq_show);
seq_printf(m, "COMPLETE\n");
seq_printf(m, "recovery_start: %lu\n", obd->obd_recovery_start);
seq_printf(m, "recovery_duration: %lu\n",
- obd->obd_recovery_end - obd->obd_recovery_start);
+ obd->obd_recovery_end ?
+ obd->obd_recovery_end - obd->obd_recovery_start :
+ cfs_time_current_sec() - obd->obd_recovery_start);
/* Number of clients that have completed recovery */
seq_printf(m, "completed_clients: %d/%d\n",
obd->obd_max_recoverable_clients -
struct obd_device *obd = m->private;
LASSERT(obd != NULL);
- return seq_printf(m, "%d\n", obd->obd_recovery_ir_factor);
+ seq_printf(m, "%d\n", obd->obd_recovery_ir_factor);
+ return 0;
}
EXPORT_SYMBOL(lprocfs_ir_factor_seq_show);
ssize_t
-lprocfs_ir_factor_seq_write(struct file *file, const char *buffer,
+lprocfs_ir_factor_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
- int val, rc;
+ int rc;
+ __s64 val;
LASSERT(obd != NULL);
- rc = lprocfs_write_helper(buffer, count, &val);
+ rc = lprocfs_str_to_s64(buffer, count, &val);
if (rc)
return rc;
struct obd_device *obd = m->private;
LASSERT(obd != NULL);
- return seq_printf(m, "%d\n", obd->obd_recovery_timeout);
+ seq_printf(m, "%d\n", obd->obd_recovery_timeout);
+ return 0;
}
EXPORT_SYMBOL(lprocfs_recovery_time_soft_seq_show);
ssize_t
-lprocfs_recovery_time_soft_seq_write(struct file *file, const char *buffer,
- size_t count, loff_t *off)
+lprocfs_recovery_time_soft_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
- int val, rc;
+ int rc;
+ __s64 val;
LASSERT(obd != NULL);
- rc = lprocfs_write_helper(buffer, count, &val);
+ rc = lprocfs_str_to_s64(buffer, count, &val);
if (rc)
return rc;
+ if (val < 0 || val > INT_MAX)
+ return -ERANGE;
obd->obd_recovery_timeout = val;
return count;
struct obd_device *obd = m->private;
LASSERT(obd != NULL);
- return seq_printf(m, "%u\n", obd->obd_recovery_time_hard);
+ seq_printf(m, "%u\n", obd->obd_recovery_time_hard);
+ return 0;
}
EXPORT_SYMBOL(lprocfs_recovery_time_hard_seq_show);
ssize_t
-lprocfs_recovery_time_hard_seq_write(struct file *file, const char *buffer,
+lprocfs_recovery_time_hard_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct obd_device *obd = m->private;
- int val, rc;
+ int rc;
+ __s64 val;
LASSERT(obd != NULL);
- rc = lprocfs_write_helper(buffer, count, &val);
+ rc = lprocfs_str_to_s64(buffer, count, &val);
if (rc)
return rc;
+ if (val < 0 || val > INT_MAX)
+ return -ERANGE;
obd->obd_recovery_time_hard = val;
return count;
LASSERT(obd != NULL);
LASSERT(target->obt_magic == OBT_MAGIC);
- return seq_printf(m, "%u\n", obd->u.obt.obt_instance);
+ seq_printf(m, "%u\n", obd->u.obt.obt_instance);
+ return 0;
}
EXPORT_SYMBOL(lprocfs_target_instance_seq_show);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff