aboutsummaryrefslogtreecommitdiff
blob: 0be7f2aafb9c82542b7c46fc6fbfb6749e211eaa (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
From adf3be9fe382564c4760b83a5843b7d5502bbe48 Mon Sep 17 00:00:00 2001
From: James Simmons <uja.ornl@gmail.com>
Date: Sun, 9 Feb 2014 10:45:37 -0500
Subject: [PATCH 10/13] LU-3319 procfs: update ldiskfs proc handling to
 seq_files

Migrate all ldiskfs proc handling to using strictly
seq_files. Also include a fix with newer gcc complaining
certain variables are initialized.

Signed-off-by: James Simmons <uja.ornl@gmail.com>
Change-Id: Ia296a4682e2feda02bcfbe0100de8a89404cd731
---
 lustre/osd-ldiskfs/osd_compat.c   |   6 +-
 lustre/osd-ldiskfs/osd_handler.c  |  16 +-
 lustre/osd-ldiskfs/osd_internal.h |   6 +-
 lustre/osd-ldiskfs/osd_lproc.c    | 336 ++++++++++++++++++++------------------
 lustre/osd-ldiskfs/osd_scrub.c    |  73 +++------
 5 files changed, 220 insertions(+), 217 deletions(-)

diff --git a/lustre/osd-ldiskfs/osd_compat.c b/lustre/osd-ldiskfs/osd_compat.c
index b4a018c..6ca1304 100644
--- a/lustre/osd-ldiskfs/osd_compat.c
+++ b/lustre/osd-ldiskfs/osd_compat.c
@@ -1168,7 +1168,7 @@ int osd_obj_spec_update(struct osd_thread_info *info, struct osd_device *osd,
 			handle_t *th)
 {
 	struct dentry	*root;
-	char		*name;
+	char		*name = NULL;
 	int		 rc;
 	ENTRY;
 
@@ -1189,7 +1189,7 @@ int osd_obj_spec_insert(struct osd_thread_info *info, struct osd_device *osd,
 			handle_t *th)
 {
 	struct dentry	*root;
-	char		*name;
+	char		*name = NULL;
 	int		 rc;
 	ENTRY;
 
@@ -1211,7 +1211,7 @@ int osd_obj_spec_lookup(struct osd_thread_info *info, struct osd_device *osd,
 	struct dentry	*root;
 	struct dentry	*dentry;
 	struct inode	*inode;
-	char		*name;
+	char		*name = NULL;
 	int		rc = -ENOENT;
 	ENTRY;
 
diff --git a/lustre/osd-ldiskfs/osd_handler.c b/lustre/osd-ldiskfs/osd_handler.c
index 9027533..dfaa542 100644
--- a/lustre/osd-ldiskfs/osd_handler.c
+++ b/lustre/osd-ldiskfs/osd_handler.c
@@ -5814,6 +5814,7 @@ static struct lu_device *osd_device_free(const struct lu_env *env,
 static int osd_process_config(const struct lu_env *env,
                               struct lu_device *d, struct lustre_cfg *cfg)
 {
+	struct obd_device		*obd = d->ld_obd;
 	struct osd_device		*o = osd_dev(d);
 	int				rc;
 	ENTRY;
@@ -5828,12 +5829,12 @@ static int osd_process_config(const struct lu_env *env,
 		break;
 	case LCFG_PARAM:
 		LASSERT(&o->od_dt_dev);
-		rc = class_process_proc_param(PARAM_OSD, lprocfs_osd_obd_vars,
-					      cfg, &o->od_dt_dev);
+		rc = class_process_proc_seq_param(PARAM_OSD, obd->obd_vars,
+						  cfg, &o->od_dt_dev);
 		if (rc > 0 || rc == -ENOSYS)
-			rc = class_process_proc_param(PARAM_OST,
-						      lprocfs_osd_obd_vars,
-						      cfg, &o->od_dt_dev);
+			rc = class_process_proc_seq_param(PARAM_OST,
+							  obd->obd_vars, cfg,
+							  &o->od_dt_dev);
 		break;
 	default:
 		rc = -ENOSYS;
@@ -5981,9 +5982,10 @@ static int __init osd_mod_init(void)
 	if (rc)
 		return rc;
 
-	rc = class_register_type(&osd_obd_device_ops, NULL, NULL,
-#ifndef HAVE_ONLY_PROCFS_SEQ
+	rc = class_register_type(&osd_obd_device_ops, NULL,
 				lprocfs_osd_module_vars,
+#ifndef HAVE_ONLY_PROCFS_SEQ
+				NULL,
 #endif
 				LUSTRE_OSD_LDISKFS_NAME, &osd_device_type);
 	if (rc)
diff --git a/lustre/osd-ldiskfs/osd_internal.h b/lustre/osd-ldiskfs/osd_internal.h
index 8436d1f..c90147f 100644
--- a/lustre/osd-ldiskfs/osd_internal.h
+++ b/lustre/osd-ldiskfs/osd_internal.h
@@ -623,8 +623,8 @@ static inline int __osd_xattr_set(struct osd_thread_info *info,
 
 #ifdef LPROCFS
 /* osd_lproc.c */
-extern struct lprocfs_vars lprocfs_osd_obd_vars[];
-extern struct lprocfs_vars lprocfs_osd_module_vars[];
+extern struct lprocfs_seq_vars lprocfs_osd_obd_vars[];
+extern struct lprocfs_seq_vars lprocfs_osd_module_vars[];
 int osd_procfs_init(struct osd_device *osd, const char *name);
 int osd_procfs_fini(struct osd_device *osd);
 void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf);
@@ -679,7 +679,7 @@ int osd_oii_insert(struct osd_device *dev, struct osd_idmap_cache *oic,
 		   int insert);
 int osd_oii_lookup(struct osd_device *dev, const struct lu_fid *fid,
 		   struct osd_inode_id *id);
-int osd_scrub_dump(struct osd_device *dev, char *buf, int len);
+int osd_scrub_dump(struct seq_file *m, struct osd_device *dev);
 
 int osd_fld_lookup(const struct lu_env *env, struct osd_device *osd,
 		   obd_seq seq, struct lu_seq_range *range);
diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c
index b9b4e3d..947a4b9 100644
--- a/lustre/osd-ldiskfs/osd_lproc.c
+++ b/lustre/osd-ldiskfs/osd_lproc.c
@@ -237,92 +237,46 @@ out:
         RETURN(result);
 }
 
-int osd_procfs_init(struct osd_device *osd, const char *name)
-{
-        struct obd_type     *type;
-        int                  rc;
-        ENTRY;
-
-	/* at the moment there is no linkage between lu_type
-	 * and obd_type, so we lookup obd_type this way */
-	type = class_search_type(LUSTRE_OSD_LDISKFS_NAME);
-
-        LASSERT(name != NULL);
-        LASSERT(type != NULL);
-
-        /* Find the type procroot and add the proc entry for this device */
-        osd->od_proc_entry = lprocfs_register(name, type->typ_procroot,
-					      lprocfs_osd_obd_vars,
-					      &osd->od_dt_dev);
-        if (IS_ERR(osd->od_proc_entry)) {
-                rc = PTR_ERR(osd->od_proc_entry);
-                CERROR("Error %d setting up lprocfs for %s\n",
-                       rc, name);
-                osd->od_proc_entry = NULL;
-                GOTO(out, rc);
-        }
-
-        rc = osd_stats_init(osd);
-
-        EXIT;
-out:
-        if (rc)
-               osd_procfs_fini(osd);
-	return rc;
-}
-
-int osd_procfs_fini(struct osd_device *osd)
-{
-	if (osd->od_stats)
-		lprocfs_free_stats(&osd->od_stats);
-
-        if (osd->od_proc_entry) {
-                 lprocfs_remove(&osd->od_proc_entry);
-                 osd->od_proc_entry = NULL;
-        }
-        RETURN(0);
-}
-
-static int lprocfs_osd_rd_fstype(char *page, char **start, off_t off, int count,
-				 int *eof, void *data)
+static int ldiskfs_osd_fstype_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *osd = osd_dt_dev(data);
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
-        LASSERT(osd != NULL);
-        return snprintf(page, count, "ldiskfs\n");
+	LASSERT(osd != NULL);
+	return seq_printf(m, "ldiskfs\n");
 }
+LPROC_SEQ_FOPS_RO(ldiskfs_osd_fstype);
 
-static int lprocfs_osd_rd_mntdev(char *page, char **start, off_t off, int count,
-                                 int *eof, void *data)
+static int ldiskfs_osd_mntdev_seq_show(struct seq_file *m, void *data)
 {
-        struct osd_device *osd = osd_dt_dev(data);
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
-        LASSERT(osd != NULL);
+	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
-                return -EINPROGRESS;
-
-	*eof = 1;
+		return -EINPROGRESS;
 
-	return snprintf(page, count, "%s\n", osd->od_mntdev);
+	return seq_printf(m, "%u\n", osd->od_read_cache);
 }
+LPROC_SEQ_FOPS_RO(ldiskfs_osd_mntdev);
 
-static int lprocfs_osd_rd_cache(char *page, char **start, off_t off,
-				int count, int *eof, void *data)
+static int ldiskfs_osd_cache_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *osd = osd_dt_dev(data);
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	return snprintf(page, count, "%u\n", osd->od_read_cache);
+	return seq_printf(m, "%u\n", osd->od_read_cache);
 }
 
-static int lprocfs_osd_wr_cache(struct file *file, const char *buffer,
-				unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_cache_seq_write(struct file *file, const char *buffer,
+			    size_t count, loff_t *off)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
-	int			 val, rc;
+	struct seq_file *m = file->private_data;
+	struct dt_device  *dt = m->private;
+	struct osd_device *osd = osd_dt_dev(dt);
+	int		   val, rc;
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
@@ -335,24 +289,26 @@ static int lprocfs_osd_wr_cache(struct file *file, const char *buffer,
 	osd->od_read_cache = !!val;
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_cache);
 
-static int lprocfs_osd_rd_wcache(char *page, char **start, off_t off,
-				 int count, int *eof, void *data)
+static int ldiskfs_osd_wcache_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *osd = osd_dt_dev(data);
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	return snprintf(page, count, "%u\n", osd->od_writethrough_cache);
+	return seq_printf(m, "%u\n", osd->od_writethrough_cache);
 }
 
-static int lprocfs_osd_wr_wcache(struct file *file, const char *buffer,
-				 unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_wcache_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
-	int			 val, rc;
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device *osd = osd_dt_dev(dt);
+	int		   val, rc;
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
@@ -365,14 +321,16 @@ static int lprocfs_osd_wr_wcache(struct file *file, const char *buffer,
 	osd->od_writethrough_cache = !!val;
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_wcache);
 
-static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer,
-				     unsigned long count, void *data)
+static ssize_t
+lprocfs_osd_force_sync_seq_write(struct file *file, const char *buffer,
+					size_t count, loff_t *off)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
-	struct dt_device	*dt = data;
-	struct lu_env		 env;
-	int			 rc;
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device *osd = osd_dt_dev(dt);
+	struct lu_env	   env;
+	int		   rc;
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
@@ -386,20 +344,18 @@ static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer,
 
 	return rc == 0 ? count : rc;
 }
+LPROC_SEQ_FOPS_WO_TYPE(ldiskfs, osd_force_sync);
 
-static int lprocfs_osd_rd_pdo(char *page, char **start, off_t off, int count,
-                              int *eof, void *data)
+static int ldiskfs_osd_pdo_seq_show(struct seq_file *m, void *data)
 {
-        *eof = 1;
-
-        return snprintf(page, count, "%s\n", ldiskfs_pdo ? "ON" : "OFF");
+	return seq_printf(m, "%s\n", ldiskfs_pdo ? "ON" : "OFF");
 }
 
-static int lprocfs_osd_wr_pdo(struct file *file, const char *buffer,
-                              unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_pdo_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-        int     pdo;
-        int     rc;
+	int pdo, rc;
 
         rc = lprocfs_write_helper(buffer, count, &pdo);
         if (rc != 0)
@@ -409,24 +365,25 @@ static int lprocfs_osd_wr_pdo(struct file *file, const char *buffer,
 
         return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_pdo);
 
-static int lprocfs_osd_rd_auto_scrub(char *page, char **start, off_t off,
-				     int count, int *eof, void *data)
+static int ldiskfs_osd_auto_scrub_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(dev != NULL);
 	if (unlikely(dev->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	*eof = 1;
-	return snprintf(page, count, "%d\n", !dev->od_noscrub);
+	return seq_printf(m, "%d\n", !dev->od_noscrub);
 }
 
-static int lprocfs_osd_wr_auto_scrub(struct file *file, const char *buffer,
-				     unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_auto_scrub_seq_write(struct file *file, const char *buffer,
+					size_t count, loff_t *off)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device *dev = osd_dt_dev(dt);
 	int val, rc;
 
 	LASSERT(dev != NULL);
@@ -440,19 +397,18 @@ static int lprocfs_osd_wr_auto_scrub(struct file *file, const char *buffer,
 	dev->od_noscrub = !val;
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_auto_scrub);
 
-static int lprocfs_osd_rd_track_declares_assert(char *page, char **start,
-						off_t off, int count,
-						int *eof, void *data)
+static int
+ldiskfs_osd_track_declares_assert_seq_show(struct seq_file *m, void *data)
 {
-	*eof = 1;
-
-	return snprintf(page, count, "%d\n", ldiskfs_track_declares_assert);
+	return seq_printf(m, "%d\n", ldiskfs_track_declares_assert);
 }
 
-static int lprocfs_osd_wr_track_declares_assert(struct file *file,
+static ssize_t
+ldiskfs_osd_track_declares_assert_seq_write(struct file *file,
 						const char *buffer,
-						unsigned long count, void *data)
+						size_t count, loff_t *off)
 {
 	int     track_declares_assert;
 	int     rc;
@@ -465,38 +421,39 @@ static int lprocfs_osd_wr_track_declares_assert(struct file *file,
 
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_track_declares_assert);
+
+extern int osd_scrub_dump(struct seq_file *m, struct osd_device *dev);
 
-static int lprocfs_osd_rd_oi_scrub(char *page, char **start, off_t off,
-				   int count, int *eof, void *data)
+static int ldiskfs_osd_oi_scrub_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(dev != NULL);
 	if (unlikely(dev->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	*eof = 1;
-	return osd_scrub_dump(dev, page, count);
+	return osd_scrub_dump(m, dev);
 }
+LPROC_SEQ_FOPS_RO(ldiskfs_osd_oi_scrub);
 
-int lprocfs_osd_rd_readcache(char *page, char **start, off_t off, int count,
-			     int *eof, void *data)
+int ldiskfs_osd_readcache_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
-	int			 rc;
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	rc = snprintf(page, count, LPU64"\n", osd->od_readcache_max_filesize);
-	return rc;
+	return seq_printf(m, LPU64"\n", osd->od_readcache_max_filesize);
 }
 
-int lprocfs_osd_wr_readcache(struct file *file, const char *buffer,
-			     unsigned long count, void *data)
+ssize_t
+ldiskfs_osd_readcache_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device	*osd = osd_dt_dev(dt);
 	__u64			 val;
 	int			 rc;
 
@@ -512,24 +469,25 @@ int lprocfs_osd_wr_readcache(struct file *file, const char *buffer,
 					 OSD_MAX_CACHE_SIZE : val;
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_readcache);
 
-static int lprocfs_osd_rd_lma_self_repair(char *page, char **start, off_t off,
-					  int count, int *eof, void *data)
+static int ldiskfs_osd_lma_self_repair_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(dev != NULL);
 	if (unlikely(dev->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	*eof = 1;
-	return snprintf(page, count, "%d\n", !!dev->od_lma_self_repair);
+	return seq_printf(m, "%d\n", !!dev->od_lma_self_repair);
 }
 
-static int lprocfs_osd_wr_lma_self_repair(struct file *file, const char *buffer,
-					  unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_lma_self_repair_seq_write(struct file *file, const char *buffer,
+					size_t count, loff_t *off)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device *dev = osd_dt_dev(dt);
 	int		   val;
 	int		   rc;
 
@@ -544,38 +502,102 @@ static int lprocfs_osd_wr_lma_self_repair(struct file *file, const char *buffer,
 	dev->od_lma_self_repair = !!val;
 	return count;
 }
-
-struct lprocfs_vars lprocfs_osd_obd_vars[] = {
-	{ "blocksize",		lprocfs_dt_rd_blksize,	0, 0 },
-	{ "kbytestotal",	lprocfs_dt_rd_kbytestotal,	0, 0 },
-	{ "kbytesfree",		lprocfs_dt_rd_kbytesfree,	0, 0 },
-	{ "kbytesavail",	lprocfs_dt_rd_kbytesavail,	0, 0 },
-	{ "filestotal",		lprocfs_dt_rd_filestotal,	0, 0 },
-	{ "filesfree",		lprocfs_dt_rd_filesfree,	0, 0 },
-        { "fstype",          lprocfs_osd_rd_fstype,      0, 0 },
-        { "mntdev",          lprocfs_osd_rd_mntdev,      0, 0 },
-	{ "force_sync",      0, lprocfs_osd_wr_force_sync     },
-        { "pdo",             lprocfs_osd_rd_pdo, lprocfs_osd_wr_pdo, 0 },
-	{ "auto_scrub",      lprocfs_osd_rd_auto_scrub,
-			     lprocfs_osd_wr_auto_scrub,  0 },
-	{ "oi_scrub",	     lprocfs_osd_rd_oi_scrub,    0, 0 },
-	{ "force_sync",		0, lprocfs_osd_wr_force_sync },
-	{ "read_cache_enable",	lprocfs_osd_rd_cache, lprocfs_osd_wr_cache, 0 },
-	{ "writethrough_cache_enable",	lprocfs_osd_rd_wcache,
-					lprocfs_osd_wr_wcache, 0 },
-	{ "readcache_max_filesize",	lprocfs_osd_rd_readcache,
-					lprocfs_osd_wr_readcache, 0 },
-	{ "lma_self_repair",	lprocfs_osd_rd_lma_self_repair,
-				lprocfs_osd_wr_lma_self_repair, 0, 0 },
+LPROC_SEQ_FOPS(ldiskfs_osd_lma_self_repair);
+
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_blksize);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytestotal);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytesfree);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytesavail);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_filestotal);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_filesfree);
+
+struct lprocfs_seq_vars lprocfs_osd_obd_vars[] = {
+	{ .name	=	"blocksize",
+	  .fops	=	&ldiskfs_dt_blksize_fops	},
+	{ .name	=	"kbytestotal",
+	  .fops	=	&ldiskfs_dt_kbytestotal_fops	},
+	{ .name	=	"kbytesfree",
+	  .fops	=	&ldiskfs_dt_kbytesfree_fops	},
+	{ .name	=	"kbytesavail",
+	  .fops	=	&ldiskfs_dt_kbytesavail_fops	},
+	{ .name	=	"filestotal",
+	  .fops	=	&ldiskfs_dt_filestotal_fops	},
+	{ .name	=	"filesfree",
+	  .fops	=	&ldiskfs_dt_filesfree_fops	},
+	{ .name	=	"fstype",
+	  .fops	=	&ldiskfs_osd_fstype_fops	},
+	{ .name	=	"mntdev",
+	  .fops	=	&ldiskfs_osd_mntdev_fops	},
+	{ .name	=	"force_sync",
+	  .fops	=	&ldiskfs_osd_force_sync_fops	},
+	{ .name	=	"pdo",
+	  .fops	=	&ldiskfs_osd_pdo_fops		},
+	{ .name	=	"auto_scrub",
+	  .fops	=	&ldiskfs_osd_auto_scrub_fops	},
+	{ .name	=	"oi_scrub",
+	  .fops	=	&ldiskfs_osd_oi_scrub_fops	},
+	{ .name	=	"read_cache_enable",
+	  .fops	=	&ldiskfs_osd_cache_fops		},
+	{ .name	=	"writethrough_cache_enable",
+	  .fops	=	&ldiskfs_osd_wcache_fops	},
+	{ .name	=	"readcache_max_filesize",
+	  .fops	=	&ldiskfs_osd_readcache_fops	},
+	{ .name	=	"lma_self_repair",
+	  .fops	=	&ldiskfs_osd_lma_self_repair_fops	},
 	{ 0 }
 };
 
-struct lprocfs_vars lprocfs_osd_module_vars[] = {
-        { "num_refs",        lprocfs_rd_numrefs,     0, 0 },
-	{ "track_declares_assert",	lprocfs_osd_rd_track_declares_assert,
-					lprocfs_osd_wr_track_declares_assert,
-					0 },
-        { 0 }
+struct lprocfs_seq_vars lprocfs_osd_module_vars[] = {
+	{ .name	=	"track_declares_assert",
+	  .fops	=	&ldiskfs_osd_track_declares_assert_fops		},
+	{ 0 }
 };
 
+
+int osd_procfs_init(struct osd_device *osd, const char *name)
+{
+	struct obd_type	*type;
+	int		rc;
+	ENTRY;
+
+	if (osd->od_proc_entry)
+		RETURN(0);
+
+	/* at the moment there is no linkage between lu_type
+	 * and obd_type, so we lookup obd_type this way */
+	type = class_search_type(LUSTRE_OSD_LDISKFS_NAME);
+
+	LASSERT(name != NULL);
+	LASSERT(type != NULL);
+
+	/* Find the type procroot and add the proc entry for this device */
+	osd->od_proc_entry = lprocfs_seq_register(name, type->typ_procroot,
+						  lprocfs_osd_obd_vars,
+						  &osd->od_dt_dev);
+	if (IS_ERR(osd->od_proc_entry)) {
+		rc = PTR_ERR(osd->od_proc_entry);
+		CERROR("Error %d setting up lprocfs for %s\n",
+		       rc, name);
+		osd->od_proc_entry = NULL;
+		GOTO(out, rc);
+	}
+
+	rc = osd_stats_init(osd);
+
+	EXIT;
+out:
+	if (rc)
+		osd_procfs_fini(osd);
+	return rc;
+}
+
+int osd_procfs_fini(struct osd_device *osd)
+{
+	if (osd->od_stats)
+		lprocfs_free_stats(&osd->od_stats);
+
+	if (osd->od_proc_entry)
+		lprocfs_remove(&osd->od_proc_entry);
+	RETURN(0);
+}
 #endif
diff --git a/lustre/osd-ldiskfs/osd_scrub.c b/lustre/osd-ldiskfs/osd_scrub.c
index cce33af..1002913 100644
--- a/lustre/osd-ldiskfs/osd_scrub.c
+++ b/lustre/osd-ldiskfs/osd_scrub.c
@@ -2578,80 +2578,69 @@ static const char *scrub_param_names[] = {
 	NULL
 };
 
-static int scrub_bits_dump(char **buf, int *len, int bits, const char *names[],
+static int scrub_bits_dump(struct seq_file *m, int bits, const char *names[],
 			   const char *prefix)
 {
-	int save = *len;
 	int flag;
 	int rc;
 	int i;
 
-	rc = snprintf(*buf, *len, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
+	rc = seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
 	if (rc <= 0)
 		return -ENOSPC;
 
-	*buf += rc;
-	*len -= rc;
 	for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
 		if (flag & bits) {
 			bits &= ~flag;
-			rc = snprintf(*buf, *len, "%s%c", names[i],
-				      bits != 0 ? ',' : '\n');
+			rc = seq_printf(m, "%s%c", names[i],
+					bits != 0 ? ',' : '\n');
 			if (rc <= 0)
 				return -ENOSPC;
-
-			*buf += rc;
-			*len -= rc;
 		}
 	}
-	return save - *len;
+	return 0;
 }
 
-static int scrub_time_dump(char **buf, int *len, __u64 time, const char *prefix)
+static int scrub_time_dump(struct seq_file *m, __u64 time, const char *prefix)
 {
 	int rc;
 
 	if (time != 0)
-		rc = snprintf(*buf, *len, "%s: "LPU64" seconds\n", prefix,
+		rc = seq_printf(m, "%s: "LPU64" seconds\n", prefix,
 			      cfs_time_current_sec() - time);
 	else
-		rc = snprintf(*buf, *len, "%s: N/A\n", prefix);
+		rc = seq_printf(m, "%s: N/A\n", prefix);
 	if (rc <= 0)
 		return -ENOSPC;
 
-	*buf += rc;
-	*len -= rc;
-	return rc;
+	return 0;
 }
 
-static int scrub_pos_dump(char **buf, int *len, __u64 pos, const char *prefix)
+static int scrub_pos_dump(struct seq_file *m, __u64 pos, const char *prefix)
 {
 	int rc;
 
 	if (pos != 0)
-		rc = snprintf(*buf, *len, "%s: "LPU64"\n", prefix, pos);
+		rc = seq_printf(m, "%s: "LPU64"\n", prefix, pos);
 	else
-		rc = snprintf(*buf, *len, "%s: N/A\n", prefix);
+		rc = seq_printf(m, "%s: N/A\n", prefix);
 	if (rc <= 0)
 		return -ENOSPC;
 
-	*buf += rc;
-	*len -= rc;
 	return rc;
 }
 
-int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
+int osd_scrub_dump(struct seq_file *m,struct osd_device *dev)
 {
 	struct osd_scrub  *scrub   = &dev->od_scrub;
 	struct scrub_file *sf      = &scrub->os_file;
 	__u64		   checked;
 	__u64		   speed;
-	int		   save    = len;
 	int		   ret     = -ENOSPC;
 	int		   rc;
 
 	down_read(&scrub->os_rwsem);
-	rc = snprintf(buf, len,
+	rc = seq_printf(m,
 		      "name: OI_scrub\n"
 		      "magic: 0x%x\n"
 		      "oi_files: %d\n"
@@ -2661,51 +2650,48 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 	if (rc <= 0)
 		goto out;
 
-	buf += rc;
-	len -= rc;
-	rc = scrub_bits_dump(&buf, &len, sf->sf_flags, scrub_flags_names,
+	rc = scrub_bits_dump(m, sf->sf_flags, scrub_flags_names,
 			     "flags");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_bits_dump(&buf, &len, sf->sf_param, scrub_param_names,
+	rc = scrub_bits_dump(m, sf->sf_param, scrub_param_names,
 			     "param");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_time_dump(&buf, &len, sf->sf_time_last_complete,
+	rc = scrub_time_dump(m, sf->sf_time_last_complete,
 			     "time_since_last_completed");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_time_dump(&buf, &len, sf->sf_time_latest_start,
+	rc = scrub_time_dump(m, sf->sf_time_latest_start,
 			     "time_since_latest_start");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_time_dump(&buf, &len, sf->sf_time_last_checkpoint,
+	rc = scrub_time_dump(m, sf->sf_time_last_checkpoint,
 			     "time_since_last_checkpoint");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_pos_dump(&buf, &len, sf->sf_pos_latest_start,
+	rc = scrub_pos_dump(m, sf->sf_pos_latest_start,
 			    "latest_start_position");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_pos_dump(&buf, &len, sf->sf_pos_last_checkpoint,
+	rc = scrub_pos_dump(m, sf->sf_pos_last_checkpoint,
 			    "last_checkpoint_position");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_pos_dump(&buf, &len, sf->sf_pos_first_inconsistent,
+	rc = scrub_pos_dump(m, sf->sf_pos_first_inconsistent,
 			    "first_failure_position");
 	if (rc < 0)
 		goto out;
 
 	checked = sf->sf_items_checked + scrub->os_new_checked;
-	rc = snprintf(buf, len,
-		      "checked: "LPU64"\n"
+	rc = seq_printf(m, "checked: "LPU64"\n"
 		      "updated: "LPU64"\n"
 		      "failed: "LPU64"\n"
 		      "prior_updated: "LPU64"\n"
@@ -2718,8 +2704,6 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 	if (rc <= 0)
 		goto out;
 
-	buf += rc;
-	len -= rc;
 	speed = checked;
 	if (thread_is_running(&scrub->os_thread)) {
 		cfs_duration_t duration = cfs_time_current() -
@@ -2732,8 +2716,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 			do_div(new_checked, duration);
 		if (rtime != 0)
 			do_div(speed, rtime);
-		rc = snprintf(buf, len,
-			      "run_time: %u seconds\n"
+		rc = seq_printf(m, "run_time: %u seconds\n"
 			      "average_speed: "LPU64" objects/sec\n"
 			      "real-time_speed: "LPU64" objects/sec\n"
 			      "current_position: %u\n"
@@ -2746,8 +2729,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 	} else {
 		if (sf->sf_run_time != 0)
 			do_div(speed, sf->sf_run_time);
-		rc = snprintf(buf, len,
-			      "run_time: %u seconds\n"
+		rc = seq_printf(m, "run_time: %u seconds\n"
 			      "average_speed: "LPU64" objects/sec\n"
 			      "real-time_speed: N/A\n"
 			      "current_position: N/A\n"
@@ -2759,10 +2741,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 	}
 	if (rc <= 0)
 		goto out;
-
-	buf += rc;
-	len -= rc;
-	ret = save - len;
+	ret = 0;
 
 out:
 	up_read(&scrub->os_rwsem);
-- 
1.8.5.3