*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
*
* GPL HEADER END
*/
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include <lprocfs_status.h>
#include "fid_internal.h"
-#ifdef CONFIG_PROC_FS
-
/* Format: [0x64BIT_INT - 0x64BIT_INT] + 32 bytes just in case */
#define MAX_FID_RANGE_STRLEN (32 + 2 * 2 * sizeof(__u64))
/**
* safe for production use.
*/
static int
-lprocfs_fid_write_common(const char __user *buffer, size_t count,
- struct lu_seq_range *range)
+ldebugfs_fid_write_common(const char __user *buffer, size_t count,
+ struct lu_seq_range *range)
{
- struct lu_seq_range tmp = { 0, };
- int rc;
char kernbuf[MAX_FID_RANGE_STRLEN];
- ENTRY;
+ struct lu_seq_range tmp = {
+ .lsr_start = 0,
+ };
+ int rc;
- LASSERT(range != NULL);
+ ENTRY;
+ LASSERT(range);
if (count >= sizeof(kernbuf))
RETURN(-EINVAL);
if (count == 5 && strcmp(kernbuf, "clear") == 0) {
memset(range, 0, sizeof(*range));
- RETURN(0);
+ RETURN(count);
}
/* of the form "[0x0000000240000400 - 0x000000028000400]" */
rc = sscanf(kernbuf, "[%llx - %llx]\n",
- (long long unsigned *)&tmp.lsr_start,
- (long long unsigned *)&tmp.lsr_end);
- if (!range_is_sane(&tmp) || range_is_zero(&tmp) ||
+ (unsigned long long *)&tmp.lsr_start,
+ (unsigned long long *)&tmp.lsr_end);
+ if (rc != 2)
+ RETURN(-EINVAL);
+ if (!lu_seq_range_is_sane(&tmp) || lu_seq_range_is_zero(&tmp) ||
tmp.lsr_start < range->lsr_start || tmp.lsr_end > range->lsr_end)
RETURN(-EINVAL);
*range = tmp;
#ifdef HAVE_SERVER_SUPPORT
/*
- * Server side procfs stuff.
+ * Server side debugfs stuff.
*/
static ssize_t
-lprocfs_server_fid_space_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+ldebugfs_server_fid_space_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
+ struct lu_server_seq *seq;
int rc;
- ENTRY;
- LASSERT(seq != NULL);
+ ENTRY;
+ seq = ((struct seq_file *)file->private_data)->private;
mutex_lock(&seq->lss_mutex);
- rc = lprocfs_fid_write_common(buffer, count, &seq->lss_space);
+ rc = ldebugfs_fid_write_common(buffer, count, &seq->lss_space);
if (rc == 0) {
- CDEBUG(D_INFO, "%s: Space: "DRANGE"\n",
- seq->lss_name, PRANGE(&seq->lss_space));
+ CDEBUG(D_INFO, "%s: Space: " DRANGE "\n",
+ seq->lss_name, PRANGE(&seq->lss_space));
}
mutex_unlock(&seq->lss_mutex);
}
static int
-lprocfs_server_fid_space_seq_show(struct seq_file *m, void *unused)
+ldebugfs_server_fid_space_seq_show(struct seq_file *m, void *unused)
{
struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
- int rc;
ENTRY;
- LASSERT(seq != NULL);
-
mutex_lock(&seq->lss_mutex);
- rc = seq_printf(m, "["LPX64" - "LPX64"]:%x:%s\n",
- PRANGE(&seq->lss_space));
+ seq_printf(m, "[%#llx - %#llx]:%x:%s\n", PRANGE(&seq->lss_space));
mutex_unlock(&seq->lss_mutex);
- RETURN(rc);
+ RETURN(0);
}
static int
-lprocfs_server_fid_server_seq_show(struct seq_file *m, void *unused)
+ldebugfs_server_fid_server_seq_show(struct seq_file *m, void *unused)
{
struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
struct client_obd *cli;
- int rc;
ENTRY;
- LASSERT(seq != NULL);
-
if (seq->lss_cli) {
if (seq->lss_cli->lcs_exp != NULL) {
cli = &seq->lss_cli->lcs_exp->exp_obd->u.cli;
- rc = seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
+ seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
} else {
- rc = seq_printf(m, "%s\n",
- seq->lss_cli->lcs_srv->lss_name);
+ seq_printf(m, "%s\n", seq->lss_cli->lcs_srv->lss_name);
}
} else {
- rc = seq_printf(m, "<none>\n");
+ seq_puts(m, "<none>\n");
}
- RETURN(rc);
+ RETURN(0);
}
-static ssize_t
-lprocfs_server_fid_width_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t ldebugfs_server_fid_width_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
- int rc, val;
- ENTRY;
-
- LASSERT(seq != NULL);
+ struct seq_file *m = file->private_data;
+ struct lu_server_seq *seq = m->private;
+ int rc;
+ ENTRY;
mutex_lock(&seq->lss_mutex);
- rc = lprocfs_write_helper(buffer, count, &val);
- if (rc != 0) {
- CERROR("%s: invalid width.\n", seq->lss_name);
+ rc = kstrtoull_from_user(buffer, count, 0, &seq->lss_width);
+ if (rc) {
+ CERROR("%s: invalid FID sequence width: rc = %d\n",
+ seq->lss_name, rc);
GOTO(out_unlock, count = rc);
}
- seq->lss_width = val;
-
- CDEBUG(D_INFO, "%s: Width: "LPU64"\n",
+ CDEBUG(D_INFO, "%s: Width: %llu\n",
seq->lss_name, seq->lss_width);
out_unlock:
mutex_unlock(&seq->lss_mutex);
}
static int
-lprocfs_server_fid_width_seq_show(struct seq_file *m, void *unused)
+ldebugfs_server_fid_width_seq_show(struct seq_file *m, void *unused)
{
struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
- int rc;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lss_mutex);
- rc = seq_printf(m, LPU64"\n", seq->lss_width);
+ seq_printf(m, "%llu\n", seq->lss_width);
mutex_unlock(&seq->lss_mutex);
- RETURN(rc);
+ RETURN(0);
}
-LPROC_SEQ_FOPS(lprocfs_server_fid_space);
-LPROC_SEQ_FOPS(lprocfs_server_fid_width);
-LPROC_SEQ_FOPS_RO(lprocfs_server_fid_server);
+LDEBUGFS_SEQ_FOPS(ldebugfs_server_fid_space);
+LDEBUGFS_SEQ_FOPS(ldebugfs_server_fid_width);
+LDEBUGFS_SEQ_FOPS_RO(ldebugfs_server_fid_server);
-struct lprocfs_seq_vars seq_server_proc_list[] = {
+struct lprocfs_vars seq_server_debugfs_list[] = {
{ .name = "space",
- .fops = &lprocfs_server_fid_space_fops },
+ .fops = &ldebugfs_server_fid_space_fops },
{ .name = "width",
- .fops = &lprocfs_server_fid_width_fops },
+ .fops = &ldebugfs_server_fid_width_fops },
{ .name = "server",
- .fops = &lprocfs_server_fid_server_fops },
+ .fops = &ldebugfs_server_fid_server_fops},
{ NULL }
};
fld->lsf_name, rc);
} else if (fld_rec.lsr_start != 0) {
range_be_to_cpu(&fld_rec, &fld_rec);
- rc = seq_printf(p, DRANGE"\n", PRANGE(&fld_rec));
+ seq_printf(p, DRANGE"\n", PRANGE(&fld_rec));
}
return rc;
static int fldb_seq_open(struct inode *inode, struct file *file)
{
struct seq_file *seq;
- struct lu_server_seq *ss = (struct lu_server_seq *) PDE_DATA(inode);
+ struct lu_server_seq *ss = inode->i_private;
struct lu_server_fld *fld;
struct dt_object *obj;
const struct dt_it_ops *iops;
fld = ss->lss_site->ss_server_fld;
LASSERT(fld != NULL);
- rc = LPROCFS_ENTRY_CHECK(inode);
- if (rc < 0)
- return rc;
-
rc = seq_open(file, &fldb_sops);
if (rc)
return rc;
env_init = 1;
iops = &obj->do_index_ops->dio_it;
- param->fsp_it = iops->init(¶m->fsp_env, obj, 0, NULL);
+ param->fsp_it = iops->init(¶m->fsp_env, obj, 0);
if (IS_ERR(param->fsp_it))
GOTO(out, rc = PTR_ERR(param->fsp_it));
param = seq->private;
if (param == NULL) {
- lprocfs_seq_release(inode, file);
+ seq_release(inode, file);
return 0;
}
iops->fini(¶m->fsp_env, param->fsp_it);
lu_env_fini(¶m->fsp_env);
OBD_FREE_PTR(param);
- lprocfs_seq_release(inode, file);
+ seq_release(inode, file);
return 0;
}
RETURN(rc < 0 ? rc : len);
}
-const struct file_operations seq_fld_proc_seq_fops = {
+const struct file_operations seq_fld_debugfs_seq_fops = {
.owner = THIS_MODULE,
.open = fldb_seq_open,
.read = seq_read,
#endif /* HAVE_SERVER_SUPPORT */
-/* Client side procfs stuff */
+/* Client side debugfs stuff */
static ssize_t
-lprocfs_client_fid_space_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+ldebugfs_client_fid_space_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
+ struct lu_client_seq *seq;
int rc;
- ENTRY;
- LASSERT(seq != NULL);
+ ENTRY;
+ seq = ((struct seq_file *)file->private_data)->private;
mutex_lock(&seq->lcs_mutex);
- rc = lprocfs_fid_write_common(buffer, count, &seq->lcs_space);
+ rc = ldebugfs_fid_write_common(buffer, count, &seq->lcs_space);
if (rc == 0) {
- CDEBUG(D_INFO, "%s: Space: "DRANGE"\n",
+ CDEBUG(D_INFO, "%s: Space: " DRANGE "\n",
seq->lcs_name, PRANGE(&seq->lcs_space));
}
RETURN(count);
}
-static int
-lprocfs_client_fid_space_seq_show(struct seq_file *m, void *unused)
+static int ldebugfs_client_fid_space_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
- int rc;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lcs_mutex);
- rc = seq_printf(m, "["LPX64" - "LPX64"]:%x:%s\n",
- PRANGE(&seq->lcs_space));
+ seq_printf(m, "[%#llx - %#llx]:%x:%s\n", PRANGE(&seq->lcs_space));
mutex_unlock(&seq->lcs_mutex);
- RETURN(rc);
+ RETURN(0);
}
-static ssize_t
-lprocfs_client_fid_width_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t ldebugfs_client_fid_width_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
- __u64 max;
- int rc, val;
- ENTRY;
+ struct seq_file *m = file->private_data;
+ struct lu_client_seq *seq = m->private;
+ u64 val;
+ u64 max;
+ int rc;
- LASSERT(seq != NULL);
+ ENTRY;
+ rc = kstrtoull_from_user(buffer, count, 0, &val);
+ if (rc)
+ return rc;
mutex_lock(&seq->lcs_mutex);
-
- rc = lprocfs_write_helper(buffer, count, &val);
- if (rc) {
- mutex_unlock(&seq->lcs_mutex);
- RETURN(rc);
- }
-
if (seq->lcs_type == LUSTRE_SEQ_DATA)
max = LUSTRE_DATA_SEQ_MAX_WIDTH;
else
max = LUSTRE_METADATA_SEQ_MAX_WIDTH;
- if (val <= max && val > 0) {
+ if (val <= max) {
seq->lcs_width = val;
- if (rc == 0) {
- CDEBUG(D_INFO, "%s: Sequence size: "LPU64"\n",
- seq->lcs_name, seq->lcs_width);
- }
+ CDEBUG(D_INFO, "%s: Sequence size: %llu\n", seq->lcs_name,
+ seq->lcs_width);
+ } else {
+ count = -ERANGE;
}
- mutex_unlock(&seq->lcs_mutex);
+ mutex_unlock(&seq->lcs_mutex);
RETURN(count);
}
static int
-lprocfs_client_fid_width_seq_show(struct seq_file *m, void *unused)
+ldebugfs_client_fid_width_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
- int rc;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lcs_mutex);
- rc = seq_printf(m, LPU64"\n", seq->lcs_width);
+ seq_printf(m, "%llu\n", seq->lcs_width);
mutex_unlock(&seq->lcs_mutex);
- RETURN(rc);
+ RETURN(0);
}
static int
-lprocfs_client_fid_fid_seq_show(struct seq_file *m, void *unused)
+ldebugfs_client_fid_fid_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
- int rc;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lcs_mutex);
- rc = seq_printf(m, DFID"\n", PFID(&seq->lcs_fid));
+ seq_printf(m, DFID"\n", PFID(&seq->lcs_fid));
mutex_unlock(&seq->lcs_mutex);
- RETURN(rc);
+ RETURN(0);
}
static int
-lprocfs_client_fid_server_seq_show(struct seq_file *m, void *unused)
+ldebugfs_client_fid_server_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
struct client_obd *cli;
- int rc;
ENTRY;
- LASSERT(seq != NULL);
-
- if (seq->lcs_exp != NULL) {
+ if (seq->lcs_exp) {
cli = &seq->lcs_exp->exp_obd->u.cli;
- rc = seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
+ seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
+#ifdef HAVE_SERVER_SUPPORT
} else {
- rc = seq_printf(m, "%s\n", seq->lcs_srv->lss_name);
+ seq_printf(m, "%s\n", seq->lcs_srv->lss_name);
+#endif /* HAVE_SERVER_SUPPORT */
}
- RETURN(rc);
+
+ RETURN(0);
}
-LPROC_SEQ_FOPS(lprocfs_client_fid_space);
-LPROC_SEQ_FOPS(lprocfs_client_fid_width);
-LPROC_SEQ_FOPS_RO(lprocfs_client_fid_server);
-LPROC_SEQ_FOPS_RO(lprocfs_client_fid_fid);
+LDEBUGFS_SEQ_FOPS(ldebugfs_client_fid_space);
+LDEBUGFS_SEQ_FOPS(ldebugfs_client_fid_width);
+LDEBUGFS_SEQ_FOPS_RO(ldebugfs_client_fid_server);
+LDEBUGFS_SEQ_FOPS_RO(ldebugfs_client_fid_fid);
-struct lprocfs_seq_vars seq_client_proc_list[] = {
+struct lprocfs_vars seq_client_debugfs_list[] = {
{ .name = "space",
- .fops = &lprocfs_client_fid_space_fops },
+ .fops = &ldebugfs_client_fid_space_fops },
{ .name = "width",
- .fops = &lprocfs_client_fid_width_fops },
+ .fops = &ldebugfs_client_fid_width_fops },
{ .name = "server",
- .fops = &lprocfs_client_fid_server_fops },
+ .fops = &ldebugfs_client_fid_server_fops},
{ .name = "fid",
- .fops = &lprocfs_client_fid_fid_fops },
+ .fops = &ldebugfs_client_fid_fid_fops },
{ NULL }
};
-
-#endif /* CONFIG_PROC_FS */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff