* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include <obd_class.h>
#include <lprocfs_status.h>
-#include <lustre_fsfilt.h>
-#include <lustre_log.h>
-#include <lustre_disk.h>
#include <lustre/lustre_idl.h>
-#include <dt_object.h>
#if defined(LPROCFS)
char *page, *start = NULL;
int rc = 0, eof = 1, count;
- if (*ppos >= CFS_PAGE_SIZE)
+ if (*ppos >= PAGE_CACHE_SIZE)
return 0;
page = (char *)__get_free_page(GFP_KERNEL);
OBD_FAIL_TIMEOUT(OBD_FAIL_LPROC_REMOVE, 10);
if (dp->read_proc)
- rc = dp->read_proc(page, &start, *ppos, CFS_PAGE_SIZE,
+ rc = dp->read_proc(page, &start, *ppos, PAGE_CACHE_SIZE,
&eof, dp->data);
LPROCFS_EXIT();
if (rc <= 0)
}
count = (rc < size) ? rc : size;
- if (cfs_copy_to_user(buf, start, count)) {
+ if (copy_to_user(buf, start, count)) {
rc = -EFAULT;
goto out;
}
};
EXPORT_SYMBOL(lprocfs_evict_client_fops);
-/**
- * Add /proc entries.
- *
- * \param root [in] The parent proc entry on which new entry will be added.
- * \param list [in] Array of proc entries to be added.
- * \param data [in] The argument to be passed when entries read/write routines
- * are called through /proc file.
- *
- * \retval 0 on success
- * < 0 on error
- */
-int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list,
- void *data)
+static int __lprocfs_add_vars(struct proc_dir_entry *root,
+ struct lprocfs_vars *list,
+ void *data)
{
int rc = 0;
if (root == NULL || list == NULL)
return -EINVAL;
- LPROCFS_WRITE_ENTRY();
while (list->name != NULL) {
struct proc_dir_entry *cur_root, *proc;
char *pathcopy, *cur, *next, pathbuf[64];
list++;
}
out:
- LPROCFS_WRITE_EXIT();
return rc;
}
+
+/**
+ * Add /proc entries.
+ *
+ * \param root [in] The parent proc entry on which new entry will be added.
+ * \param list [in] Array of proc entries to be added.
+ * \param data [in] The argument to be passed when entries read/write routines
+ * are called through /proc file.
+ *
+ * \retval 0 on success
+ * < 0 on error
+ */
+int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list,
+ void *data)
+{
+ int rc;
+
+ LPROCFS_WRITE_ENTRY();
+ rc = __lprocfs_add_vars(root, list, data);
+ LPROCFS_WRITE_EXIT();
+
+ return rc;
+}
EXPORT_SYMBOL(lprocfs_add_vars);
-void lprocfs_remove_nolock(struct proc_dir_entry **rooth)
+void lprocfs_remove_nolock(struct proc_dir_entry **proot)
{
- struct proc_dir_entry *root = *rooth;
- struct proc_dir_entry *temp = root;
- struct proc_dir_entry *rm_entry;
- struct proc_dir_entry *parent;
+ struct proc_dir_entry *root = *proot;
+ struct proc_dir_entry *temp = root;
+ struct proc_dir_entry *rm_entry;
+ struct proc_dir_entry *parent;
- if (!root)
- return;
- *rooth = NULL;
+ *proot = NULL;
+ if (root == NULL || IS_ERR(root))
+ return;
parent = root->parent;
LASSERT(parent != NULL);
EXPORT_SYMBOL(lprocfs_try_remove_proc_entry);
struct proc_dir_entry *lprocfs_register(const char *name,
- struct proc_dir_entry *parent,
- struct lprocfs_vars *list, void *data)
+ struct proc_dir_entry *parent,
+ struct lprocfs_vars *list, void *data)
{
- struct proc_dir_entry *newchild;
+ struct proc_dir_entry *entry;
+ int rc;
- newchild = lprocfs_srch(parent, name);
- if (newchild != NULL) {
- CERROR(" Lproc: Attempting to register %s more than once \n",
- name);
- return ERR_PTR(-EALREADY);
- }
+ LPROCFS_WRITE_ENTRY();
+ entry = __lprocfs_srch(parent, name);
+ if (entry != NULL) {
+ CERROR("entry '%s' already registered\n", name);
+ GOTO(out, entry = ERR_PTR(-EALREADY));
+ }
- newchild = proc_mkdir(name, parent);
- if (newchild != NULL && list != NULL) {
- int rc = lprocfs_add_vars(newchild, list, data);
- if (rc) {
- lprocfs_remove(&newchild);
- return ERR_PTR(rc);
- }
- }
- return newchild;
+ entry = proc_mkdir(name, parent);
+ if (entry == NULL)
+ GOTO(out, entry = ERR_PTR(-ENOMEM));
+
+ if (list != NULL) {
+ rc = __lprocfs_add_vars(entry, list, data);
+ if (rc != 0) {
+ lprocfs_remove_nolock(&entry);
+ GOTO(out, entry = ERR_PTR(rc));
+ }
+ }
+out:
+ LPROCFS_WRITE_EXIT();
+
+ return entry;
}
EXPORT_SYMBOL(lprocfs_register);
unsigned long tmp;
dummy[MAX_STRING_SIZE] = '\0';
- if (cfs_copy_from_user(dummy, buffer, MAX_STRING_SIZE))
+ if (copy_from_user(dummy, buffer, MAX_STRING_SIZE))
return -EFAULT;
tmp = simple_strtoul(dummy, &end, 0);
struct obd_device *dev = data;
LASSERT(dev != NULL);
- LASSERT(dev->obd_name != NULL);
*eof = 1;
return snprintf(page, count, "%s\n", dev->obd_name);
}
}
EXPORT_SYMBOL(lprocfs_rd_blksize);
-int lprocfs_osd_rd_blksize(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct dt_device *dt = data;
- struct obd_statfs osfs;
- int rc = dt_statfs(NULL, dt, &osfs);
- if (!rc) {
- *eof = 1;
- rc = snprintf(page, count, "%d\n",
- (unsigned) osfs.os_bsize);
- }
- return rc;
-}
-EXPORT_SYMBOL(lprocfs_osd_rd_blksize);
-
int lprocfs_rd_kbytestotal(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
}
EXPORT_SYMBOL(lprocfs_rd_kbytestotal);
-int lprocfs_osd_rd_kbytestotal(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct dt_device *dt = data;
- struct obd_statfs osfs;
- int rc = dt_statfs(NULL, dt, &osfs);
- if (!rc) {
- __u32 blk_size = osfs.os_bsize >> 10;
- __u64 result = osfs.os_blocks;
-
- while (blk_size >>= 1)
- result <<= 1;
-
- *eof = 1;
- rc = snprintf(page, count, LPU64"\n", result);
- }
- return rc;
-}
-EXPORT_SYMBOL(lprocfs_osd_rd_kbytestotal);
-
int lprocfs_rd_kbytesfree(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
}
EXPORT_SYMBOL(lprocfs_rd_kbytesfree);
-int lprocfs_osd_rd_kbytesfree(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct dt_device *dt = data;
- struct obd_statfs osfs;
- int rc = dt_statfs(NULL, dt, &osfs);
- if (!rc) {
- __u32 blk_size = osfs.os_bsize >> 10;
- __u64 result = osfs.os_bfree;
-
- while (blk_size >>= 1)
- result <<= 1;
-
- *eof = 1;
- rc = snprintf(page, count, LPU64"\n", result);
- }
- return rc;
-}
-EXPORT_SYMBOL(lprocfs_osd_rd_kbytesfree);
-
int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
}
EXPORT_SYMBOL(lprocfs_rd_kbytesavail);
-int lprocfs_osd_rd_kbytesavail(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct dt_device *dt = data;
- struct obd_statfs osfs;
- int rc = dt_statfs(NULL, dt, &osfs);
- if (!rc) {
- __u32 blk_size = osfs.os_bsize >> 10;
- __u64 result = osfs.os_bavail;
-
- while (blk_size >>= 1)
- result <<= 1;
-
- *eof = 1;
- rc = snprintf(page, count, LPU64"\n", result);
- }
- return rc;
-}
-EXPORT_SYMBOL(lprocfs_osd_rd_kbytesavail);
-
int lprocfs_rd_filestotal(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
}
EXPORT_SYMBOL(lprocfs_rd_filestotal);
-int lprocfs_osd_rd_filestotal(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct dt_device *dt = data;
- struct obd_statfs osfs;
- int rc = dt_statfs(NULL, dt, &osfs);
- if (!rc) {
- *eof = 1;
- rc = snprintf(page, count, LPU64"\n", osfs.os_files);
- }
-
- return rc;
-}
-EXPORT_SYMBOL(lprocfs_osd_rd_filestotal);
-
int lprocfs_rd_filesfree(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
}
EXPORT_SYMBOL(lprocfs_rd_filesfree);
-int lprocfs_osd_rd_filesfree(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct dt_device *dt = data;
- struct obd_statfs osfs;
- int rc = dt_statfs(NULL, dt, &osfs);
- if (!rc) {
- *eof = 1;
- rc = snprintf(page, count, LPU64"\n", osfs.os_ffree);
- }
- return rc;
-}
-EXPORT_SYMBOL(lprocfs_osd_rd_filesfree);
-
int lprocfs_rd_server_uuid(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
{
unsigned int num_entry;
struct lprocfs_counter *percpu_cntr;
- struct lprocfs_counter_header *cntr_header;
int i;
unsigned long flags = 0;
for (i = 0; i < num_entry; i++) {
if (stats->ls_percpu[i] == NULL)
continue;
- cntr_header = &stats->ls_cnt_header[idx];
percpu_cntr = lprocfs_stats_counter_get(stats, i, idx);
cnt->lc_count += percpu_cntr->lc_count;
"lightweight_conn",
"short_io",
"pingless",
+ "flock_deadlock",
"unknown",
NULL
};
void lprocfs_clear_stats(struct lprocfs_stats *stats)
{
struct lprocfs_counter *percpu_cntr;
- struct lprocfs_counter_header *header;
int i;
int j;
unsigned int num_entry;
if (stats->ls_percpu[i] == NULL)
continue;
for (j = 0; j < stats->ls_num; j++) {
- header = &stats->ls_cnt_header[j];
percpu_cntr = lprocfs_stats_counter_get(stats, i, j);
percpu_cntr->lc_count = 0;
percpu_cntr->lc_min = LC_MIN_INIT;
static void *lprocfs_stats_seq_start(struct seq_file *p, loff_t *pos)
{
- struct lprocfs_stats *stats = p->private;
- /* return 1st cpu location */
- return (*pos >= stats->ls_num) ? NULL :
- lprocfs_stats_counter_get(stats, 0, *pos);
+ struct lprocfs_stats *stats = p->private;
+
+ return (*pos < stats->ls_num) ? pos : NULL;
}
static void lprocfs_stats_seq_stop(struct seq_file *p, void *v)
static void *lprocfs_stats_seq_next(struct seq_file *p, void *v, loff_t *pos)
{
- struct lprocfs_stats *stats = p->private;
- ++*pos;
- return (*pos >= stats->ls_num) ? NULL :
- lprocfs_stats_counter_get(stats, 0, *pos);
+ (*pos)++;
+
+ return lprocfs_stats_seq_start(p, pos);
}
/* 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 *cntr = v;
- struct lprocfs_counter ret;
- struct lprocfs_counter_header *header;
- int entry_size;
- int idx;
- int rc = 0;
+ struct lprocfs_counter_header *hdr;
+ struct lprocfs_counter ctr;
+ int idx = *(loff_t *)v;
+ int rc = 0;
- if (cntr == &(stats->ls_percpu[0])->lp_cntr[0]) {
+ if (idx == 0) {
struct timeval now;
+
cfs_gettimeofday(&now);
rc = seq_printf(p, "%-25s %lu.%lu secs.usecs\n",
"snapshot_time", now.tv_sec, now.tv_usec);
if (rc < 0)
return rc;
}
- entry_size = sizeof(*cntr);
- if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE)
- entry_size += sizeof(__s64);
- idx = ((void *)cntr - (void *)&(stats->ls_percpu[0])->lp_cntr[0]) /
- entry_size;
- header = &stats->ls_cnt_header[idx];
- lprocfs_stats_collect(stats, idx, &ret);
+ hdr = &stats->ls_cnt_header[idx];
+ lprocfs_stats_collect(stats, idx, &ctr);
- if (ret.lc_count == 0)
+ if (ctr.lc_count == 0)
goto out;
- rc = seq_printf(p, "%-25s "LPD64" samples [%s]", header->lc_name,
- ret.lc_count, header->lc_units);
-
+ rc = seq_printf(p, "%-25s "LPD64" samples [%s]", hdr->lc_name,
+ ctr.lc_count, hdr->lc_units);
if (rc < 0)
goto out;
- if ((header->lc_config & LPROCFS_CNTR_AVGMINMAX) &&
- (ret.lc_count > 0)) {
+ if ((hdr->lc_config & LPROCFS_CNTR_AVGMINMAX) && ctr.lc_count > 0) {
rc = seq_printf(p, " "LPD64" "LPD64" "LPD64,
- ret.lc_min, ret.lc_max, ret.lc_sum);
+ ctr.lc_min, ctr.lc_max, ctr.lc_sum);
if (rc < 0)
goto out;
- if (header->lc_config & LPROCFS_CNTR_STDDEV)
- rc = seq_printf(p, " "LPD64, ret.lc_sumsquare);
+ if (hdr->lc_config & LPROCFS_CNTR_STDDEV)
+ rc = seq_printf(p, " "LPD64, ctr.lc_sumsquare);
if (rc < 0)
goto out;
}
rc = seq_printf(p, "\n");
- out:
+out:
return (rc < 0) ? rc : 0;
}
struct seq_operations lprocfs_stats_seq_sops = {
- start: lprocfs_stats_seq_start,
- stop: lprocfs_stats_seq_stop,
- next: lprocfs_stats_seq_next,
- show: lprocfs_stats_seq_show,
+ .start = lprocfs_stats_seq_start,
+ .stop = lprocfs_stats_seq_stop,
+ .next = lprocfs_stats_seq_next,
+ .show = lprocfs_stats_seq_show,
};
static int lprocfs_stats_seq_open(struct inode *inode, struct file *file)
NULL, NULL);
OBD_FREE(buffer, LNET_NIDSTR_SIZE);
- if (new_stat->nid_proc == NULL) {
- CERROR("Error making export directory for nid %s\n",
- libcfs_nid2str(*nid));
- GOTO(destroy_new_ns, rc = -ENOMEM);
- }
+ 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);
+ GOTO(destroy_new_ns, rc);
+ }
entry = lprocfs_add_simple(new_stat->nid_proc, "uuid",
lprocfs_exp_rd_uuid, NULL, new_stat, NULL);
if (count > (sizeof(kernbuf) - 1))
return -EINVAL;
- if (cfs_copy_from_user(kernbuf, buffer, count))
+ if (copy_from_user(kernbuf, buffer, count))
return -EFAULT;
kernbuf[count] = '\0';
if (count > (sizeof(kernbuf) - 1))
return -EINVAL;
- if (cfs_copy_from_user(kernbuf, buffer, count))
+ if (copy_from_user(kernbuf, buffer, count))
return -EFAULT;
kernbuf[count] = '\0';
what we need to read */
*start = page + off;
- /* We know we are allocated a page here.
- Also we know that this function will
- not need to write more than a page
- so we can truncate at CFS_PAGE_SIZE. */
- size = min(count + (int)off + 1, (int)CFS_PAGE_SIZE);
+ /*
+ * We know we are allocated a page here.
+ * Also we know that this function will
+ * not need to write more than a page
+ * so we can truncate at PAGE_CACHE_SIZE.
+ */
+ size = min(count + (int)off + 1, (int)PAGE_CACHE_SIZE);
/* Initialize the page */
memset(page, 0, size);
}
EXPORT_SYMBOL(lprocfs_obd_wr_recovery_time_hard);
-int lprocfs_obd_rd_mntdev(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct obd_device *obd = (struct obd_device *)data;
- struct lustre_mount_info *lmi;
- const char *dev_name;
-
- LASSERT(obd != NULL);
- lmi = server_get_mount_2(obd->obd_name);
- dev_name = get_mntdev_name(lmi->lmi_sb);
- LASSERT(dev_name != NULL);
- *eof = 1;
- server_put_mount_2(obd->obd_name, lmi->lmi_mnt);
- return snprintf(page, count, "%s\n", dev_name);
-}
-EXPORT_SYMBOL(lprocfs_obd_rd_mntdev);
-
int lprocfs_obd_rd_max_pages_per_rpc(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
}
EXPORT_SYMBOL(lprocfs_obd_rd_max_pages_per_rpc);
+#ifdef HAVE_SERVER_SUPPORT
int lprocfs_target_rd_instance(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
return snprintf(page, count, "%u\n", obd->u.obt.obt_instance);
}
EXPORT_SYMBOL(lprocfs_target_rd_instance);
+#endif
#endif /* LPROCFS*/
git://git.whamcloud.com / fs / lustre-release.git / blobdiff