X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=516d7984e5285a0b47889e563fa0e66146edbbea;hp=1d411c2b198fc886a9d0d3b87ac5fc0edd524aeb;hb=f100d508311d16a09040a057438ee06fd9e6d7fe;hpb=6498fa0391051802ddce9234f8b23ad883a65797 diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index 1d411c2..516d798 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -28,6 +26,8 @@ /* * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, Whamcloud, Inc. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -38,9 +38,6 @@ * Author: Hariharan Thantry */ -#ifndef EXPORT_SYMTAB -# define EXPORT_SYMTAB -#endif #define DEBUG_SUBSYSTEM S_CLASS #ifndef __KERNEL__ @@ -52,15 +49,27 @@ #include #include #include +#include #if defined(LPROCFS) +static int lprocfs_no_percpu_stats = 0; +CFS_MODULE_PARM(lprocfs_no_percpu_stats, "i", int, 0644, + "Do not alloc percpu data for lprocfs stats"); + #define MAX_STRING_SIZE 128 /* for bug 10866, global variable */ CFS_DECLARE_RWSEM(_lprocfs_lock); 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(); @@ -92,11 +101,12 @@ struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head, { struct proc_dir_entry *temp; - LPROCFS_ENTRY(); + LPROCFS_SRCH_ENTRY(); temp = __lprocfs_srch(head, name); - LPROCFS_EXIT(); + LPROCFS_SRCH_EXIT(); return temp; } +EXPORT_SYMBOL(lprocfs_srch); /* lprocfs API calls */ @@ -154,6 +164,7 @@ cfs_proc_dir_entry_t *lprocfs_add_simple(struct proc_dir_entry *root, LPROCFS_WRITE_EXIT(); return proc; } +EXPORT_SYMBOL(lprocfs_add_simple); struct proc_dir_entry *lprocfs_add_symlink(const char *name, struct proc_dir_entry *parent, const char *format, ...) @@ -181,6 +192,7 @@ struct proc_dir_entry *lprocfs_add_symlink(const char *name, OBD_FREE(dest, MAX_STRING_SIZE + 1); return entry; } +EXPORT_SYMBOL(lprocfs_add_symlink); static ssize_t lprocfs_fops_read(struct file *f, char __user *buf, size_t size, loff_t *ppos) @@ -372,8 +384,9 @@ out: LPROCFS_WRITE_EXIT(); return rc; } +EXPORT_SYMBOL(lprocfs_add_vars); -void lprocfs_remove(struct proc_dir_entry **rooth) +void lprocfs_remove_nolock(struct proc_dir_entry **rooth) { struct proc_dir_entry *root = *rooth; struct proc_dir_entry *temp = root; @@ -386,7 +399,6 @@ void lprocfs_remove(struct proc_dir_entry **rooth) parent = root->parent; LASSERT(parent != NULL); - LPROCFS_WRITE_ENTRY(); /* search vs remove race */ while (1) { while (temp->subdir != NULL) @@ -401,21 +413,89 @@ void lprocfs_remove(struct proc_dir_entry **rooth) "0x%p %s/%s len %d\n", rm_entry, temp->name, rm_entry->name, (int)strlen(rm_entry->name)); +#ifdef HAVE_PROCFS_USERS + /* if procfs uses user count to synchronize deletion of + * proc entry, there is no protection for rm_entry->data, + * then lprocfs_fops_read and lprocfs_fops_write maybe + * call proc_dir_entry->read_proc (or write_proc) with + * proc_dir_entry->data == NULL, then cause kernel Oops. + * see bug19706 for detailed information */ + + /* procfs won't free rm_entry->data if it isn't a LINK, + * and Lustre won't use rm_entry->data if it is a LINK */ + if (S_ISLNK(rm_entry->mode)) + rm_entry->data = NULL; +#else /* Now, the rm_entry->deleted flags is protected * by _lprocfs_lock. */ rm_entry->data = NULL; +#endif remove_proc_entry(rm_entry->name, temp); if (temp == parent) break; } - LPROCFS_WRITE_EXIT(); } +void lprocfs_remove(struct proc_dir_entry **rooth) +{ + LPROCFS_WRITE_ENTRY(); /* search vs remove race */ + lprocfs_remove_nolock(rooth); + LPROCFS_WRITE_EXIT(); +} +EXPORT_SYMBOL(lprocfs_remove); + void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent) { LASSERT(parent != NULL); remove_proc_entry(name, parent); } +EXPORT_SYMBOL(lprocfs_remove_proc_entry); + +void lprocfs_try_remove_proc_entry(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); + + LPROCFS_WRITE_ENTRY(); + + /* 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); + + LPROCFS_WRITE_EXIT(); + + return; +} +EXPORT_SYMBOL(lprocfs_try_remove_proc_entry); struct proc_dir_entry *lprocfs_register(const char *name, struct proc_dir_entry *parent, @@ -440,6 +520,7 @@ struct proc_dir_entry *lprocfs_register(const char *name, } return newchild; } +EXPORT_SYMBOL(lprocfs_register); /* Generic callbacks */ int lprocfs_rd_uint(char *page, char **start, off_t off, @@ -448,6 +529,7 @@ int lprocfs_rd_uint(char *page, char **start, off_t off, unsigned int *temp = data; return snprintf(page, count, "%u\n", *temp); } +EXPORT_SYMBOL(lprocfs_rd_uint); int lprocfs_wr_uint(struct file *file, const char *buffer, unsigned long count, void *data) @@ -467,6 +549,7 @@ int lprocfs_wr_uint(struct file *file, const char *buffer, *p = (unsigned int)tmp; return count; } +EXPORT_SYMBOL(lprocfs_wr_uint); int lprocfs_rd_u64(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -475,6 +558,7 @@ int lprocfs_rd_u64(char *page, char **start, off_t off, *eof = 1; return snprintf(page, count, LPU64"\n", *(__u64 *)data); } +EXPORT_SYMBOL(lprocfs_rd_u64); int lprocfs_rd_atomic(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -484,6 +568,7 @@ int lprocfs_rd_atomic(char *page, char **start, off_t off, *eof = 1; return snprintf(page, count, "%d\n", cfs_atomic_read(atom)); } +EXPORT_SYMBOL(lprocfs_rd_atomic); int lprocfs_wr_atomic(struct file *file, const char *buffer, unsigned long count, void *data) @@ -502,6 +587,7 @@ int lprocfs_wr_atomic(struct file *file, const char *buffer, cfs_atomic_set(atm, val); return count; } +EXPORT_SYMBOL(lprocfs_wr_atomic); int lprocfs_rd_uuid(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -512,6 +598,7 @@ int lprocfs_rd_uuid(char *page, char **start, off_t off, int count, *eof = 1; return snprintf(page, count, "%s\n", obd->obd_uuid.uuid); } +EXPORT_SYMBOL(lprocfs_rd_uuid); int lprocfs_rd_name(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -523,6 +610,7 @@ int lprocfs_rd_name(char *page, char **start, off_t off, int count, *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) @@ -534,12 +622,14 @@ int lprocfs_rd_fstype(char *page, char **start, off_t off, int count, int *eof, 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) { - struct obd_statfs osfs; - int rc = obd_statfs(data, &osfs, + struct obd_device *obd = data; + struct obd_statfs osfs; + int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) { @@ -548,12 +638,29 @@ int lprocfs_rd_blksize(char *page, char **start, off_t off, int count, } return rc; } +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) { - struct obd_statfs osfs; - int rc = obd_statfs(data, &osfs, + struct obd_device *obd = data; + struct obd_statfs osfs; + int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) { @@ -568,12 +675,34 @@ int lprocfs_rd_kbytestotal(char *page, char **start, off_t off, int count, } return rc; } +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) { - struct obd_statfs osfs; - int rc = obd_statfs(data, &osfs, + struct obd_device *obd = data; + struct obd_statfs osfs; + int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) { @@ -588,12 +717,34 @@ int lprocfs_rd_kbytesfree(char *page, char **start, off_t off, int count, } return rc; } +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) { - struct obd_statfs osfs; - int rc = obd_statfs(data, &osfs, + struct obd_device *obd = data; + struct obd_statfs osfs; + int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) { @@ -608,12 +759,34 @@ int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, int count, } return rc; } +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) { - struct obd_statfs osfs; - int rc = obd_statfs(data, &osfs, + struct obd_device *obd = data; + struct obd_statfs osfs; + int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) { @@ -623,12 +796,29 @@ int lprocfs_rd_filestotal(char *page, char **start, off_t off, int count, return rc; } +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) { - struct obd_statfs osfs; - int rc = obd_statfs(data, &osfs, + struct obd_device *obd = data; + struct obd_statfs osfs; + int rc = obd_statfs(NULL, obd->obd_self_export, &osfs, cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), OBD_STATFS_NODELAY); if (!rc) { @@ -637,6 +827,21 @@ int lprocfs_rd_filesfree(char *page, char **start, off_t off, int count, } return rc; } +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) @@ -658,6 +863,7 @@ int lprocfs_rd_server_uuid(char *page, char **start, off_t off, int count, LPROCFS_CLIMP_EXIT(obd); return rc; } +EXPORT_SYMBOL(lprocfs_rd_server_uuid); int lprocfs_rd_conn_uuid(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -681,15 +887,18 @@ int lprocfs_rd_conn_uuid(char *page, char **start, off_t off, int count, LPROCFS_CLIMP_EXIT(obd); return rc; } +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) { - unsigned int num_cpu; - struct lprocfs_counter t; - struct lprocfs_counter *percpu_cntr; - int centry, i; + unsigned int num_entry; + struct lprocfs_counter t; + struct lprocfs_counter *percpu_cntr; + int centry; + int i; + unsigned long flags = 0; memset(cnt, 0, sizeof(*cnt)); @@ -701,13 +910,12 @@ void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, cnt->lc_min = LC_MIN_INIT; - if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) - num_cpu = 1; - else - num_cpu = cfs_num_possible_cpus(); + num_entry = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); - for (i = 0; i < num_cpu; i++) { - percpu_cntr = &(stats->ls_percpu[i])->lp_cntr[idx]; + for (i = 0; i < num_entry; i++) { + if (stats->ls_percpu[i] == NULL) + continue; + percpu_cntr = &(stats->ls_percpu[i])->lp_cntr[idx]; do { centry = cfs_atomic_read(&percpu_cntr-> \ @@ -730,8 +938,10 @@ void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, cnt->lc_sumsquare += t.lc_sumsquare; } - cnt->lc_units = stats->ls_percpu[0]->lp_cntr[idx].lc_units; + 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); /** * Append a space separated list of current set flags to str. @@ -793,10 +1003,23 @@ static const char *obd_connect_names[] = { "large_ea", "full20", "layout_lock", + "64bithash", + "object_max_bytes", + "imp_recov", + "jobstats", + "umask", + "einprogress", + "grant_param", + "flock_owner", + "lvb_type", + "nanoseconds_times", + "lightweight_conn", + "short_io", + "unknown", NULL }; -static int obd_connect_flags2str(char *page, int count, __u64 flags, char *sep) +int obd_connect_flags2str(char *page, int count, __u64 flags, char *sep) { __u64 mask = 1; int i, ret = 0; @@ -812,6 +1035,7 @@ static int obd_connect_flags2str(char *page, int count, __u64 flags, char *sep) ret ? sep : "", flags & ~(mask - 1)); return ret; } +EXPORT_SYMBOL(obd_connect_flags2str); int lprocfs_rd_import(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -832,10 +1056,12 @@ int lprocfs_rd_import(char *page, char **start, off_t off, int count, " name: %s\n" " target: %s\n" " state: %s\n" + " instance: %u\n" " connect_flags: [", obd->obd_name, obd2cli_tgt(obd), - ptlrpc_import_state_name(imp->imp_state)); + ptlrpc_import_state_name(imp->imp_state), + imp->imp_connect_data.ocd_instance); i += obd_connect_flags2str(page + i, count - i, imp->imp_connect_data.ocd_connect_flags, ", "); @@ -855,17 +1081,18 @@ int lprocfs_rd_import(char *page, char **start, off_t off, int count, libcfs_nid2str(conn->oic_conn->c_peer.nid)); j++; } - cfs_spin_unlock(&imp->imp_lock); - i += snprintf(page + i, count - i, - "]\n" - " current_connection: %s\n" - " connection_attempts: %u\n" - " generation: %u\n" - " in-progress_invalidations: %u\n", - libcfs_nid2str(imp->imp_connection->c_peer.nid), - imp->imp_conn_cnt, - imp->imp_generation, - cfs_atomic_read(&imp->imp_inval_count)); + i += snprintf(page + i, count - i, + "]\n" + " current_connection: %s\n" + " connection_attempts: %u\n" + " generation: %u\n" + " in-progress_invalidations: %u\n", + imp->imp_connection == NULL ? "" : + libcfs_nid2str(imp->imp_connection->c_peer.nid), + imp->imp_conn_cnt, + imp->imp_generation, + cfs_atomic_read(&imp->imp_inval_count)); + cfs_spin_unlock(&imp->imp_lock); lprocfs_stats_collect(obd->obd_svc_stats, PTLRPC_REQWAIT_CNTR, &ret); if (ret.lc_count != 0) { @@ -947,6 +1174,7 @@ int lprocfs_rd_import(char *page, char **start, off_t off, int count, LPROCFS_CLIMP_EXIT(obd); return i; } +EXPORT_SYMBOL(lprocfs_rd_import); int lprocfs_rd_state(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -978,6 +1206,7 @@ int lprocfs_rd_state(char *page, char **start, off_t off, int count, LPROCFS_CLIMP_EXIT(obd); return i; } +EXPORT_SYMBOL(lprocfs_rd_state); int lprocfs_at_hist_helper(char *page, int count, int rc, struct adaptive_timeout *at) @@ -988,6 +1217,7 @@ int lprocfs_at_hist_helper(char *page, int count, int rc, rc += snprintf(page + rc, count - rc, "\n"); return rc; } +EXPORT_SYMBOL(lprocfs_at_hist_helper); /* See also ptlrpc_lprocfs_rd_timeouts */ int lprocfs_rd_timeouts(char *page, char **start, off_t off, int count, @@ -1041,6 +1271,7 @@ int lprocfs_rd_timeouts(char *page, char **start, off_t off, int count, LPROCFS_CLIMP_EXIT(obd); return rc; } +EXPORT_SYMBOL(lprocfs_rd_timeouts); int lprocfs_rd_connect_flags(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -1068,6 +1299,7 @@ int lprocfs_rd_num_exports(char *page, char **start, off_t off, int count, *eof = 1; return snprintf(page, count, "%u\n", obd->obd_num_exports); } +EXPORT_SYMBOL(lprocfs_rd_num_exports); int lprocfs_rd_numrefs(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -1078,6 +1310,7 @@ int lprocfs_rd_numrefs(char *page, char **start, off_t off, int count, *eof = 1; return snprintf(page, count, "%d\n", class->typ_refcnt); } +EXPORT_SYMBOL(lprocfs_rd_numrefs); int lprocfs_obd_setup(struct obd_device *obd, struct lprocfs_vars *list) { @@ -1097,6 +1330,7 @@ int lprocfs_obd_setup(struct obd_device *obd, struct lprocfs_vars *list) } return rc; } +EXPORT_SYMBOL(lprocfs_obd_setup); int lprocfs_obd_cleanup(struct obd_device *obd) { @@ -1114,6 +1348,7 @@ int lprocfs_obd_cleanup(struct obd_device *obd) } return 0; } +EXPORT_SYMBOL(lprocfs_obd_cleanup); static void lprocfs_free_client_stats(struct nid_stat *client_stat) { @@ -1122,10 +1357,8 @@ static void lprocfs_free_client_stats(struct nid_stat *client_stat) client_stat->nid_brw_stats); LASSERTF(cfs_atomic_read(&client_stat->nid_exp_ref_count) == 0, - "count %d\n", - cfs_atomic_read(&client_stat->nid_exp_ref_count)); - - cfs_hlist_del_init(&client_stat->nid_hash); + "nid %s:count %d\n", libcfs_nid2str(client_stat->nid), + atomic_read(&client_stat->nid_exp_ref_count)); if (client_stat->nid_proc) lprocfs_remove(&client_stat->nid_proc); @@ -1146,120 +1379,121 @@ static void lprocfs_free_client_stats(struct nid_stat *client_stat) void lprocfs_free_per_client_stats(struct obd_device *obd) { + cfs_hash_t *hash = obd->obd_nid_stats_hash; struct nid_stat *stat; ENTRY; /* we need extra list - because hash_exit called to early */ /* not need locking because all clients is died */ - while(!cfs_list_empty(&obd->obd_nid_stats)) { + while (!cfs_list_empty(&obd->obd_nid_stats)) { stat = cfs_list_entry(obd->obd_nid_stats.next, struct nid_stat, nid_list); cfs_list_del_init(&stat->nid_list); + cfs_hash_del(hash, &stat->nid, &stat->nid_hash); lprocfs_free_client_stats(stat); } - EXIT; } +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 i, j; - unsigned int num_cpu; + struct lprocfs_stats *stats; + unsigned int percpusize; + unsigned int num_entry; if (num == 0) return NULL; - if (flags & LPROCFS_STATS_FLAG_NOPERCPU) - num_cpu = 1; - else - num_cpu = cfs_num_possible_cpus(); - - OBD_ALLOC(stats, offsetof(typeof(*stats), ls_percpu[num_cpu])); - if (stats == NULL) - return NULL; - - if (flags & LPROCFS_STATS_FLAG_NOPERCPU) { - stats->ls_flags = flags; - cfs_spin_lock_init(&stats->ls_lock); - /* Use this lock only if there are no percpu areas */ - } else { - stats->ls_flags = 0; - } - - percpusize = offsetof(struct lprocfs_percpu, lp_cntr[num]); - if (num_cpu > 1) - percpusize = CFS_L1_CACHE_ALIGN(percpusize); - - for (i = 0; i < num_cpu; i++) { - OBD_ALLOC(stats->ls_percpu[i], percpusize); - if (stats->ls_percpu[i] == NULL) { - for (j = 0; j < i; j++) { - OBD_FREE(stats->ls_percpu[j], percpusize); - stats->ls_percpu[j] = NULL; - } - break; - } - } - if (stats->ls_percpu[0] == NULL) { - OBD_FREE(stats, offsetof(typeof(*stats), - ls_percpu[num_cpu])); - return NULL; - } - - stats->ls_num = num; - return stats; + if (lprocfs_no_percpu_stats != 0) + flags |= LPROCFS_STATS_FLAG_NOPERCPU; + + if (flags & LPROCFS_STATS_FLAG_NOPERCPU) + num_entry = 1; + else + num_entry = cfs_num_possible_cpus() + 1; + + /* alloc percpu pointers for all possible cpu slots */ + OBD_ALLOC(stats, offsetof(struct lprocfs_stats, ls_percpu[num_entry])); + if (stats == NULL) + return NULL; + + stats->ls_num = num; + stats->ls_biggest_alloc_num = 1; + stats->ls_flags = flags; + cfs_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; + } + return stats; } +EXPORT_SYMBOL(lprocfs_alloc_stats); void lprocfs_free_stats(struct lprocfs_stats **statsh) { - struct lprocfs_stats *stats = *statsh; - unsigned int num_cpu; - unsigned int percpusize; - unsigned int i; + struct lprocfs_stats *stats = *statsh; + unsigned int num_entry; + unsigned int percpusize; + unsigned int i; if (stats == NULL || stats->ls_num == 0) return; *statsh = NULL; - if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) - num_cpu = 1; - else - num_cpu = cfs_num_possible_cpus(); + if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) + num_entry = 1; + else + num_entry = cfs_num_possible_cpus() + 1; - percpusize = offsetof(struct lprocfs_percpu, lp_cntr[stats->ls_num]); - if (num_cpu > 1) - percpusize = CFS_L1_CACHE_ALIGN(percpusize); - for (i = 0; i < num_cpu; i++) - OBD_FREE(stats->ls_percpu[i], percpusize); - OBD_FREE(stats, offsetof(typeof(*stats), ls_percpu[num_cpu])); + percpusize = offsetof(struct lprocfs_percpu, lp_cntr[stats->ls_num]); + if (num_entry > 1) + percpusize = CFS_L1_CACHE_ALIGN(percpusize); + 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])); } +EXPORT_SYMBOL(lprocfs_free_stats); void lprocfs_clear_stats(struct lprocfs_stats *stats) { - struct lprocfs_counter *percpu_cntr; - int i,j; - unsigned int num_cpu; - - num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU); - - for (i = 0; i < num_cpu; i++) { - for (j = 0; j < stats->ls_num; j++) { - percpu_cntr = &(stats->ls_percpu[i])->lp_cntr[j]; - cfs_atomic_inc(&percpu_cntr->lc_cntl.la_entry); - 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; - cfs_atomic_inc(&percpu_cntr->lc_cntl.la_exit); - } - } - - lprocfs_stats_unlock(stats); + 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); + + for (i = 0; i < num_entry; i++) { + if (stats->ls_percpu[i] == NULL) + continue; + for (j = 0; j < stats->ls_num; j++) { + percpu_cntr = &(stats->ls_percpu[i])->lp_cntr[j]; + cfs_atomic_inc(&percpu_cntr->lc_cntl.la_entry); + 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; + cfs_atomic_inc(&percpu_cntr->lc_cntl.la_exit); + } + } + + lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags); } +EXPORT_SYMBOL(lprocfs_clear_stats); static ssize_t lprocfs_stats_seq_write(struct file *file, const char *buf, size_t len, loff_t *off) @@ -1391,30 +1625,26 @@ int lprocfs_register_stats(struct proc_dir_entry *root, const char *name, return 0; } +EXPORT_SYMBOL(lprocfs_register_stats); void lprocfs_counter_init(struct lprocfs_stats *stats, int index, - unsigned conf, const char *name, const char *units) + unsigned conf, const char *name, const char *units) { - struct lprocfs_counter *c; - int i; - unsigned int num_cpu; + struct lprocfs_counter *c = &(stats->ls_percpu[0]->lp_cntr[index]); + unsigned long flags = 0; - LASSERT(stats != NULL); - - num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU); - - for (i = 0; i < num_cpu; i++) { - c = &(stats->ls_percpu[i]->lp_cntr[index]); - 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; - } + LASSERT(stats != NULL); + LASSERT(stats->ls_percpu[0] != NULL); - lprocfs_stats_unlock(stats); + 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; + lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags); } EXPORT_SYMBOL(lprocfs_counter_init); @@ -1488,7 +1718,6 @@ void lprocfs_init_ops_stats(int num_private_stats, struct lprocfs_stats *stats) 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, quota_adjust_qunit); LPROCFS_OBD_OP_INIT(num_private_stats, stats, ping); LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_new); LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_rem); @@ -1496,8 +1725,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); - LPROCFS_OBD_OP_INIT(num_private_stats, stats, sync_fs); } +EXPORT_SYMBOL(lprocfs_init_ops_stats); int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) { @@ -1536,12 +1765,14 @@ int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) } return rc; } +EXPORT_SYMBOL(lprocfs_alloc_obd_stats); void lprocfs_free_obd_stats(struct obd_device *obd) { if (obd->obd_stats) lprocfs_free_stats(&obd->obd_stats); } +EXPORT_SYMBOL(lprocfs_free_obd_stats); #define LPROCFS_MD_OP_INIT(base, stats, op) \ do { \ @@ -1585,6 +1816,7 @@ void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats) LPROCFS_MD_OP_INIT(num_private_stats, stats, intent_getattr_async); LPROCFS_MD_OP_INIT(num_private_stats, stats, revalidate_lock); } +EXPORT_SYMBOL(lprocfs_init_mps_stats); int lprocfs_alloc_md_stats(struct obd_device *obd, unsigned num_private_stats) @@ -1622,6 +1854,7 @@ int lprocfs_alloc_md_stats(struct obd_device *obd, } return rc; } +EXPORT_SYMBOL(lprocfs_alloc_md_stats); void lprocfs_free_md_stats(struct obd_device *obd) { @@ -1633,6 +1866,7 @@ void lprocfs_free_md_stats(struct obd_device *obd) lprocfs_free_stats(&stats); } } +EXPORT_SYMBOL(lprocfs_free_md_stats); void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats) { @@ -1655,6 +1889,7 @@ void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats) LDLM_GL_CALLBACK - LDLM_FIRST_OPC, 0, "ldlm_gl_callback", "reqs"); } +EXPORT_SYMBOL(lprocfs_init_ldlm_stats); int lprocfs_exp_rd_nid(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -1719,13 +1954,15 @@ int lprocfs_exp_print_hash(cfs_hash_t *hs, cfs_hash_bd_t *bd, struct exp_uuid_cb_data *data = cb_data; struct obd_export *exp = cfs_hash_object(hs, hnode); - LASSERT(hs == exp->exp_lock_hash); - if (!*data->len) { - *data->len += cfs_hash_debug_header(data->page, - data->count); + if (exp->exp_lock_hash != NULL) { + if (!*data->len) { + *data->len += cfs_hash_debug_header(data->page, + data->count); + } + *data->len += cfs_hash_debug_str(hs, data->page + *data->len, + data->count); } - *data->len += cfs_hash_debug_str(hs, data->page + *data->len, - data->count); + return 0; } @@ -1756,7 +1993,7 @@ int lprocfs_nid_stats_clear_read(char *page, char **start, off_t off, } EXPORT_SYMBOL(lprocfs_nid_stats_clear_read); -int lprocfs_nid_stats_clear_write_cb(void *obj, void *data) +static int lprocfs_nid_stats_clear_write_cb(void *obj, void *data) { struct nid_stat *stat = obj; int i; @@ -1802,8 +2039,7 @@ int lprocfs_nid_stats_clear_write(struct file *file, const char *buffer, } EXPORT_SYMBOL(lprocfs_nid_stats_clear_write); -int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int reconnect, - int *newnid) +int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid) { struct nid_stat *new_stat, *old_stat; struct obd_device *obd = NULL; @@ -1843,15 +2079,16 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int reconnect, 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) { - /* if this connects to the existing export of same nid, - * we need to release old stats for obd_disconnect won't - * balance the reference gotten in "cfs_hash_findadd_uinque" */ - if (reconnect && exp->exp_nid_stats) - nidstat_putref(old_stat); - exp->exp_nid_stats = old_stat; GOTO(destroy_new, rc = -EALREADY); } @@ -1907,6 +2144,7 @@ destroy_new: OBD_FREE_PTR(new_stat); RETURN(rc); } +EXPORT_SYMBOL(lprocfs_exp_setup); int lprocfs_exp_cleanup(struct obd_export *exp) { @@ -1920,12 +2158,14 @@ int lprocfs_exp_cleanup(struct obd_export *exp) return 0; } +EXPORT_SYMBOL(lprocfs_exp_cleanup); int lprocfs_write_helper(const char *buffer, unsigned long count, int *val) { return lprocfs_write_frac_helper(buffer, count, val, 1); } +EXPORT_SYMBOL(lprocfs_write_helper); int lprocfs_write_frac_helper(const char *buffer, unsigned long count, int *val, int mult) @@ -1968,6 +2208,7 @@ int lprocfs_write_frac_helper(const char *buffer, unsigned long count, } return 0; } +EXPORT_SYMBOL(lprocfs_write_frac_helper); int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val, int mult) @@ -2022,11 +2263,13 @@ int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val, buffer[prtn++] ='\n'; return prtn; } +EXPORT_SYMBOL(lprocfs_read_frac_helper); int lprocfs_write_u64_helper(const char *buffer, unsigned long count,__u64 *val) { return lprocfs_write_frac_u64_helper(buffer, count, val, 1); } +EXPORT_SYMBOL(lprocfs_write_u64_helper); int lprocfs_write_frac_u64_helper(const char *buffer, unsigned long count, __u64 *val, int mult) @@ -2088,6 +2331,53 @@ int lprocfs_write_frac_u64_helper(const char *buffer, unsigned long count, *val = whole * mult + frac; return 0; } +EXPORT_SYMBOL(lprocfs_write_frac_u64_helper); + +static char *lprocfs_strnstr(const char *s1, const char *s2, size_t len) +{ + size_t l2; + + l2 = strlen(s2); + if (!l2) + return (char *)s1; + while (len >= l2) { + len--; + if (!memcmp(s1, s2, l2)) + return (char *)s1; + s1++; + } + return NULL; +} + +/** + * Find the string \a name in the input \a buffer, and return a pointer to the + * value immediately following \a name, reducing \a count appropriately. + * If \a name is not found the original \a buffer is returned. + */ +char *lprocfs_find_named_value(const char *buffer, const char *name, + unsigned long *count) +{ + char *val; + size_t buflen = *count; + + /* there is no strnstr() in rhel5 and ubuntu kernels */ + val = lprocfs_strnstr(buffer, name, buflen); + if (val == NULL) + return (char *)buffer; + + val += strlen(name); /* skip prefix */ + while (val < buffer + buflen && isspace(*val)) /* skip separator */ + val++; + + *count = 0; + while (val < buffer + buflen && isalnum(*val)) { + ++*count; + ++val; + } + + return val - *count; +} +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) @@ -2174,11 +2464,6 @@ int lprocfs_obd_rd_hash(char *page, char **start, off_t off, c += cfs_hash_debug_str(obd->obd_uuid_hash, page + c, count - c); c += cfs_hash_debug_str(obd->obd_nid_hash, page + c, count - c); c += cfs_hash_debug_str(obd->obd_nid_stats_hash, page+c, count-c); -#ifdef HAVE_QUOTA_SUPPORT - if (obd->u.obt.obt_qctxt.lqc_lqs_hash) - c += cfs_hash_debug_str(obd->u.obt.obt_qctxt.lqc_lqs_hash, - page + c, count - c); -#endif return c; } @@ -2245,8 +2530,13 @@ int lprocfs_obd_rd_recovery_status(char *page, char **start, off_t off, "last_transno: "LPD64"\n", obd->obd_next_recovery_transno - 1)<=0) goto out; - if (lprocfs_obd_snprintf(&page, size, &len, "VBR: %s\n", - obd->obd_version_recov ? "ON" : "OFF")<=0) + if (lprocfs_obd_snprintf(&page, size, &len, "VBR: %s\n", + obd->obd_version_recov ? + "ENABLED" : "DISABLED") <=0) + goto out; + if (lprocfs_obd_snprintf(&page, size, &len, "IR: %s\n", + obd->obd_no_ir ? + "DISABLED" : "ENABLED") <= 0) goto out; goto fclose; } @@ -2257,11 +2547,15 @@ int lprocfs_obd_rd_recovery_status(char *page, char **start, off_t off, obd->obd_recovery_start) <= 0) goto out; if (lprocfs_obd_snprintf(&page, size, &len, "time_remaining: %lu\n", - cfs_time_current_sec() >= obd->obd_recovery_end ? 0 : - obd->obd_recovery_end - cfs_time_current_sec()) <= 0) + cfs_time_current_sec() >= + obd->obd_recovery_start + + obd->obd_recovery_timeout ? 0 : + obd->obd_recovery_start + + obd->obd_recovery_timeout - + cfs_time_current_sec()) <= 0) goto out; if (lprocfs_obd_snprintf(&page, size, &len,"connected_clients: %d/%d\n", - obd->obd_connected_clients, + cfs_atomic_read(&obd->obd_connected_clients), obd->obd_max_recoverable_clients) <= 0) goto out; /* Number of clients that have completed recovery */ @@ -2274,7 +2568,7 @@ int lprocfs_obd_rd_recovery_status(char *page, char **start, off_t off, <=0) goto out; if (lprocfs_obd_snprintf(&page, size, &len,"completed_clients: %d\n", - obd->obd_connected_clients - + cfs_atomic_read(&obd->obd_connected_clients) - cfs_atomic_read(&obd->obd_lock_replay_clients)) <=0) goto out; @@ -2299,6 +2593,36 @@ out: } EXPORT_SYMBOL(lprocfs_obd_rd_recovery_status); +int lprocfs_obd_rd_ir_factor(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct obd_device *obd = (struct obd_device *)data; + LASSERT(obd != NULL); + + return snprintf(page, count, "%d\n", + obd->obd_recovery_ir_factor); +} +EXPORT_SYMBOL(lprocfs_obd_rd_ir_factor); + +int lprocfs_obd_wr_ir_factor(struct file *file, const char *buffer, + unsigned long count, void *data) +{ + struct obd_device *obd = (struct obd_device *)data; + int val, rc; + LASSERT(obd != NULL); + + rc = lprocfs_write_helper(buffer, count, &val); + if (rc) + return rc; + + if (val < OBD_IR_FACTOR_MIN || val > OBD_IR_FACTOR_MAX) + return -EINVAL; + + obd->obd_recovery_ir_factor = val; + return count; +} +EXPORT_SYMBOL(lprocfs_obd_wr_ir_factor); + int lprocfs_obd_rd_recovery_time_soft(char *page, char **start, off_t off, int count, int *eof, void *data) { @@ -2332,7 +2656,7 @@ int lprocfs_obd_rd_recovery_time_hard(char *page, char **start, off_t off, struct obd_device *obd = data; LASSERT(obd != NULL); - return snprintf(page, count, "%lu\n", obd->obd_recovery_time_hard); + return snprintf(page, count, "%u\n", obd->obd_recovery_time_hard); } EXPORT_SYMBOL(lprocfs_obd_rd_recovery_time_hard); @@ -2355,67 +2679,40 @@ 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 obd_device *obd = (struct obd_device *)data; - LASSERT(obd != NULL); - LASSERT(obd->u.obt.obt_vfsmnt->mnt_devname); - *eof = 1; - return snprintf(page, count, "%s\n", - obd->u.obt.obt_vfsmnt->mnt_devname); + 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); -EXPORT_SYMBOL(lprocfs_register); -EXPORT_SYMBOL(lprocfs_srch); -EXPORT_SYMBOL(lprocfs_remove); -EXPORT_SYMBOL(lprocfs_remove_proc_entry); -EXPORT_SYMBOL(lprocfs_add_vars); -EXPORT_SYMBOL(lprocfs_obd_setup); -EXPORT_SYMBOL(lprocfs_obd_cleanup); -EXPORT_SYMBOL(lprocfs_add_simple); -EXPORT_SYMBOL(lprocfs_add_symlink); -EXPORT_SYMBOL(lprocfs_free_per_client_stats); -EXPORT_SYMBOL(lprocfs_alloc_stats); -EXPORT_SYMBOL(lprocfs_free_stats); -EXPORT_SYMBOL(lprocfs_clear_stats); -EXPORT_SYMBOL(lprocfs_register_stats); -EXPORT_SYMBOL(lprocfs_init_ops_stats); -EXPORT_SYMBOL(lprocfs_init_mps_stats); -EXPORT_SYMBOL(lprocfs_init_ldlm_stats); -EXPORT_SYMBOL(lprocfs_alloc_obd_stats); -EXPORT_SYMBOL(lprocfs_alloc_md_stats); -EXPORT_SYMBOL(lprocfs_free_obd_stats); -EXPORT_SYMBOL(lprocfs_free_md_stats); -EXPORT_SYMBOL(lprocfs_exp_setup); -EXPORT_SYMBOL(lprocfs_exp_cleanup); +int lprocfs_obd_rd_max_pages_per_rpc(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct obd_device *dev = data; + struct client_obd *cli = &dev->u.cli; + int rc; -EXPORT_SYMBOL(lprocfs_rd_u64); -EXPORT_SYMBOL(lprocfs_rd_atomic); -EXPORT_SYMBOL(lprocfs_wr_atomic); -EXPORT_SYMBOL(lprocfs_rd_uint); -EXPORT_SYMBOL(lprocfs_wr_uint); -EXPORT_SYMBOL(lprocfs_rd_uuid); -EXPORT_SYMBOL(lprocfs_rd_name); -EXPORT_SYMBOL(lprocfs_rd_fstype); -EXPORT_SYMBOL(lprocfs_rd_server_uuid); -EXPORT_SYMBOL(lprocfs_rd_conn_uuid); -EXPORT_SYMBOL(lprocfs_rd_num_exports); -EXPORT_SYMBOL(lprocfs_rd_numrefs); -EXPORT_SYMBOL(lprocfs_at_hist_helper); -EXPORT_SYMBOL(lprocfs_rd_import); -EXPORT_SYMBOL(lprocfs_rd_state); -EXPORT_SYMBOL(lprocfs_rd_timeouts); -EXPORT_SYMBOL(lprocfs_rd_blksize); -EXPORT_SYMBOL(lprocfs_rd_kbytestotal); -EXPORT_SYMBOL(lprocfs_rd_kbytesfree); -EXPORT_SYMBOL(lprocfs_rd_kbytesavail); -EXPORT_SYMBOL(lprocfs_rd_filestotal); -EXPORT_SYMBOL(lprocfs_rd_filesfree); + client_obd_list_lock(&cli->cl_loi_list_lock); + rc = snprintf(page, count, "%d\n", cli->cl_max_pages_per_rpc); + client_obd_list_unlock(&cli->cl_loi_list_lock); + return rc; +} +EXPORT_SYMBOL(lprocfs_obd_rd_max_pages_per_rpc); -EXPORT_SYMBOL(lprocfs_write_helper); -EXPORT_SYMBOL(lprocfs_write_frac_helper); -EXPORT_SYMBOL(lprocfs_read_frac_helper); -EXPORT_SYMBOL(lprocfs_write_u64_helper); -EXPORT_SYMBOL(lprocfs_write_frac_u64_helper); -EXPORT_SYMBOL(lprocfs_stats_collect); +int lprocfs_target_rd_instance(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct obd_device *obd = (struct obd_device *)data; + struct obd_device_target *target = &obd->u.obt; + + LASSERT(obd != NULL); + LASSERT(target->obt_magic == OBT_MAGIC); + *eof = 1; + return snprintf(page, count, "%u\n", obd->u.obt.obt_instance); +} +EXPORT_SYMBOL(lprocfs_target_rd_instance); #endif /* LPROCFS*/