Whamcloud - gitweb
a90a6e108b27407c822c5ff101c61e13c179eb7d
[fs/lustre-release.git] / lustre / obdclass / lprocfs_status.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  Copyright (C) 2002, 2003 Cluster File Systems, Inc.
5  *   Author: Hariharan Thantry <thantry@users.sourceforge.net>
6  *
7  *   This file is part of Lustre, http://www.lustre.org.
8  *
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.
12  *
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.
17  *
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.
21  */
22
23 #ifndef EXPORT_SYMTAB
24 # define EXPORT_SYMTAB
25 #endif
26 #define DEBUG_SUBSYSTEM S_CLASS
27
28 #ifdef __KERNEL__
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>
36 # endif
37 # include <linux/seq_file.h>
38 #else /* __KERNEL__ */
39 # include <liblustre.h>
40 #endif
41
42 #include <linux/obd_class.h>
43 #include <linux/lprocfs_status.h>
44 #include <linux/lustre_fsfilt.h>
45
46 #if defined(LPROCFS) && defined(__KERNEL__)
47
48 struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head,
49                                     const char *name)
50 {
51         struct proc_dir_entry *temp;
52
53         if (head == NULL)
54                 return NULL;
55
56         temp = head->subdir;
57         while (temp != NULL) {
58                 if (strcmp(temp->name, name) == 0)
59                         return temp;
60
61                 temp = temp->next;
62         }
63         return NULL;
64 }
65
66 /* lprocfs API calls */
67
68 int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list,
69                      void *data)
70 {
71         if (root == NULL || list == NULL)
72                 return -EINVAL;
73
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;
78
79                 proc = NULL;
80                 cur_root = root;
81
82                 /* need copy of path for strsep */
83                 if (strlen(list->name) > sizeof(pathbuf) - 1) {
84                         OBD_ALLOC(pathcopy, pathsize);
85                         if (pathcopy == NULL)
86                                 return -ENOMEM;
87                 } else {
88                         pathcopy = pathbuf;
89                 }
90
91                 next = pathcopy;
92                 strcpy(pathcopy, list->name);
93
94                 while (cur_root != NULL && (cur = strsep(&next, "/"))) {
95                         if (*cur =='\0') /* skip double/trailing "/" */
96                                 continue;
97
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"));
102                         if (next != NULL) {
103                                 cur_root = (proc ? proc :
104                                             proc_mkdir(cur, cur_root));
105                         } else if (proc == NULL) {
106                                 mode_t mode = 0;
107                                 if (list->read_fptr)
108                                         mode = 0444;
109                                 if (list->write_fptr)
110                                         mode |= 0200;
111                                 proc = create_proc_entry(cur, mode, cur_root);
112                         }
113                 }
114
115                 if (pathcopy != pathbuf)
116                         OBD_FREE(pathcopy, pathsize);
117
118                 if (cur_root == NULL || proc == NULL) {
119                         CERROR("LprocFS: No memory to create /proc entry %s",
120                                list->name);
121                         return -ENOMEM;
122                 }
123
124                 proc->read_proc = list->read_fptr;
125                 proc->write_proc = list->write_fptr;
126                 proc->data = (list->data ? list->data : data);
127                 list++;
128         }
129         return 0;
130 }
131
132 void lprocfs_remove(struct proc_dir_entry *root)
133 {
134         struct proc_dir_entry *temp = root;
135         struct proc_dir_entry *rm_entry;
136         struct proc_dir_entry *parent;
137
138         LASSERT(root != NULL);
139         parent = root->parent;
140         LASSERT(parent != NULL);
141  
142         while (1) {
143                 while (temp->subdir != NULL)
144                         temp = temp->subdir;
145
146                 rm_entry = temp;
147                 temp = temp->parent;
148
149                 /* Memory corruption once caused this to fail, and
150                    without this LASSERT we would loop here forever. */
151                 LASSERTF(strlen(rm_entry->name) == rm_entry->namelen,
152                          "0x%p  %s/%s len %d\n", rm_entry, temp->name,
153                          rm_entry->name, (int)strlen(rm_entry->name));
154
155                 remove_proc_entry(rm_entry->name, rm_entry->parent);
156                 if (temp == parent)
157                         break;
158         }
159 }
160
161 struct proc_dir_entry *lprocfs_register(const char *name,
162                                         struct proc_dir_entry *parent,
163                                         struct lprocfs_vars *list, void *data)
164 {
165         struct proc_dir_entry *newchild;
166
167         newchild = lprocfs_srch(parent, name);
168         if (newchild != NULL) {
169                 CERROR(" Lproc: Attempting to register %s more than once \n",
170                        name);
171                 return ERR_PTR(-EALREADY);
172         }
173
174         newchild = proc_mkdir(name, parent);
175         if (newchild != NULL && list != NULL) {
176                 int rc = lprocfs_add_vars(newchild, list, data);
177                 if (rc) {
178                         lprocfs_remove(newchild);
179                         return ERR_PTR(rc);
180                 }
181         }
182         return newchild;
183 }
184
185 /* Generic callbacks */
186
187 int lprocfs_rd_u64(char *page, char **start, off_t off,
188                    int count, int *eof, void *data)
189 {
190         LASSERT(data != NULL);
191         *eof = 1;
192         return snprintf(page, count, LPU64"\n", *(__u64 *)data);
193 }
194
195 int lprocfs_rd_uuid(char *page, char **start, off_t off, int count,
196                     int *eof, void *data)
197 {
198         struct obd_device *dev = (struct obd_device*)data;
199
200         LASSERT(dev != NULL);
201         *eof = 1;
202         return snprintf(page, count, "%s\n", dev->obd_uuid.uuid);
203 }
204
205 int lprocfs_rd_name(char *page, char **start, off_t off, int count,
206                     int *eof, void* data)
207 {
208         struct obd_device *dev = (struct obd_device *)data;
209
210         LASSERT(dev != NULL);
211         LASSERT(dev->obd_name != NULL);
212         *eof = 1;
213         return snprintf(page, count, "%s\n", dev->obd_name);
214 }
215
216 int lprocfs_rd_fstype(char *page, char **start, off_t off, int count, int *eof,
217                       void *data)
218 {
219         struct obd_device *obd = (struct obd_device *)data;
220
221         LASSERT(obd != NULL);
222         LASSERT(obd->obd_fsops != NULL);
223         LASSERT(obd->obd_fsops->fs_type != NULL);
224         return snprintf(page, count, "%s\n", obd->obd_fsops->fs_type);
225 }
226
227 int lprocfs_rd_blksize(char *page, char **start, off_t off, int count,
228                        int *eof, void *data)
229 {
230         struct obd_statfs osfs;
231         int rc = obd_statfs(data, &osfs, jiffies - HZ);
232         if (!rc) {
233                 *eof = 1;
234                 rc = snprintf(page, count, "%u\n", osfs.os_bsize);
235         }
236         return rc;
237 }
238
239 int lprocfs_rd_kbytestotal(char *page, char **start, off_t off, int count,
240                            int *eof, void *data)
241 {
242         struct obd_statfs osfs;
243         int rc = obd_statfs(data, &osfs, jiffies - HZ);
244         if (!rc) {
245                 __u32 blk_size = osfs.os_bsize >> 10;
246                 __u64 result = osfs.os_blocks;
247
248                 while (blk_size >>= 1)
249                         result <<= 1;
250
251                 *eof = 1;
252                 rc = snprintf(page, count, LPU64"\n", result);
253         }
254         return rc;
255 }
256
257 int lprocfs_rd_kbytesfree(char *page, char **start, off_t off, int count,
258                           int *eof, void *data)
259 {
260         struct obd_statfs osfs;
261         int rc = obd_statfs(data, &osfs, jiffies - HZ);
262         if (!rc) {
263                 __u32 blk_size = osfs.os_bsize >> 10;
264                 __u64 result = osfs.os_bfree;
265
266                 while (blk_size >>= 1)
267                         result <<= 1;
268
269                 *eof = 1;
270                 rc = snprintf(page, count, LPU64"\n", result);
271         }
272         return rc;
273 }
274
275 int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, int count,
276                            int *eof, void *data)
277 {
278         struct obd_statfs osfs;
279         int rc = obd_statfs(data, &osfs, jiffies - HZ);
280         if (!rc) {
281                 __u32 blk_size = osfs.os_bsize >> 10;
282                 __u64 result = osfs.os_bavail;
283
284                 while (blk_size >>= 1)
285                         result <<= 1;
286
287                 *eof = 1;
288                 rc = snprintf(page, count, LPU64"\n", result);
289         }
290         return rc;
291 }
292
293 int lprocfs_rd_filestotal(char *page, char **start, off_t off, int count,
294                           int *eof, void *data)
295 {
296         struct obd_statfs osfs;
297         int rc = obd_statfs(data, &osfs, jiffies - HZ);
298         if (!rc) {
299                 *eof = 1;
300                 rc = snprintf(page, count, LPU64"\n", osfs.os_files);
301         }
302
303         return rc;
304 }
305
306 int lprocfs_rd_filesfree(char *page, char **start, off_t off, int count,
307                          int *eof, void *data)
308 {
309         struct obd_statfs osfs;
310         int rc = obd_statfs(data, &osfs, jiffies - HZ);
311         if (!rc) {
312                 *eof = 1;
313                 rc = snprintf(page, count, LPU64"\n", osfs.os_ffree);
314         }
315         return rc;
316 }
317
318 int lprocfs_rd_filegroups(char *page, char **start, off_t off, int count,
319                           int *eof, void *data)
320 {
321         *eof = 1;
322         return snprintf(page, count, "unimplemented\n");
323 }
324
325 int lprocfs_rd_server_uuid(char *page, char **start, off_t off, int count,
326                            int *eof, void *data)
327 {
328         struct obd_device *obd = (struct obd_device *)data;
329         struct obd_import *imp;
330         char *imp_state_name = NULL;
331         
332         LASSERT(obd != NULL);
333         imp = obd->u.cli.cl_import;
334         imp_state_name = ptlrpc_import_state_name(imp->imp_state);
335         *eof = 1;
336         return snprintf(page, count, "%s\t%s\n",
337                         imp->imp_target_uuid.uuid, imp_state_name);
338 }
339
340 int lprocfs_rd_conn_uuid(char *page, char **start, off_t off, int count,
341                          int *eof,  void *data)
342 {
343         struct obd_device *obd = (struct obd_device*)data;
344         struct ptlrpc_connection *conn;
345
346         LASSERT(obd != NULL);
347         conn = obd->u.cli.cl_import->imp_connection;
348         LASSERT(conn != NULL);
349         *eof = 1;
350         return snprintf(page, count, "%s\n", conn->c_remote_uuid.uuid);
351 }
352
353 int lprocfs_rd_numrefs(char *page, char **start, off_t off, int count,
354                        int *eof, void *data)
355 {
356         struct obd_type *class = (struct obd_type*) data;
357
358         LASSERT(class != NULL);
359         *eof = 1;
360         return snprintf(page, count, "%d\n", class->typ_refcnt);
361 }
362
363 int lprocfs_obd_attach(struct obd_device *dev, struct lprocfs_vars *list)
364 {
365         int rc = 0;
366
367         LASSERT(dev != NULL);
368         LASSERT(dev->obd_type != NULL);
369         LASSERT(dev->obd_type->typ_procroot != NULL);
370
371         dev->obd_proc_entry = lprocfs_register(dev->obd_name,
372                                                dev->obd_type->typ_procroot,
373                                                list, dev);
374         if (IS_ERR(dev->obd_proc_entry)) {
375                 rc = PTR_ERR(dev->obd_proc_entry);
376                 dev->obd_proc_entry = NULL;
377         }
378         return rc;
379 }
380
381 int lprocfs_obd_detach(struct obd_device *dev)
382 {
383         if (dev && dev->obd_proc_entry) {
384                 lprocfs_remove(dev->obd_proc_entry);
385                 dev->obd_proc_entry = NULL;
386         }
387         return 0;
388 }
389
390 struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num)
391 {
392         struct lprocfs_stats *stats;
393         struct lprocfs_percpu *percpu;
394         unsigned int percpusize;
395         unsigned int i;
396
397         if (num == 0)
398                 return NULL;
399
400         OBD_ALLOC(stats, offsetof(typeof(*stats), ls_percpu[num_online_cpus()]));
401         if (stats == NULL)
402                 return NULL;
403
404         percpusize = L1_CACHE_ALIGN(offsetof(typeof(*percpu), lp_cntr[num]));
405         stats->ls_percpu_size = num_online_cpus() * percpusize;
406         OBD_ALLOC(stats->ls_percpu[0], stats->ls_percpu_size);
407         if (stats->ls_percpu[0] == NULL) {
408                 OBD_FREE(stats, offsetof(typeof(*stats),
409                                          ls_percpu[num_online_cpus()]));
410                 return NULL;
411         }
412
413         stats->ls_num = num;
414         for (i = 1; i < num_online_cpus(); i++)
415                 stats->ls_percpu[i] = (void *)(stats->ls_percpu[i - 1]) +
416                         percpusize;
417
418         return stats;
419 }
420
421 void lprocfs_free_stats(struct lprocfs_stats *stats)
422 {
423         if (stats->ls_num == 0)
424                 return;
425
426         OBD_FREE(stats->ls_percpu[0], stats->ls_percpu_size);
427         OBD_FREE(stats, offsetof(typeof(*stats), ls_percpu[num_online_cpus()]));
428 }
429
430 /* Reset counter under lock */
431 int lprocfs_counter_write(struct file *file, const char *buffer,
432                           unsigned long count, void *data)
433 {
434         /* not supported */
435         return 0;
436 }
437
438 static void *lprocfs_stats_seq_start(struct seq_file *p, loff_t *pos)
439 {
440         struct lprocfs_stats *stats = p->private;
441         /* return 1st cpu location */
442         return (*pos >= stats->ls_num) ? NULL :
443                 &(stats->ls_percpu[0]->lp_cntr[*pos]);
444 }
445
446 static void lprocfs_stats_seq_stop(struct seq_file *p, void *v)
447 {
448 }
449
450 static void *lprocfs_stats_seq_next(struct seq_file *p, void *v, loff_t *pos)
451 {
452         struct lprocfs_stats *stats = p->private;
453         ++*pos;
454         return (*pos >= stats->ls_num) ? NULL :
455                 &(stats->ls_percpu[0]->lp_cntr[*pos]);
456 }
457
458 /* seq file export of one lprocfs counter */
459 static int lprocfs_stats_seq_show(struct seq_file *p, void *v)
460 {
461        struct lprocfs_stats *stats = p->private;
462        struct lprocfs_counter  *cntr = v;
463        struct lprocfs_counter  t, ret = { .lc_min = ~(__u64)0 };
464        int i, idx, rc;
465
466        if (cntr == &(stats->ls_percpu[0])->lp_cntr[0]) {
467                struct timeval now;
468                do_gettimeofday(&now);
469                rc = seq_printf(p, "%-25s %lu.%lu secs.usecs\n",
470                                "snapshot_time", now.tv_sec, now.tv_usec);
471                if (rc < 0)
472                        return rc;
473        }
474        idx = cntr - &(stats->ls_percpu[0])->lp_cntr[0];
475
476        for (i = 0; i < num_online_cpus(); i++) {
477                struct lprocfs_counter *percpu_cntr =
478                        &(stats->ls_percpu[i])->lp_cntr[idx];
479                int centry;
480
481                do {
482                        centry = atomic_read(&percpu_cntr->lc_cntl.la_entry);
483                        t.lc_count = percpu_cntr->lc_count;
484                        t.lc_sum = percpu_cntr->lc_sum;
485                        t.lc_min = percpu_cntr->lc_min;
486                        t.lc_max = percpu_cntr->lc_max;
487                        t.lc_sumsquare = percpu_cntr->lc_sumsquare;
488                } while (centry != atomic_read(&percpu_cntr->lc_cntl.la_entry) &&
489                         centry != atomic_read(&percpu_cntr->lc_cntl.la_exit));
490                ret.lc_count += t.lc_count;
491                ret.lc_sum += t.lc_sum;
492                if (t.lc_min < ret.lc_min)
493                        ret.lc_min = t.lc_min;
494                if (t.lc_max > ret.lc_max)
495                        ret.lc_max = t.lc_max;
496                ret.lc_sumsquare += t.lc_sumsquare;
497        }
498
499        rc = seq_printf(p, "%-25s "LPU64" samples [%s]", cntr->lc_name,
500                        ret.lc_count, cntr->lc_units);
501        if (rc < 0)
502                goto out;
503
504        if ((cntr->lc_config & LPROCFS_CNTR_AVGMINMAX) && (ret.lc_count > 0)) {
505                rc = seq_printf(p, " "LPU64" "LPU64" "LPU64,
506                                ret.lc_min, ret.lc_max, ret.lc_sum);
507                if (rc < 0)
508                        goto out;
509                if (cntr->lc_config & LPROCFS_CNTR_STDDEV)
510                        rc = seq_printf(p, " "LPU64, ret.lc_sumsquare);
511                if (rc < 0)
512                        goto out;
513        }
514        rc = seq_printf(p, "\n");
515  out:
516        return (rc < 0) ? rc : 0;
517 }
518
519 struct seq_operations lprocfs_stats_seq_sops = {
520         start: lprocfs_stats_seq_start,
521         stop:  lprocfs_stats_seq_stop,
522         next:  lprocfs_stats_seq_next,
523         show:  lprocfs_stats_seq_show,
524 };
525
526 static int lprocfs_stats_seq_open(struct inode *inode, struct file *file)
527 {
528         struct proc_dir_entry *dp = PDE(inode);
529         struct seq_file *seq;
530         int rc;
531
532         rc = seq_open(file, &lprocfs_stats_seq_sops);
533         if (rc)
534                 return rc;
535         seq = file->private_data;
536         seq->private = dp->data;
537         return 0;
538 }
539
540 struct file_operations lprocfs_stats_seq_fops = {
541         open:    lprocfs_stats_seq_open,
542         read:    seq_read,
543         llseek:  seq_lseek,
544         release: seq_release,
545 };
546
547 int lprocfs_register_stats(struct proc_dir_entry *root, const char *name,
548                            struct lprocfs_stats *stats)
549 {
550         struct proc_dir_entry *entry;
551         LASSERT(root != NULL);
552
553         entry = create_proc_entry(name, 0444, root);
554         if (entry == NULL)
555                 return -ENOMEM;
556         entry->proc_fops = &lprocfs_stats_seq_fops;
557         entry->data = (void *)stats;
558         entry->write_proc = lprocfs_counter_write;
559         return 0;
560 }
561
562 void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
563                           unsigned conf, const char *name, const char *units)
564 {
565         struct lprocfs_counter *c;
566         int i;
567
568         LASSERT(stats != NULL);
569         for (i = 0; i < num_online_cpus(); i++) {
570                 c = &(stats->ls_percpu[i]->lp_cntr[index]);
571                 c->lc_config = conf;
572                 c->lc_min = ~(__u64)0;
573                 c->lc_name = name;
574                 c->lc_units = units;
575         }
576 }
577 EXPORT_SYMBOL(lprocfs_counter_init);
578
579 #define LPROCFS_OBD_OP_INIT(base, stats, op)                               \
580 do {                                                                       \
581         unsigned int coffset = base + OBD_COUNTER_OFFSET(op);              \
582         LASSERT(coffset < stats->ls_num);                                  \
583         lprocfs_counter_init(stats, coffset, 0, #op, "reqs");              \
584 } while (0)
585
586 int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats)
587 {
588         struct lprocfs_stats *stats;
589         unsigned int num_stats;
590         int rc, i;
591
592         LASSERT(obd->obd_stats == NULL);
593         LASSERT(obd->obd_proc_entry != NULL);
594         LASSERT(obd->obd_cntr_base == 0);
595
596         num_stats = 1 + OBD_COUNTER_OFFSET(notify) +
597                 num_private_stats;
598         stats = lprocfs_alloc_stats(num_stats);
599         if (stats == NULL)
600                 return -ENOMEM;
601
602         LPROCFS_OBD_OP_INIT(num_private_stats, stats, iocontrol);
603         LPROCFS_OBD_OP_INIT(num_private_stats, stats, get_info);
604         LPROCFS_OBD_OP_INIT(num_private_stats, stats, set_info);
605         LPROCFS_OBD_OP_INIT(num_private_stats, stats, attach);
606         LPROCFS_OBD_OP_INIT(num_private_stats, stats, detach);
607         LPROCFS_OBD_OP_INIT(num_private_stats, stats, setup);
608         LPROCFS_OBD_OP_INIT(num_private_stats, stats, precleanup);
609         LPROCFS_OBD_OP_INIT(num_private_stats, stats, cleanup);
610         LPROCFS_OBD_OP_INIT(num_private_stats, stats, postrecov);
611         LPROCFS_OBD_OP_INIT(num_private_stats, stats, connect);
612         LPROCFS_OBD_OP_INIT(num_private_stats, stats, disconnect);
613         LPROCFS_OBD_OP_INIT(num_private_stats, stats, statfs);
614         LPROCFS_OBD_OP_INIT(num_private_stats, stats, packmd);
615         LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpackmd);
616         LPROCFS_OBD_OP_INIT(num_private_stats, stats, preallocate);
617         LPROCFS_OBD_OP_INIT(num_private_stats, stats, create);
618         LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy);
619         LPROCFS_OBD_OP_INIT(num_private_stats, stats, setattr);
620         LPROCFS_OBD_OP_INIT(num_private_stats, stats, getattr);
621         LPROCFS_OBD_OP_INIT(num_private_stats, stats, getattr_async);
622         LPROCFS_OBD_OP_INIT(num_private_stats, stats, brw);
623         LPROCFS_OBD_OP_INIT(num_private_stats, stats, brw_async);
624         LPROCFS_OBD_OP_INIT(num_private_stats, stats, prep_async_page);
625         LPROCFS_OBD_OP_INIT(num_private_stats, stats, queue_async_io);
626         LPROCFS_OBD_OP_INIT(num_private_stats, stats, set_async_flags);
627         LPROCFS_OBD_OP_INIT(num_private_stats, stats, queue_group_io);
628         LPROCFS_OBD_OP_INIT(num_private_stats, stats, trigger_group_io);
629         LPROCFS_OBD_OP_INIT(num_private_stats, stats, teardown_async_page);
630         LPROCFS_OBD_OP_INIT(num_private_stats, stats, punch);
631         LPROCFS_OBD_OP_INIT(num_private_stats, stats, sync);
632         LPROCFS_OBD_OP_INIT(num_private_stats, stats, migrate);
633         LPROCFS_OBD_OP_INIT(num_private_stats, stats, copy);
634         LPROCFS_OBD_OP_INIT(num_private_stats, stats, iterate);
635         LPROCFS_OBD_OP_INIT(num_private_stats, stats, preprw);
636         LPROCFS_OBD_OP_INIT(num_private_stats, stats, commitrw);
637         LPROCFS_OBD_OP_INIT(num_private_stats, stats, enqueue);
638         LPROCFS_OBD_OP_INIT(num_private_stats, stats, match);
639         LPROCFS_OBD_OP_INIT(num_private_stats, stats, change_cbdata);
640         LPROCFS_OBD_OP_INIT(num_private_stats, stats, cancel);
641         LPROCFS_OBD_OP_INIT(num_private_stats, stats, cancel_unused);
642         LPROCFS_OBD_OP_INIT(num_private_stats, stats, san_preprw);
643         LPROCFS_OBD_OP_INIT(num_private_stats, stats, init_export);
644         LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy_export);
645         LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_init); 
646         LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_finish); 
647         LPROCFS_OBD_OP_INIT(num_private_stats, stats, pin); 
648         LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpin);
649         LPROCFS_OBD_OP_INIT(num_private_stats, stats, import_event);
650         LPROCFS_OBD_OP_INIT(num_private_stats, stats, notify);
651         
652         for (i = num_private_stats; i < num_stats; i++) {
653                 /* If this LBUGs, it is likely that an obd
654                  * operation was added to struct obd_ops in
655                  * <linux/obd.h>, and that the corresponding line item
656                  * LPROCFS_OBD_OP_INIT(.., .., opname)
657                  * is missing from the list above. */
658                 if (stats->ls_percpu[0]->lp_cntr[i].lc_name == NULL) {
659                         CERROR("Missing obd_stat initializer obd_op "
660                                "operation at offset %d. Aborting.\n",
661                                i - num_private_stats);
662                         LBUG();
663                 }
664         }
665         rc = lprocfs_register_stats(obd->obd_proc_entry, "stats", stats);
666         if (rc < 0) {
667                 lprocfs_free_stats(stats);
668         } else {
669                 obd->obd_stats  = stats;
670                 obd->obd_cntr_base = num_private_stats;
671         }
672         return rc;
673 }
674
675 void lprocfs_free_obd_stats(struct obd_device *obd)
676 {
677         struct lprocfs_stats *stats = obd->obd_stats;
678
679         if (stats != NULL) {
680                 obd->obd_stats = NULL;
681                 lprocfs_free_stats(stats);
682         }
683 }
684
685 int lprocfs_write_helper(const char *buffer, unsigned long count,
686                          int *val)
687 {
688         char kernbuf[20], *end;
689
690         if (count > (sizeof(kernbuf) - 1))
691                 return -EINVAL;
692
693         if (copy_from_user(kernbuf, buffer, count))
694                 return -EFAULT;
695
696         kernbuf[count] = '\0';
697
698         *val = simple_strtol(kernbuf, &end, 0);
699         if (kernbuf == end)
700                 return -EINVAL;
701
702         return 0;
703 }
704
705 int lprocfs_write_u64_helper(const char *buffer, unsigned long count,
706                              __u64 *val)
707 {
708         char kernbuf[22], *end;
709
710         if (count > (sizeof(kernbuf) - 1))
711                 return -EINVAL;
712
713         if (copy_from_user(kernbuf, buffer, count))
714                 return -EFAULT;
715
716         kernbuf[count] = '\0';
717
718         *val = simple_strtoull(kernbuf, &end, 0);
719         if (kernbuf == end)
720                 return -EINVAL;
721
722         return 0;
723 }
724
725 int lprocfs_obd_seq_create(struct obd_device *dev, char *name, mode_t mode,
726                            struct file_operations *seq_fops, void *data)
727 {
728         struct proc_dir_entry *entry;
729         ENTRY;
730
731         entry = create_proc_entry(name, mode, dev->obd_proc_entry);
732         if (entry == NULL)
733                 RETURN(-ENOMEM);
734         entry->proc_fops = seq_fops;
735         entry->data = data;
736
737         RETURN(0);
738 }
739 EXPORT_SYMBOL(lprocfs_obd_seq_create);
740
741 void lprocfs_oh_tally(struct obd_histogram *oh, unsigned int value)
742 {
743         unsigned long flags;
744
745         if (value >= OBD_HIST_MAX)
746                 value = OBD_HIST_MAX - 1;
747
748         spin_lock_irqsave(&oh->oh_lock, flags);
749         oh->oh_buckets[value]++;
750         spin_unlock_irqrestore(&oh->oh_lock, flags);
751 }
752 EXPORT_SYMBOL(lprocfs_oh_tally);
753
754 void lprocfs_oh_tally_log2(struct obd_histogram *oh, unsigned int value)
755 {
756         unsigned int val;
757
758         for (val = 0; ((1 << val) < value) && (val <= OBD_HIST_MAX); val++)
759                 ;
760
761         lprocfs_oh_tally(oh, val);
762 }
763 EXPORT_SYMBOL(lprocfs_oh_tally_log2);
764
765 unsigned long lprocfs_oh_sum(struct obd_histogram *oh)
766 {
767         unsigned long ret = 0;
768         int i;
769
770         for (i = 0; i < OBD_HIST_MAX; i++)
771                 ret +=  oh->oh_buckets[i];
772         return ret;
773 }
774 EXPORT_SYMBOL(lprocfs_oh_sum);
775
776 void lprocfs_oh_clear(struct obd_histogram *oh)
777 {
778         unsigned long flags;
779         spin_lock_irqsave(&oh->oh_lock, flags);
780         memset(oh->oh_buckets, 0, sizeof(oh->oh_buckets));
781         spin_unlock_irqrestore(&oh->oh_lock, flags);
782 }
783 EXPORT_SYMBOL(lprocfs_oh_clear);
784
785 #endif /* LPROCFS*/
786
787 EXPORT_SYMBOL(lprocfs_register);
788 EXPORT_SYMBOL(lprocfs_srch);
789 EXPORT_SYMBOL(lprocfs_remove);
790 EXPORT_SYMBOL(lprocfs_add_vars);
791 EXPORT_SYMBOL(lprocfs_obd_attach);
792 EXPORT_SYMBOL(lprocfs_obd_detach);
793 EXPORT_SYMBOL(lprocfs_alloc_stats);
794 EXPORT_SYMBOL(lprocfs_free_stats);
795 EXPORT_SYMBOL(lprocfs_register_stats);
796 EXPORT_SYMBOL(lprocfs_alloc_obd_stats);
797 EXPORT_SYMBOL(lprocfs_free_obd_stats);
798
799 EXPORT_SYMBOL(lprocfs_rd_u64);
800 EXPORT_SYMBOL(lprocfs_rd_uuid);
801 EXPORT_SYMBOL(lprocfs_rd_name);
802 EXPORT_SYMBOL(lprocfs_rd_fstype);
803 EXPORT_SYMBOL(lprocfs_rd_server_uuid);
804 EXPORT_SYMBOL(lprocfs_rd_conn_uuid);
805 EXPORT_SYMBOL(lprocfs_rd_numrefs);
806
807 EXPORT_SYMBOL(lprocfs_rd_blksize);
808 EXPORT_SYMBOL(lprocfs_rd_kbytestotal);
809 EXPORT_SYMBOL(lprocfs_rd_kbytesfree);
810 EXPORT_SYMBOL(lprocfs_rd_kbytesavail);
811 EXPORT_SYMBOL(lprocfs_rd_filestotal);
812 EXPORT_SYMBOL(lprocfs_rd_filesfree);
813 EXPORT_SYMBOL(lprocfs_rd_filegroups);
814
815 EXPORT_SYMBOL(lprocfs_write_helper);
816 EXPORT_SYMBOL(lprocfs_write_u64_helper);