1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copyright (C) 2002, 2003 Cluster File Systems, Inc.
5 * Author: Hariharan Thantry <thantry@users.sourceforge.net>
7 * This file is part of Lustre, http://www.lustre.org.
9 * Lustre is free software; you can redistribute it and/or
10 * modify it under the terms of version 2 of the GNU General Public
11 * License as published by the Free Software Foundation.
13 * Lustre is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with Lustre; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 # define EXPORT_SYMTAB
26 #define DEBUG_SUBSYSTEM S_CLASS
29 # include <linux/config.h>
30 # include <linux/module.h>
31 # include <linux/version.h>
32 # include <linux/slab.h>
33 # include <linux/types.h>
34 # if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
35 # include <asm/statfs.h>
37 # include <linux/seq_file.h>
38 #else /* __KERNEL__ */
39 # include <liblustre.h>
42 #include <linux/obd_class.h>
43 #include <linux/lprocfs_status.h>
44 #include <linux/lustre_fsfilt.h>
46 #if defined(LPROCFS) && defined(__KERNEL__)
48 struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head,
51 struct proc_dir_entry *temp;
57 while (temp != NULL) {
58 if (strcmp(temp->name, name) == 0)
66 /* lprocfs API calls */
68 int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list,
71 if (root == NULL || list == NULL)
74 while (list->name != NULL) {
75 struct proc_dir_entry *cur_root, *proc;
76 char *pathcopy, *cur, *next, pathbuf[64];
77 int pathsize = strlen(list->name) + 1;
82 /* need copy of path for strsep */
83 if (strlen(list->name) > sizeof(pathbuf) - 1) {
84 OBD_ALLOC(pathcopy, pathsize);
92 strcpy(pathcopy, list->name);
94 while (cur_root != NULL && (cur = strsep(&next, "/"))) {
95 if (*cur =='\0') /* skip double/trailing "/" */
98 proc = lprocfs_srch(cur_root, cur);
99 CDEBUG(D_OTHER, "cur_root=%s, cur=%s, next=%s, (%s)\n",
100 cur_root->name, cur, next,
101 (proc ? "exists" : "new"));
103 cur_root = (proc ? proc :
104 proc_mkdir(cur, cur_root));
105 } else if (proc == NULL) {
109 if (list->write_fptr)
111 proc = create_proc_entry(cur, mode, cur_root);
115 if (pathcopy != pathbuf)
116 OBD_FREE(pathcopy, pathsize);
118 if (cur_root == NULL || proc == NULL) {
119 CERROR("LprocFS: No memory to create /proc entry %s",
124 proc->read_proc = list->read_fptr;
125 proc->write_proc = list->write_fptr;
126 proc->data = (list->data ? list->data : data);
132 void lprocfs_remove(struct proc_dir_entry *root)
134 struct proc_dir_entry *temp = root;
135 struct proc_dir_entry *rm_entry;
136 struct proc_dir_entry *parent;
138 LASSERT(root != NULL);
139 parent = root->parent;
140 LASSERT(parent != NULL);
143 while (temp->subdir != NULL)
148 remove_proc_entry(rm_entry->name, rm_entry->parent);
154 struct proc_dir_entry *lprocfs_register(const char *name,
155 struct proc_dir_entry *parent,
156 struct lprocfs_vars *list, void *data)
158 struct proc_dir_entry *newchild;
160 newchild = lprocfs_srch(parent, name);
161 if (newchild != NULL) {
162 CERROR(" Lproc: Attempting to register %s more than once \n",
164 return ERR_PTR(-EALREADY);
167 newchild = proc_mkdir(name, parent);
168 if (newchild != NULL && list != NULL) {
169 int rc = lprocfs_add_vars(newchild, list, data);
171 lprocfs_remove(newchild);
178 /* Generic callbacks */
180 int lprocfs_rd_u64(char *page, char **start, off_t off,
181 int count, int *eof, void *data)
183 LASSERT(data != NULL);
185 return snprintf(page, count, LPU64"\n", *(__u64 *)data);
188 int lprocfs_rd_uuid(char *page, char **start, off_t off, int count,
189 int *eof, void *data)
191 struct obd_device *dev = (struct obd_device*)data;
193 LASSERT(dev != NULL);
195 return snprintf(page, count, "%s\n", dev->obd_uuid.uuid);
198 int lprocfs_rd_name(char *page, char **start, off_t off, int count,
199 int *eof, void* data)
201 struct obd_device *dev = (struct obd_device *)data;
203 LASSERT(dev != NULL);
204 LASSERT(dev->obd_name != NULL);
206 return snprintf(page, count, "%s\n", dev->obd_name);
209 int lprocfs_rd_fstype(char *page, char **start, off_t off, int count, int *eof,
212 struct obd_device *obd = (struct obd_device *)data;
214 LASSERT(obd != NULL);
215 LASSERT(obd->obd_fsops != NULL);
216 LASSERT(obd->obd_fsops->fs_type != NULL);
217 return snprintf(page, count, "%s\n", obd->obd_fsops->fs_type);
220 int lprocfs_rd_blksize(char *page, char **start, off_t off, int count,
221 int *eof, void *data)
223 struct obd_statfs osfs;
224 int rc = obd_statfs(data, &osfs, jiffies - HZ);
227 rc = snprintf(page, count, "%u\n", osfs.os_bsize);
232 int lprocfs_rd_kbytestotal(char *page, char **start, off_t off, int count,
233 int *eof, void *data)
235 struct obd_statfs osfs;
236 int rc = obd_statfs(data, &osfs, jiffies - HZ);
238 __u32 blk_size = osfs.os_bsize >> 10;
239 __u64 result = osfs.os_blocks;
241 while (blk_size >>= 1)
245 rc = snprintf(page, count, LPU64"\n", result);
250 int lprocfs_rd_kbytesfree(char *page, char **start, off_t off, int count,
251 int *eof, void *data)
253 struct obd_statfs osfs;
254 int rc = obd_statfs(data, &osfs, jiffies - HZ);
256 __u32 blk_size = osfs.os_bsize >> 10;
257 __u64 result = osfs.os_bfree;
259 while (blk_size >>= 1)
263 rc = snprintf(page, count, LPU64"\n", result);
268 int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, int count,
269 int *eof, void *data)
271 struct obd_statfs osfs;
272 int rc = obd_statfs(data, &osfs, jiffies - HZ);
274 __u32 blk_size = osfs.os_bsize >> 10;
275 __u64 result = osfs.os_bavail;
277 while (blk_size >>= 1)
281 rc = snprintf(page, count, LPU64"\n", result);
286 int lprocfs_rd_filestotal(char *page, char **start, off_t off, int count,
287 int *eof, void *data)
289 struct obd_statfs osfs;
290 int rc = obd_statfs(data, &osfs, jiffies - HZ);
293 rc = snprintf(page, count, LPU64"\n", osfs.os_files);
299 int lprocfs_rd_filesfree(char *page, char **start, off_t off, int count,
300 int *eof, void *data)
302 struct obd_statfs osfs;
303 int rc = obd_statfs(data, &osfs, jiffies - HZ);
306 rc = snprintf(page, count, LPU64"\n", osfs.os_ffree);
311 int lprocfs_rd_filegroups(char *page, char **start, off_t off, int count,
312 int *eof, void *data)
315 return snprintf(page, count, "unimplemented\n");
318 int lprocfs_rd_server_uuid(char *page, char **start, off_t off, int count,
319 int *eof, void *data)
321 struct obd_device *obd = (struct obd_device *)data;
322 struct obd_import *imp;
323 char *imp_state_name = NULL;
325 LASSERT(obd != NULL);
326 imp = obd->u.cli.cl_import;
327 imp_state_name = ptlrpc_import_state_name(imp->imp_state);
329 return snprintf(page, count, "%s\t%s\n",
330 imp->imp_target_uuid.uuid, imp_state_name);
333 int lprocfs_rd_conn_uuid(char *page, char **start, off_t off, int count,
334 int *eof, void *data)
336 struct obd_device *obd = (struct obd_device*)data;
337 struct ptlrpc_connection *conn;
339 LASSERT(obd != NULL);
340 conn = obd->u.cli.cl_import->imp_connection;
341 LASSERT(conn != NULL);
343 return snprintf(page, count, "%s\n", conn->c_remote_uuid.uuid);
346 int lprocfs_rd_numrefs(char *page, char **start, off_t off, int count,
347 int *eof, void *data)
349 struct obd_type *class = (struct obd_type*) data;
351 LASSERT(class != NULL);
353 return snprintf(page, count, "%d\n", class->typ_refcnt);
356 int lprocfs_obd_attach(struct obd_device *dev, struct lprocfs_vars *list)
360 LASSERT(dev != NULL);
361 LASSERT(dev->obd_type != NULL);
362 LASSERT(dev->obd_type->typ_procroot != NULL);
364 dev->obd_proc_entry = lprocfs_register(dev->obd_name,
365 dev->obd_type->typ_procroot,
367 if (IS_ERR(dev->obd_proc_entry)) {
368 rc = PTR_ERR(dev->obd_proc_entry);
369 dev->obd_proc_entry = NULL;
374 int lprocfs_obd_detach(struct obd_device *dev)
376 if (dev && dev->obd_proc_entry) {
377 lprocfs_remove(dev->obd_proc_entry);
378 dev->obd_proc_entry = NULL;
383 struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num)
385 struct lprocfs_stats *stats;
386 struct lprocfs_percpu *percpu;
387 unsigned int percpusize;
393 OBD_ALLOC(stats, offsetof(typeof(*stats), ls_percpu[num_online_cpus()]));
397 percpusize = L1_CACHE_ALIGN(offsetof(typeof(*percpu), lp_cntr[num]));
398 stats->ls_percpu_size = num_online_cpus() * percpusize;
399 OBD_ALLOC(stats->ls_percpu[0], stats->ls_percpu_size);
400 if (stats->ls_percpu[0] == NULL) {
401 OBD_FREE(stats, offsetof(typeof(*stats),
402 ls_percpu[num_online_cpus()]));
407 for (i = 1; i < num_online_cpus(); i++)
408 stats->ls_percpu[i] = (void *)(stats->ls_percpu[i - 1]) +
414 void lprocfs_free_stats(struct lprocfs_stats *stats)
416 if (stats->ls_num == 0)
419 OBD_FREE(stats->ls_percpu[0], stats->ls_percpu_size);
420 OBD_FREE(stats, offsetof(typeof(*stats), ls_percpu[num_online_cpus()]));
423 /* Reset counter under lock */
424 int lprocfs_counter_write(struct file *file, const char *buffer,
425 unsigned long count, void *data)
431 static void *lprocfs_stats_seq_start(struct seq_file *p, loff_t *pos)
433 struct lprocfs_stats *stats = p->private;
434 /* return 1st cpu location */
435 return (*pos >= stats->ls_num) ? NULL :
436 &(stats->ls_percpu[0]->lp_cntr[*pos]);
439 static void lprocfs_stats_seq_stop(struct seq_file *p, void *v)
443 static void *lprocfs_stats_seq_next(struct seq_file *p, void *v, loff_t *pos)
445 struct lprocfs_stats *stats = p->private;
447 return (*pos >= stats->ls_num) ? NULL :
448 &(stats->ls_percpu[0]->lp_cntr[*pos]);
451 /* seq file export of one lprocfs counter */
452 static int lprocfs_stats_seq_show(struct seq_file *p, void *v)
454 struct lprocfs_stats *stats = p->private;
455 struct lprocfs_counter *cntr = v;
456 struct lprocfs_counter t, ret = { .lc_min = ~(__u64)0 };
459 if (cntr == &(stats->ls_percpu[0])->lp_cntr[0]) {
461 do_gettimeofday(&now);
462 rc = seq_printf(p, "%-25s %lu.%lu secs.usecs\n",
463 "snapshot_time", now.tv_sec, now.tv_usec);
467 idx = cntr - &(stats->ls_percpu[0])->lp_cntr[0];
469 for (i = 0; i < num_online_cpus(); i++) {
470 struct lprocfs_counter *percpu_cntr =
471 &(stats->ls_percpu[i])->lp_cntr[idx];
475 centry = atomic_read(&percpu_cntr->lc_cntl.la_entry);
476 t.lc_count = percpu_cntr->lc_count;
477 t.lc_sum = percpu_cntr->lc_sum;
478 t.lc_min = percpu_cntr->lc_min;
479 t.lc_max = percpu_cntr->lc_max;
480 t.lc_sumsquare = percpu_cntr->lc_sumsquare;
481 } while (centry != atomic_read(&percpu_cntr->lc_cntl.la_entry) &&
482 centry != atomic_read(&percpu_cntr->lc_cntl.la_exit));
483 ret.lc_count += t.lc_count;
484 ret.lc_sum += t.lc_sum;
485 if (t.lc_min < ret.lc_min)
486 ret.lc_min = t.lc_min;
487 if (t.lc_max > ret.lc_max)
488 ret.lc_max = t.lc_max;
489 ret.lc_sumsquare += t.lc_sumsquare;
492 rc = seq_printf(p, "%-25s "LPU64" samples [%s]", cntr->lc_name,
493 ret.lc_count, cntr->lc_units);
497 if ((cntr->lc_config & LPROCFS_CNTR_AVGMINMAX) && (ret.lc_count > 0)) {
498 rc = seq_printf(p, " "LPU64" "LPU64" "LPU64,
499 ret.lc_min, ret.lc_max, ret.lc_sum);
502 if (cntr->lc_config & LPROCFS_CNTR_STDDEV)
503 rc = seq_printf(p, " "LPU64, ret.lc_sumsquare);
507 rc = seq_printf(p, "\n");
509 return (rc < 0) ? rc : 0;
512 struct seq_operations lprocfs_stats_seq_sops = {
513 start: lprocfs_stats_seq_start,
514 stop: lprocfs_stats_seq_stop,
515 next: lprocfs_stats_seq_next,
516 show: lprocfs_stats_seq_show,
519 static int lprocfs_stats_seq_open(struct inode *inode, struct file *file)
521 struct proc_dir_entry *dp = PDE(inode);
522 struct seq_file *seq;
525 rc = seq_open(file, &lprocfs_stats_seq_sops);
528 seq = file->private_data;
529 seq->private = dp->data;
533 struct file_operations lprocfs_stats_seq_fops = {
534 open: lprocfs_stats_seq_open,
537 release: seq_release,
540 int lprocfs_register_stats(struct proc_dir_entry *root, const char *name,
541 struct lprocfs_stats *stats)
543 struct proc_dir_entry *entry;
544 LASSERT(root != NULL);
546 entry = create_proc_entry(name, 0444, root);
549 entry->proc_fops = &lprocfs_stats_seq_fops;
550 entry->data = (void *)stats;
551 entry->write_proc = lprocfs_counter_write;
555 void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
556 unsigned conf, const char *name, const char *units)
558 struct lprocfs_counter *c;
561 LASSERT(stats != NULL);
562 for (i = 0; i < num_online_cpus(); i++) {
563 c = &(stats->ls_percpu[i]->lp_cntr[index]);
565 c->lc_min = ~(__u64)0;
570 EXPORT_SYMBOL(lprocfs_counter_init);
572 #define LPROCFS_OBD_OP_INIT(base, stats, op) \
574 unsigned int coffset = base + OBD_COUNTER_OFFSET(op); \
575 LASSERT(coffset < stats->ls_num); \
576 lprocfs_counter_init(stats, coffset, 0, #op, "reqs"); \
579 int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats)
581 struct lprocfs_stats *stats;
582 unsigned int num_stats;
585 LASSERT(obd->obd_stats == NULL);
586 LASSERT(obd->obd_proc_entry != NULL);
587 LASSERT(obd->obd_cntr_base == 0);
589 num_stats = 1 + OBD_COUNTER_OFFSET(notify) +
591 stats = lprocfs_alloc_stats(num_stats);
595 LPROCFS_OBD_OP_INIT(num_private_stats, stats, iocontrol);
596 LPROCFS_OBD_OP_INIT(num_private_stats, stats, get_info);
597 LPROCFS_OBD_OP_INIT(num_private_stats, stats, set_info);
598 LPROCFS_OBD_OP_INIT(num_private_stats, stats, attach);
599 LPROCFS_OBD_OP_INIT(num_private_stats, stats, detach);
600 LPROCFS_OBD_OP_INIT(num_private_stats, stats, setup);
601 LPROCFS_OBD_OP_INIT(num_private_stats, stats, precleanup);
602 LPROCFS_OBD_OP_INIT(num_private_stats, stats, cleanup);
603 LPROCFS_OBD_OP_INIT(num_private_stats, stats, postrecov);
604 LPROCFS_OBD_OP_INIT(num_private_stats, stats, connect);
605 LPROCFS_OBD_OP_INIT(num_private_stats, stats, disconnect);
606 LPROCFS_OBD_OP_INIT(num_private_stats, stats, statfs);
607 LPROCFS_OBD_OP_INIT(num_private_stats, stats, packmd);
608 LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpackmd);
609 LPROCFS_OBD_OP_INIT(num_private_stats, stats, preallocate);
610 LPROCFS_OBD_OP_INIT(num_private_stats, stats, create);
611 LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy);
612 LPROCFS_OBD_OP_INIT(num_private_stats, stats, setattr);
613 LPROCFS_OBD_OP_INIT(num_private_stats, stats, getattr);
614 LPROCFS_OBD_OP_INIT(num_private_stats, stats, getattr_async);
615 LPROCFS_OBD_OP_INIT(num_private_stats, stats, brw);
616 LPROCFS_OBD_OP_INIT(num_private_stats, stats, brw_async);
617 LPROCFS_OBD_OP_INIT(num_private_stats, stats, prep_async_page);
618 LPROCFS_OBD_OP_INIT(num_private_stats, stats, queue_async_io);
619 LPROCFS_OBD_OP_INIT(num_private_stats, stats, set_async_flags);
620 LPROCFS_OBD_OP_INIT(num_private_stats, stats, queue_sync_io);
621 LPROCFS_OBD_OP_INIT(num_private_stats, stats, trigger_sync_io);
622 LPROCFS_OBD_OP_INIT(num_private_stats, stats, teardown_async_page);
623 LPROCFS_OBD_OP_INIT(num_private_stats, stats, punch);
624 LPROCFS_OBD_OP_INIT(num_private_stats, stats, sync);
625 LPROCFS_OBD_OP_INIT(num_private_stats, stats, migrate);
626 LPROCFS_OBD_OP_INIT(num_private_stats, stats, copy);
627 LPROCFS_OBD_OP_INIT(num_private_stats, stats, iterate);
628 LPROCFS_OBD_OP_INIT(num_private_stats, stats, preprw);
629 LPROCFS_OBD_OP_INIT(num_private_stats, stats, commitrw);
630 LPROCFS_OBD_OP_INIT(num_private_stats, stats, enqueue);
631 LPROCFS_OBD_OP_INIT(num_private_stats, stats, match);
632 LPROCFS_OBD_OP_INIT(num_private_stats, stats, change_cbdata);
633 LPROCFS_OBD_OP_INIT(num_private_stats, stats, cancel);
634 LPROCFS_OBD_OP_INIT(num_private_stats, stats, cancel_unused);
635 LPROCFS_OBD_OP_INIT(num_private_stats, stats, san_preprw);
636 LPROCFS_OBD_OP_INIT(num_private_stats, stats, init_export);
637 LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy_export);
638 LPROCFS_OBD_OP_INIT(num_private_stats, stats, lock_contains);
639 LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_init);
640 LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_finish);
641 LPROCFS_OBD_OP_INIT(num_private_stats, stats, pin);
642 LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpin);
643 LPROCFS_OBD_OP_INIT(num_private_stats, stats, invalidate_import);
644 LPROCFS_OBD_OP_INIT(num_private_stats, stats, notify);
646 for (i = num_private_stats; i < num_stats; i++) {
647 /* If this LBUGs, it is likely that an obd
648 * operation was added to struct obd_ops in
649 * <linux/obd.h>, and that the corresponding line item
650 * LPROCFS_OBD_OP_INIT(.., .., opname)
651 * is missing from the list above. */
652 if (stats->ls_percpu[0]->lp_cntr[i].lc_name == NULL) {
653 CERROR("Missing obd_stat initializer obd_op "
654 "operation at offset %d. Aborting.\n",
655 i - num_private_stats);
659 rc = lprocfs_register_stats(obd->obd_proc_entry, "stats", stats);
661 lprocfs_free_stats(stats);
663 obd->obd_stats = stats;
664 obd->obd_cntr_base = num_private_stats;
669 void lprocfs_free_obd_stats(struct obd_device *obd)
671 struct lprocfs_stats *stats = obd->obd_stats;
674 obd->obd_stats = NULL;
675 lprocfs_free_stats(stats);
679 int lprocfs_write_helper(const char *buffer, unsigned long count,
682 char kernbuf[20], *end;
684 if (count > (sizeof(kernbuf) - 1))
687 if (copy_from_user(kernbuf, buffer, count))
690 kernbuf[count] = '\0';
692 *val = simple_strtol(kernbuf, &end, 0);
699 int lprocfs_write_u64_helper(const char *buffer, unsigned long count,
702 char kernbuf[22], *end;
704 if (count > (sizeof(kernbuf) - 1))
707 if (copy_from_user(kernbuf, buffer, count))
710 kernbuf[count] = '\0';
712 *val = simple_strtoull(kernbuf, &end, 0);
719 int lprocfs_obd_seq_create(struct obd_device *dev, char *name, mode_t mode,
720 struct file_operations *seq_fops, void *data)
722 struct proc_dir_entry *entry;
725 entry = create_proc_entry(name, mode, dev->obd_proc_entry);
728 entry->proc_fops = seq_fops;
733 EXPORT_SYMBOL(lprocfs_obd_seq_create);
735 void lprocfs_oh_tally(struct obd_histogram *oh, unsigned int value)
739 if (value >= OBD_HIST_MAX)
740 value = OBD_HIST_MAX - 1;
742 spin_lock_irqsave(&oh->oh_lock, flags);
743 oh->oh_buckets[value]++;
744 spin_unlock_irqrestore(&oh->oh_lock, flags);
746 EXPORT_SYMBOL(lprocfs_oh_tally);
748 void lprocfs_oh_tally_log2(struct obd_histogram *oh, unsigned int value)
752 for (val = 0; ((1 << val) < value) && (val <= OBD_HIST_MAX); val++)
755 lprocfs_oh_tally(oh, val);
757 EXPORT_SYMBOL(lprocfs_oh_tally_log2);
759 unsigned long lprocfs_oh_sum(struct obd_histogram *oh)
761 unsigned long ret = 0;
764 for (i = 0; i < OBD_HIST_MAX; i++)
765 ret += oh->oh_buckets[i];
768 EXPORT_SYMBOL(lprocfs_oh_sum);
770 void lprocfs_oh_clear(struct obd_histogram *oh)
773 spin_lock_irqsave(&oh->oh_lock, flags);
774 memset(oh->oh_buckets, 0, sizeof(oh->oh_buckets));
775 spin_unlock_irqrestore(&oh->oh_lock, flags);
777 EXPORT_SYMBOL(lprocfs_oh_clear);
781 EXPORT_SYMBOL(lprocfs_register);
782 EXPORT_SYMBOL(lprocfs_srch);
783 EXPORT_SYMBOL(lprocfs_remove);
784 EXPORT_SYMBOL(lprocfs_add_vars);
785 EXPORT_SYMBOL(lprocfs_obd_attach);
786 EXPORT_SYMBOL(lprocfs_obd_detach);
787 EXPORT_SYMBOL(lprocfs_alloc_stats);
788 EXPORT_SYMBOL(lprocfs_free_stats);
789 EXPORT_SYMBOL(lprocfs_register_stats);
790 EXPORT_SYMBOL(lprocfs_alloc_obd_stats);
791 EXPORT_SYMBOL(lprocfs_free_obd_stats);
793 EXPORT_SYMBOL(lprocfs_rd_u64);
794 EXPORT_SYMBOL(lprocfs_rd_uuid);
795 EXPORT_SYMBOL(lprocfs_rd_name);
796 EXPORT_SYMBOL(lprocfs_rd_fstype);
797 EXPORT_SYMBOL(lprocfs_rd_server_uuid);
798 EXPORT_SYMBOL(lprocfs_rd_conn_uuid);
799 EXPORT_SYMBOL(lprocfs_rd_numrefs);
801 EXPORT_SYMBOL(lprocfs_rd_blksize);
802 EXPORT_SYMBOL(lprocfs_rd_kbytestotal);
803 EXPORT_SYMBOL(lprocfs_rd_kbytesfree);
804 EXPORT_SYMBOL(lprocfs_rd_kbytesavail);
805 EXPORT_SYMBOL(lprocfs_rd_filestotal);
806 EXPORT_SYMBOL(lprocfs_rd_filesfree);
807 EXPORT_SYMBOL(lprocfs_rd_filegroups);
809 EXPORT_SYMBOL(lprocfs_write_helper);
810 EXPORT_SYMBOL(lprocfs_write_u64_helper);