X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=885287c4b77fc33bf1777fac7c8fcfe139dde801;hb=79683154758ed5e71aa755cdf4c385bc621fb966;hp=9a78fe447af7d05f442f9883d25181f97bc05f57;hpb=9219ce0081c665ec42a83ee10fb44cf1ace5e932;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index 9a78fe4..885287c 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -27,7 +27,7 @@ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, Whamcloud, Inc. + * Copyright (c) 2011, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -46,10 +46,7 @@ #include #include -#include -#include #include -#include #if defined(LPROCFS) @@ -65,14 +62,12 @@ EXPORT_SYMBOL(_lprocfs_lock); int lprocfs_single_release(struct inode *inode, struct file *file) { - LPROCFS_EXIT(); return single_release(inode, file); } EXPORT_SYMBOL(lprocfs_single_release); int lprocfs_seq_release(struct inode *inode, struct file *file) { - LPROCFS_EXIT(); return seq_release(inode, file); } EXPORT_SYMBOL(lprocfs_seq_release); @@ -201,23 +196,22 @@ static ssize_t lprocfs_fops_read(struct file *f, char __user *buf, 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); if (page == NULL) return -ENOMEM; - if (LPROCFS_ENTRY_AND_CHECK(dp)) { + if (LPROCFS_ENTRY_CHECK(dp)) { rc = -ENOENT; goto out; } 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) goto out; @@ -236,7 +230,7 @@ static ssize_t lprocfs_fops_read(struct file *f, char __user *buf, } count = (rc < size) ? rc : size; - if (cfs_copy_to_user(buf, start, count)) { + if (copy_to_user(buf, start, count)) { rc = -EFAULT; goto out; } @@ -253,11 +247,10 @@ static ssize_t lprocfs_fops_write(struct file *f, const char __user *buf, struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode); int rc = -EIO; - if (LPROCFS_ENTRY_AND_CHECK(dp)) + if (LPROCFS_ENTRY_CHECK(dp)) return -ENOENT; if (dp->write_proc) rc = dp->write_proc(f, buf, size, dp->data); - LPROCFS_EXIT(); return rc; } @@ -279,13 +272,13 @@ int lprocfs_evict_client_open(struct inode *inode, struct file *f) int lprocfs_evict_client_release(struct inode *inode, struct file *f) { - struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode); - struct obd_device *obd = dp->data; + struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode); + struct obd_device *obd = dp->data; - cfs_atomic_dec(&obd->obd_evict_inprogress); - cfs_waitq_signal(&obd->obd_evict_inprogress_waitq); + cfs_atomic_dec(&obd->obd_evict_inprogress); + wake_up(&obd->obd_evict_inprogress_waitq); - return 0; + return 0; } struct file_operations lprocfs_evict_client_fops = { @@ -297,26 +290,15 @@ struct file_operations lprocfs_evict_client_fops = { }; 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]; @@ -381,21 +363,43 @@ int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, 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); @@ -481,27 +485,34 @@ void lprocfs_try_remove_proc_entry(const char *name, 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); @@ -522,7 +533,7 @@ int lprocfs_wr_uint(struct file *file, const char *buffer, 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); @@ -589,24 +600,11 @@ int lprocfs_rd_name(char *page, char **start, off_t off, int count, 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_name); -int lprocfs_rd_fstype(char *page, char **start, off_t off, int count, int *eof, - void *data) -{ - struct obd_device *obd = data; - - LASSERT(obd != NULL); - LASSERT(obd->obd_fsops != NULL); - LASSERT(obd->obd_fsops->fs_type != NULL); - return snprintf(page, count, "%s\n", obd->obd_fsops->fs_type); -} -EXPORT_SYMBOL(lprocfs_rd_fstype); - int lprocfs_rd_blksize(char *page, char **start, off_t off, int count, int *eof, void *data) { @@ -623,21 +621,6 @@ int lprocfs_rd_blksize(char *page, char **start, off_t off, int count, } 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) { @@ -660,26 +643,6 @@ int lprocfs_rd_kbytestotal(char *page, char **start, off_t off, int count, } 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) { @@ -702,26 +665,6 @@ int lprocfs_rd_kbytesfree(char *page, char **start, off_t off, int count, } 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) { @@ -744,26 +687,6 @@ int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, int count, } 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) { @@ -781,21 +704,6 @@ int lprocfs_rd_filestotal(char *page, char **start, off_t off, int count, } 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) { @@ -812,20 +720,6 @@ int lprocfs_rd_filesfree(char *page, char **start, off_t off, int count, } 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) { @@ -874,12 +768,12 @@ EXPORT_SYMBOL(lprocfs_rd_conn_uuid); /** add up per-cpu counters */ void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, - struct lprocfs_counter *cnt) + struct lprocfs_counter *cnt) { - struct lprocfs_counter *ptr; - unsigned int num_entry; - 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)); @@ -896,18 +790,17 @@ void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, for (i = 0; i < num_entry; i++) { if (stats->ls_percpu[i] == NULL) continue; - - ptr = &(stats->ls_percpu[i])->lp_cntr[idx]; - cnt->lc_count += ptr->lc_count; - cnt->lc_sum += ptr->lc_sum; - if (ptr->lc_min < cnt->lc_min) - cnt->lc_min = ptr->lc_min; - if (ptr->lc_max > cnt->lc_max) - cnt->lc_max = ptr->lc_max; - cnt->lc_sumsquare += ptr->lc_sumsquare; + percpu_cntr = lprocfs_stats_counter_get(stats, i, idx); + + cnt->lc_count += percpu_cntr->lc_count; + cnt->lc_sum += percpu_cntr->lc_sum; + if (percpu_cntr->lc_min < cnt->lc_min) + cnt->lc_min = percpu_cntr->lc_min; + if (percpu_cntr->lc_max > cnt->lc_max) + cnt->lc_max = percpu_cntr->lc_max; + cnt->lc_sumsquare += percpu_cntr->lc_sumsquare; } - cnt->lc_units = stats->ls_percpu[0]->lp_cntr[idx].lc_units; lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags); } EXPORT_SYMBOL(lprocfs_stats_collect); @@ -984,6 +877,8 @@ static const char *obd_connect_names[] = { "nanoseconds_times", "lightweight_conn", "short_io", + "pingless", + "flock_deadlock", "unknown", NULL }; @@ -1009,11 +904,15 @@ EXPORT_SYMBOL(obd_connect_flags2str); int lprocfs_rd_import(char *page, char **start, off_t off, int count, int *eof, void *data) { - struct lprocfs_counter ret; - struct obd_device *obd = (struct obd_device *)data; - struct obd_import *imp; - struct obd_import_conn *conn; - int i, j, k, rw = 0; + 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; + int i; + int j; + int k; + int rw = 0; LASSERT(obd != NULL); LPROCFS_CLIMP_CHECK(obd); @@ -1063,6 +962,10 @@ int lprocfs_rd_import(char *page, char **start, off_t off, int count, cfs_atomic_read(&imp->imp_inval_count)); spin_unlock(&imp->imp_lock); + if (obd->obd_svc_stats == NULL) + goto out_climp; + + 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 */ @@ -1080,7 +983,7 @@ int lprocfs_rd_import(char *page, char **start, off_t off, int count, cfs_atomic_read(&imp->imp_inflight), cfs_atomic_read(&imp->imp_unregistering), cfs_atomic_read(&imp->imp_timeouts), - ret.lc_sum, ret.lc_units); + ret.lc_sum, header->lc_units); k = 0; for(j = 0; j < IMP_AT_MAX_PORTALS; j++) { @@ -1123,6 +1026,7 @@ int lprocfs_rd_import(char *page, char **start, off_t off, int count, } k = (int)ret.lc_sum; j = opcode_offset(OST_READ + rw) + EXTRA_MAX_OPCODES; + 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 */ @@ -1131,7 +1035,7 @@ int lprocfs_rd_import(char *page, char **start, off_t off, int count, ret.lc_sum = sum; i += snprintf(page + i, count - i, " %s_per_rpc: "LPU64"\n", - ret.lc_units, ret.lc_sum); + header->lc_units, ret.lc_sum); j = (int)ret.lc_sum; if (j > 0) i += snprintf(page + i, count - i, @@ -1140,6 +1044,7 @@ int lprocfs_rd_import(char *page, char **start, off_t off, int count, } } +out_climp: LPROCFS_CLIMP_EXIT(obd); return i; } @@ -1321,9 +1226,8 @@ EXPORT_SYMBOL(lprocfs_obd_cleanup); static void lprocfs_free_client_stats(struct nid_stat *client_stat) { - CDEBUG(D_CONFIG, "stat %p - data %p/%p/%p\n", client_stat, - client_stat->nid_proc, client_stat->nid_stats, - client_stat->nid_brw_stats); + CDEBUG(D_CONFIG, "stat %p - data %p/%p\n", client_stat, + client_stat->nid_proc, client_stat->nid_stats); LASSERTF(cfs_atomic_read(&client_stat->nid_exp_ref_count) == 0, "nid %s:count %d\n", libcfs_nid2str(client_stat->nid), @@ -1335,9 +1239,6 @@ static void lprocfs_free_client_stats(struct nid_stat *client_stat) if (client_stat->nid_stats) lprocfs_free_stats(&client_stat->nid_stats); - if (client_stat->nid_brw_stats) - OBD_FREE_PTR(client_stat->nid_brw_stats); - if (client_stat->nid_ldlm_stats) lprocfs_free_stats(&client_stat->nid_ldlm_stats); @@ -1368,9 +1269,10 @@ EXPORT_SYMBOL(lprocfs_free_per_client_stats); struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num, enum lprocfs_stats_flags flags) { - struct lprocfs_stats *stats; - unsigned int percpusize; - unsigned int num_entry; + struct lprocfs_stats *stats; + unsigned int num_entry; + unsigned int percpusize = 0; + int i; if (num == 0) return NULL; @@ -1381,31 +1283,42 @@ struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num, if (flags & LPROCFS_STATS_FLAG_NOPERCPU) num_entry = 1; else - num_entry = cfs_num_possible_cpus() + 1; + num_entry = num_possible_cpus(); /* alloc percpu pointers for all possible cpu slots */ - OBD_ALLOC(stats, offsetof(struct lprocfs_stats, ls_percpu[num_entry])); + LIBCFS_ALLOC(stats, offsetof(typeof(*stats), ls_percpu[num_entry])); if (stats == NULL) return NULL; stats->ls_num = num; - stats->ls_biggest_alloc_num = 1; stats->ls_flags = flags; spin_lock_init(&stats->ls_lock); - percpusize = offsetof(struct lprocfs_percpu, lp_cntr[num]); - if (num_entry > 1) - percpusize = CFS_L1_CACHE_ALIGN(percpusize); - - /* for no percpu area, the 0th entry is for real use, - * for percpu area, the 0th entry is for intialized entry template */ - OBD_ALLOC(stats->ls_percpu[0], percpusize); - if (stats->ls_percpu[0] == NULL) { - OBD_FREE(stats, - offsetof(struct lprocfs_stats, ls_percpu[num_entry])); - stats = NULL; + /* 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) + 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) + goto fail; + stats->ls_biggest_alloc_num = 1; + } else if ((flags & LPROCFS_STATS_FLAG_IRQ_SAFE) != 0) { + /* alloc all percpu data, currently only obd_memory use this */ + for (i = 0; i < num_entry; ++i) + if (lprocfs_stats_alloc_one(stats, i) < 0) + goto fail; } + return stats; + +fail: + lprocfs_free_stats(&stats); + return NULL; } EXPORT_SYMBOL(lprocfs_alloc_stats); @@ -1423,25 +1336,26 @@ void lprocfs_free_stats(struct lprocfs_stats **statsh) if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) num_entry = 1; else - num_entry = cfs_num_possible_cpus() + 1; + num_entry = num_possible_cpus(); - percpusize = offsetof(struct lprocfs_percpu, lp_cntr[stats->ls_num]); - if (num_entry > 1) - percpusize = CFS_L1_CACHE_ALIGN(percpusize); + percpusize = lprocfs_stats_counter_size(stats); for (i = 0; i < num_entry; i++) if (stats->ls_percpu[i] != NULL) - OBD_FREE(stats->ls_percpu[i], percpusize); - OBD_FREE(stats, offsetof(typeof(*stats), ls_percpu[num_entry])); + 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)); + LIBCFS_FREE(stats, offsetof(typeof(*stats), ls_percpu[num_entry])); } EXPORT_SYMBOL(lprocfs_free_stats); void lprocfs_clear_stats(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; + int i; + int j; + unsigned int num_entry; + unsigned long flags = 0; num_entry = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); @@ -1449,12 +1363,14 @@ void lprocfs_clear_stats(struct lprocfs_stats *stats) if (stats->ls_percpu[i] == NULL) continue; for (j = 0; j < stats->ls_num; j++) { - percpu_cntr = &(stats->ls_percpu[i])->lp_cntr[j]; - percpu_cntr->lc_count = 0; - percpu_cntr->lc_sum = 0; - percpu_cntr->lc_min = LC_MIN_INIT; - percpu_cntr->lc_max = 0; - percpu_cntr->lc_sumsquare = 0; + percpu_cntr = lprocfs_stats_counter_get(stats, i, j); + percpu_cntr->lc_count = 0; + percpu_cntr->lc_min = LC_MIN_INIT; + percpu_cntr->lc_max = 0; + percpu_cntr->lc_sumsquare = 0; + percpu_cntr->lc_sum = 0; + if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) + percpu_cntr->lc_sum_irq = 0; } } @@ -1475,10 +1391,9 @@ static ssize_t lprocfs_stats_seq_write(struct file *file, const char *buf, 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 : - &(stats->ls_percpu[0]->lp_cntr[*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) @@ -1487,61 +1402,61 @@ 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 : - &(stats->ls_percpu[0]->lp_cntr[*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; - int idx, rc = 0; - - if (cntr == &(stats->ls_percpu[0])->lp_cntr[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; - } - idx = cntr - &(stats->ls_percpu[0])->lp_cntr[0]; - - lprocfs_stats_collect(stats, idx, &ret); - - if (ret.lc_count == 0) - goto out; - - rc = seq_printf(p, "%-25s "LPD64" samples [%s]", cntr->lc_name, - ret.lc_count, cntr->lc_units); - - if (rc < 0) - goto out; - - if ((cntr->lc_config & LPROCFS_CNTR_AVGMINMAX) && (ret.lc_count > 0)) { - rc = seq_printf(p, " "LPD64" "LPD64" "LPD64, - ret.lc_min, ret.lc_max, ret.lc_sum); - if (rc < 0) - goto out; - if (cntr->lc_config & LPROCFS_CNTR_STDDEV) - rc = seq_printf(p, " "LPD64, ret.lc_sumsquare); - if (rc < 0) - goto out; - } - rc = seq_printf(p, "\n"); - out: - return (rc < 0) ? rc : 0; + struct lprocfs_stats *stats = p->private; + struct lprocfs_counter_header *hdr; + struct lprocfs_counter ctr; + int idx = *(loff_t *)v; + int rc = 0; + + if (idx == 0) { + struct timeval now; + + do_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; + } + + hdr = &stats->ls_cnt_header[idx]; + lprocfs_stats_collect(stats, idx, &ctr); + + if (ctr.lc_count == 0) + goto out; + + rc = seq_printf(p, "%-25s "LPD64" samples [%s]", hdr->lc_name, + ctr.lc_count, hdr->lc_units); + if (rc < 0) + goto out; + + if ((hdr->lc_config & LPROCFS_CNTR_AVGMINMAX) && ctr.lc_count > 0) { + rc = seq_printf(p, " "LPD64" "LPD64" "LPD64, + ctr.lc_min, ctr.lc_max, ctr.lc_sum); + if (rc < 0) + goto out; + 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: + 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) @@ -1550,14 +1465,12 @@ static int lprocfs_stats_seq_open(struct inode *inode, struct file *file) struct seq_file *seq; int rc; - if (LPROCFS_ENTRY_AND_CHECK(dp)) + if (LPROCFS_ENTRY_CHECK(dp)) return -ENOENT; rc = seq_open(file, &lprocfs_stats_seq_sops); - if (rc) { - LPROCFS_EXIT(); + if (rc) return rc; - } seq = file->private_data; seq->private = dp->data; return 0; @@ -1597,20 +1510,35 @@ EXPORT_SYMBOL(lprocfs_register_stats); void lprocfs_counter_init(struct lprocfs_stats *stats, int index, unsigned conf, const char *name, const char *units) { - struct lprocfs_counter *c = &(stats->ls_percpu[0]->lp_cntr[index]); - unsigned long flags = 0; + struct lprocfs_counter_header *header; + struct lprocfs_counter *percpu_cntr; + unsigned long flags = 0; + unsigned int i; + unsigned int num_cpu; LASSERT(stats != NULL); - LASSERT(stats->ls_percpu[0] != NULL); - - lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); - c->lc_config = conf; - c->lc_count = 0; - c->lc_sum = 0; - c->lc_min = LC_MIN_INIT; - c->lc_max = 0; - c->lc_name = name; - c->lc_units = units; + + header = &stats->ls_cnt_header[index]; + 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; + + num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); + for (i = 0; i < num_cpu; ++i) { + if (stats->ls_percpu[i] == NULL) + continue; + percpu_cntr = lprocfs_stats_counter_get(stats, i, index); + percpu_cntr->lc_count = 0; + percpu_cntr->lc_min = LC_MIN_INIT; + percpu_cntr->lc_max = 0; + percpu_cntr->lc_sumsquare = 0; + percpu_cntr->lc_sum = 0; + if ((stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) != 0) + percpu_cntr->lc_sum_irq = 0; + } lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags); } EXPORT_SYMBOL(lprocfs_counter_init); @@ -1642,7 +1570,6 @@ void lprocfs_init_ops_stats(int num_private_stats, struct lprocfs_stats *stats) LPROCFS_OBD_OP_INIT(num_private_stats, stats, fid_init); LPROCFS_OBD_OP_INIT(num_private_stats, stats, fid_fini); LPROCFS_OBD_OP_INIT(num_private_stats, stats, fid_alloc); - LPROCFS_OBD_OP_INIT(num_private_stats, stats, fid_delete); 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); @@ -1692,6 +1619,8 @@ void lprocfs_init_ops_stats(int num_private_stats, struct lprocfs_stats *stats) LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_del); LPROCFS_OBD_OP_INIT(num_private_stats, stats, getref); LPROCFS_OBD_OP_INIT(num_private_stats, stats, putref); + + CLASSERT(NUM_OBD_STATS == OBD_COUNTER_OFFSET(putref) + 1); } EXPORT_SYMBOL(lprocfs_init_ops_stats); @@ -1705,8 +1634,7 @@ int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) LASSERT(obd->obd_proc_entry != NULL); LASSERT(obd->obd_cntr_base == 0); - num_stats = ((int)sizeof(*obd->obd_type->typ_dt_ops) / sizeof(void *)) + - num_private_stats - 1 /* o_owner */; + num_stats = NUM_OBD_STATS + num_private_stats; stats = lprocfs_alloc_stats(num_stats, 0); if (stats == NULL) return -ENOMEM; @@ -1719,7 +1647,7 @@ int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) * , and that the corresponding line item * LPROCFS_OBD_OP_INIT(.., .., opname) * is missing from the list above. */ - LASSERTF(stats->ls_percpu[0]->lp_cntr[i].lc_name != NULL, + LASSERTF(stats->ls_cnt_header[i].lc_name != NULL, "Missing obd_stat initializer obd_op " "operation at offset %d.\n", i - num_private_stats); } @@ -1741,17 +1669,23 @@ void lprocfs_free_obd_stats(struct obd_device *obd) } EXPORT_SYMBOL(lprocfs_free_obd_stats); -#define LPROCFS_MD_OP_INIT(base, stats, op) \ -do { \ - unsigned int coffset = base + MD_COUNTER_OFFSET(op); \ - LASSERT(coffset < stats->ls_num); \ - lprocfs_counter_init(stats, coffset, 0, #op, "reqs"); \ -} while (0) +/* 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, getstatus); - LPROCFS_MD_OP_INIT(num_private_stats, stats, change_cbdata); + LPROCFS_MD_OP_INIT(num_private_stats, stats, null_inode); LPROCFS_MD_OP_INIT(num_private_stats, stats, find_cbdata); LPROCFS_MD_OP_INIT(num_private_stats, stats, close); LPROCFS_MD_OP_INIT(num_private_stats, stats, create); @@ -1764,7 +1698,7 @@ void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats) LPROCFS_MD_OP_INIT(num_private_stats, stats, rename); LPROCFS_MD_OP_INIT(num_private_stats, stats, is_subdir); LPROCFS_MD_OP_INIT(num_private_stats, stats, setattr); - LPROCFS_MD_OP_INIT(num_private_stats, stats, sync); + LPROCFS_MD_OP_INIT(num_private_stats, stats, fsync); LPROCFS_MD_OP_INIT(num_private_stats, stats, readpage); LPROCFS_MD_OP_INIT(num_private_stats, stats, unlink); LPROCFS_MD_OP_INIT(num_private_stats, stats, setxattr); @@ -1786,52 +1720,65 @@ void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats) EXPORT_SYMBOL(lprocfs_init_mps_stats); int lprocfs_alloc_md_stats(struct obd_device *obd, - unsigned num_private_stats) + unsigned int num_private_stats) { - struct lprocfs_stats *stats; - unsigned int num_stats; - int rc, i; + struct lprocfs_stats *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 + * 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 + * the stats backing /proc/fs/lustre/mdt/.../md_stats but the + * mdt layer does not use the md_ops interface. This is + * confusing and a waste of memory. See LU-2484. + */ + 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) + return -ENOMEM; - LASSERT(obd->md_stats == NULL); - LASSERT(obd->obd_proc_entry != NULL); - LASSERT(obd->md_cntr_base == 0); + lprocfs_init_mps_stats(num_private_stats, stats); - num_stats = 1 + MD_COUNTER_OFFSET(revalidate_lock) + - num_private_stats; - stats = lprocfs_alloc_stats(num_stats, 0); - if (stats == NULL) - return -ENOMEM; + 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); + LBUG(); + } + } - lprocfs_init_mps_stats(num_private_stats, stats); + rc = lprocfs_register_stats(obd->obd_proc_entry, "md_stats", stats); + if (rc < 0) { + lprocfs_free_stats(&stats); + } else { + obd->obd_md_stats = stats; + obd->obd_md_cntr_base = num_private_stats; + } - for (i = num_private_stats; i < num_stats; i++) { - if (stats->ls_percpu[0]->lp_cntr[i].lc_name == NULL) { - CERROR("Missing md_stat initializer md_op " - "operation at offset %d. Aborting.\n", - i - num_private_stats); - LBUG(); - } - } - rc = lprocfs_register_stats(obd->obd_proc_entry, "md_stats", stats); - if (rc < 0) { - lprocfs_free_stats(&stats); - } else { - obd->md_stats = stats; - obd->md_cntr_base = num_private_stats; - } - return rc; + return rc; } EXPORT_SYMBOL(lprocfs_alloc_md_stats); void lprocfs_free_md_stats(struct obd_device *obd) { - struct lprocfs_stats *stats = obd->md_stats; + struct lprocfs_stats *stats = obd->obd_md_stats; - if (stats != NULL) { - obd->md_stats = NULL; - obd->md_cntr_base = 0; - lprocfs_free_stats(&stats); - } + if (stats != NULL) { + obd->obd_md_stats = NULL; + obd->obd_md_cntr_base = 0; + lprocfs_free_stats(&stats); + } } EXPORT_SYMBOL(lprocfs_free_md_stats); @@ -1963,7 +1910,6 @@ EXPORT_SYMBOL(lprocfs_nid_stats_clear_read); static int lprocfs_nid_stats_clear_write_cb(void *obj, void *data) { struct nid_stat *stat = obj; - int i; ENTRY; CDEBUG(D_INFO,"refcnt %d\n", cfs_atomic_read(&stat->nid_exp_ref_count)); @@ -1978,10 +1924,6 @@ static int lprocfs_nid_stats_clear_write_cb(void *obj, void *data) if (stat->nid_stats) lprocfs_clear_stats(stat->nid_stats); - if (stat->nid_brw_stats) { - for (i = 0; i < BRW_LAST; i++) - lprocfs_oh_clear(&stat->nid_brw_stats->hist[i]); - } RETURN(0); } @@ -2027,6 +1969,13 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid) if (!nid || *nid == LNET_NID_ANY) RETURN(0); + spin_lock(&exp->exp_lock); + if (exp->exp_nid_stats != NULL) { + spin_unlock(&exp->exp_lock); + RETURN(-EALREADY); + } + spin_unlock(&exp->exp_lock); + obd = exp->exp_obd; CDEBUG(D_CONFIG, "using hash %p\n", obd->obd_nid_stats_hash); @@ -2046,19 +1995,12 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid) old_stat, libcfs_nid2str(*nid), cfs_atomic_read(&new_stat->nid_exp_ref_count)); - /* We need to release old stats because lprocfs_exp_cleanup() hasn't - * been and will never be called. */ - if (exp->exp_nid_stats) { - nidstat_putref(exp->exp_nid_stats); - exp->exp_nid_stats = NULL; - } - - /* Return -EALREADY here so that we know that the /proc - * entry already has been created */ - if (old_stat != new_stat) { - exp->exp_nid_stats = old_stat; - GOTO(destroy_new, rc = -EALREADY); - } + /* Return -EALREADY here so that we know that the /proc + * entry already has been created */ + if (old_stat != new_stat) { + nidstat_putref(old_stat); + GOTO(destroy_new, rc = -EALREADY); + } /* not found - create */ OBD_ALLOC(buffer, LNET_NIDSTR_SIZE); if (buffer == NULL) @@ -2070,11 +2012,13 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid) 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); @@ -2092,7 +2036,9 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid) GOTO(destroy_new_ns, rc); } - exp->exp_nid_stats = new_stat; + spin_lock(&exp->exp_lock); + exp->exp_nid_stats = new_stat; + spin_unlock(&exp->exp_lock); *newnid = 1; /* protect competitive add to list, not need locking on destroy */ spin_lock(&obd->obd_nid_lock); @@ -2142,7 +2088,7 @@ int lprocfs_write_frac_helper(const char *buffer, unsigned long count, 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'; @@ -2248,7 +2194,7 @@ int lprocfs_write_frac_u64_helper(const char *buffer, unsigned long count, 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'; @@ -2277,18 +2223,20 @@ int lprocfs_write_frac_u64_helper(const char *buffer, unsigned long count, } units = 1; - switch(*end) { - 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; - } + if (end != NULL) { + switch (*end) { + 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; + } + } /* Specified units override the multiplier */ if (units) mult = mult < 0 ? -units : units; @@ -2346,12 +2294,18 @@ char *lprocfs_find_named_value(const char *buffer, const char *name, } EXPORT_SYMBOL(lprocfs_find_named_value); -int lprocfs_seq_create(cfs_proc_dir_entry_t *parent, char *name, mode_t mode, - struct file_operations *seq_fops, void *data) +int lprocfs_seq_create(cfs_proc_dir_entry_t *parent, + const char *name, + mode_t mode, + const struct file_operations *seq_fops, + void *data) { struct proc_dir_entry *entry; ENTRY; + /* Disallow secretly (un)writable entries. */ + LASSERT((seq_fops->write == NULL) == ((mode & 0222) == 0)); + LPROCFS_WRITE_ENTRY(); entry = create_proc_entry(name, mode, parent); if (entry) { @@ -2367,10 +2321,11 @@ int lprocfs_seq_create(cfs_proc_dir_entry_t *parent, char *name, mode_t mode, } EXPORT_SYMBOL(lprocfs_seq_create); -__inline__ int lprocfs_obd_seq_create(struct obd_device *dev, char *name, - mode_t mode, - struct file_operations *seq_fops, - void *data) +int lprocfs_obd_seq_create(struct obd_device *dev, + const char *name, + mode_t mode, + const struct file_operations *seq_fops, + void *data) { return (lprocfs_seq_create(dev->obd_proc_entry, name, mode, seq_fops, data)); @@ -2390,12 +2345,12 @@ EXPORT_SYMBOL(lprocfs_oh_tally); void lprocfs_oh_tally_log2(struct obd_histogram *oh, unsigned int value) { - unsigned int val; + unsigned int val = 0; - for (val = 0; ((1 << val) < value) && (val <= OBD_HIST_MAX); val++) - ; + if (likely(value != 0)) + val = min(fls(value - 1), OBD_HIST_MAX); - lprocfs_oh_tally(oh, val); + lprocfs_oh_tally(oh, val); } EXPORT_SYMBOL(lprocfs_oh_tally_log2); @@ -2451,11 +2406,13 @@ int lprocfs_obd_rd_recovery_status(char *page, char **start, off_t off, 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); @@ -2643,19 +2600,6 @@ int lprocfs_obd_wr_recovery_time_hard(struct file *file, const char *buffer, } 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; - - LASSERT(obd != NULL); - LASSERT(mnt_get_devname(obd->u.obt.obt_vfsmnt)); - *eof = 1; - return snprintf(page, count, "%s\n", - mnt_get_devname(obd->u.obt.obt_vfsmnt)); -} -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) { @@ -2670,6 +2614,7 @@ int lprocfs_obd_rd_max_pages_per_rpc(char *page, char **start, off_t off, } 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) { @@ -2682,4 +2627,5 @@ int lprocfs_target_rd_instance(char *page, char **start, off_t off, return snprintf(page, count, "%u\n", obd->u.obt.obt_instance); } EXPORT_SYMBOL(lprocfs_target_rd_instance); +#endif #endif /* LPROCFS*/