X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=dc595f5d5e194f492ce1f6be858f25379a5d3999;hb=bf959135d50c2e7e3d4414a6792f63665c6da22c;hp=0eac9eabba58f30cdcc4e4917133440aedea5f3a;hpb=fff2c3277d4c4fe6aaa5d5c2085892a6543c4730;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index 0eac9ea..dc595f5 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(); @@ -68,28 +77,37 @@ int lprocfs_seq_release(struct inode *inode, struct file *file) } EXPORT_SYMBOL(lprocfs_seq_release); -struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head, - const char *name) +static struct proc_dir_entry *__lprocfs_srch(struct proc_dir_entry *head, + const char *name) { struct proc_dir_entry *temp; if (head == NULL) return NULL; - LPROCFS_ENTRY(); temp = head->subdir; while (temp != NULL) { if (strcmp(temp->name, name) == 0) { - LPROCFS_EXIT(); return temp; } temp = temp->next; } - LPROCFS_EXIT(); return NULL; } +struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head, + const char *name) +{ + struct proc_dir_entry *temp; + + LPROCFS_SRCH_ENTRY(); + temp = __lprocfs_srch(head, name); + LPROCFS_SRCH_EXIT(); + return temp; +} +EXPORT_SYMBOL(lprocfs_srch); + /* lprocfs API calls */ /* Function that emulates snprintf but also has the side effect of advancing @@ -131,9 +149,11 @@ cfs_proc_dir_entry_t *lprocfs_add_simple(struct proc_dir_entry *root, mode |= 0200; if (fops) mode = 0644; + LPROCFS_WRITE_ENTRY(); proc = create_proc_entry(name, mode, root); if (!proc) { CERROR("LprocFS: No memory to create /proc entry %s", name); + LPROCFS_WRITE_EXIT(); return ERR_PTR(-ENOMEM); } proc->read_proc = read_proc; @@ -141,8 +161,10 @@ cfs_proc_dir_entry_t *lprocfs_add_simple(struct proc_dir_entry *root, proc->data = data; if (fops) proc->proc_fops = fops; + 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, ...) @@ -170,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) @@ -288,9 +311,12 @@ EXPORT_SYMBOL(lprocfs_evict_client_fops); 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]; @@ -303,7 +329,7 @@ int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, if (strlen(list->name) > sizeof(pathbuf) - 1) { OBD_ALLOC(pathcopy, pathsize); if (pathcopy == NULL) - return -ENOMEM; + GOTO(out, rc = -ENOMEM); } else { pathcopy = pathbuf; } @@ -315,7 +341,7 @@ int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, if (*cur =='\0') /* skip double/trailing "/" */ continue; - proc = lprocfs_srch(cur_root, cur); + proc = __lprocfs_srch(cur_root, cur); CDEBUG(D_OTHER, "cur_root=%s, cur=%s, next=%s, (%s)\n", cur_root->name, cur, next, (proc ? "exists" : "new")); @@ -342,7 +368,7 @@ int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, if (cur_root == NULL || proc == NULL) { CERROR("LprocFS: No memory to create /proc entry %s", list->name); - return -ENOMEM; + GOTO(out, rc = -ENOMEM); } if (list->fops) @@ -354,10 +380,13 @@ int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, proc->data = (list->data ? list->data : data); list++; } - return 0; +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; @@ -370,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) @@ -385,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, @@ -424,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, @@ -432,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) @@ -451,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) @@ -459,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) @@ -468,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) @@ -486,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) @@ -496,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) @@ -507,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) @@ -518,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) { @@ -532,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) { @@ -552,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) { @@ -572,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) { @@ -592,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) { @@ -607,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) { @@ -621,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) @@ -642,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) @@ -665,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)); @@ -685,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-> \ @@ -714,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. @@ -777,10 +1003,22 @@ static const char *obd_connect_names[] = { "large_ea", "full20", "layout_lock", + "64bithash", + "object_max_bytes", + "imp_recov", + "jobstats", + "umask", + "einprogress", + "grant_param", + "nanoseconds_times", + "lvb_type", + "unknown", + "lightweight_conn", + "short_io", 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; @@ -796,6 +1034,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) @@ -816,10 +1055,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, ", "); @@ -839,17 +1080,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) { @@ -931,6 +1173,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) @@ -962,6 +1205,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) @@ -972,6 +1216,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, @@ -1025,6 +1270,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) @@ -1052,6 +1298,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) @@ -1062,6 +1309,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) { @@ -1081,6 +1329,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) { @@ -1098,6 +1347,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) { @@ -1106,10 +1356,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); @@ -1130,120 +1378,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) @@ -1361,37 +1610,40 @@ int lprocfs_register_stats(struct proc_dir_entry *root, const char *name, struct proc_dir_entry *entry; LASSERT(root != NULL); + LPROCFS_WRITE_ENTRY(); entry = create_proc_entry(name, 0644, root); + if (entry) { + entry->proc_fops = &lprocfs_stats_seq_fops; + entry->data = stats; + } + + LPROCFS_WRITE_EXIT(); + if (entry == NULL) return -ENOMEM; - entry->proc_fops = &lprocfs_stats_seq_fops; - entry->data = stats; + 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); + LASSERT(stats != NULL); + LASSERT(stats->ls_percpu[0] != 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; - } - - 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); @@ -1465,7 +1717,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); @@ -1474,6 +1725,7 @@ void lprocfs_init_ops_stats(int num_private_stats, struct lprocfs_stats *stats) LPROCFS_OBD_OP_INIT(num_private_stats, stats, getref); LPROCFS_OBD_OP_INIT(num_private_stats, stats, putref); } +EXPORT_SYMBOL(lprocfs_init_ops_stats); int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) { @@ -1512,12 +1764,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 { \ @@ -1526,23 +1780,8 @@ do { \ lprocfs_counter_init(stats, coffset, 0, #op, "reqs"); \ } while (0) -int lprocfs_alloc_md_stats(struct obd_device *obd, - unsigned num_private_stats) +void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats) { - struct lprocfs_stats *stats; - unsigned int num_stats; - int rc, i; - - LASSERT(obd->md_stats == NULL); - LASSERT(obd->obd_proc_entry != NULL); - LASSERT(obd->md_cntr_base == 0); - - num_stats = 1 + MD_COUNTER_OFFSET(revalidate_lock) + - num_private_stats; - stats = lprocfs_alloc_stats(num_stats, 0); - if (stats == NULL) - return -ENOMEM; - 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, find_cbdata); @@ -1575,6 +1814,27 @@ int lprocfs_alloc_md_stats(struct obd_device *obd, LPROCFS_MD_OP_INIT(num_private_stats, stats, get_remote_perm); 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) +{ + struct lprocfs_stats *stats; + unsigned int num_stats; + int rc, i; + + LASSERT(obd->md_stats == NULL); + LASSERT(obd->obd_proc_entry != NULL); + LASSERT(obd->md_cntr_base == 0); + + num_stats = 1 + MD_COUNTER_OFFSET(revalidate_lock) + + num_private_stats; + stats = lprocfs_alloc_stats(num_stats, 0); + if (stats == NULL) + return -ENOMEM; + + lprocfs_init_mps_stats(num_private_stats, stats); for (i = num_private_stats; i < num_stats; i++) { if (stats->ls_percpu[0]->lp_cntr[i].lc_name == NULL) { @@ -1593,6 +1853,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) { @@ -1604,6 +1865,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) { @@ -1626,6 +1888,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) @@ -1690,13 +1953,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; } @@ -1727,15 +1992,15 @@ 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; ENTRY; - /* object has only hash + iterate_all references. - * add/delete blocked by hash bucket lock */ + CDEBUG(D_INFO,"refcnt %d\n", cfs_atomic_read(&stat->nid_exp_ref_count)); - if (cfs_atomic_read(&stat->nid_exp_ref_count) == 2) { + if (cfs_atomic_read(&stat->nid_exp_ref_count) == 1) { + /* object has only hash references. */ cfs_spin_lock(&stat->nid_obd->obd_nid_lock); cfs_list_move(&stat->nid_list, data); cfs_spin_unlock(&stat->nid_obd->obd_nid_lock); @@ -1773,8 +2038,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; @@ -1814,15 +2078,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); } @@ -1878,6 +2143,7 @@ destroy_new: OBD_FREE_PTR(new_stat); RETURN(rc); } +EXPORT_SYMBOL(lprocfs_exp_setup); int lprocfs_exp_cleanup(struct obd_export *exp) { @@ -1891,12 +2157,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) @@ -1939,6 +2207,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) @@ -1993,11 +2262,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) @@ -2059,6 +2330,7 @@ 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); int lprocfs_seq_create(cfs_proc_dir_entry_t *parent, char *name, mode_t mode, struct file_operations *seq_fops, void *data) @@ -2066,11 +2338,16 @@ int lprocfs_seq_create(cfs_proc_dir_entry_t *parent, char *name, mode_t mode, struct proc_dir_entry *entry; ENTRY; + LPROCFS_WRITE_ENTRY(); entry = create_proc_entry(name, mode, parent); + if (entry) { + entry->proc_fops = seq_fops; + entry->data = data; + } + LPROCFS_WRITE_EXIT(); + if (entry == NULL) RETURN(-ENOMEM); - entry->proc_fops = seq_fops; - entry->data = data; RETURN(0); } @@ -2140,11 +2417,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; } @@ -2211,8 +2483,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; } @@ -2223,11 +2500,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 */ @@ -2240,7 +2521,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; @@ -2265,6 +2546,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) { @@ -2298,7 +2609,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); @@ -2321,66 +2632,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_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*/