Whamcloud - gitweb
906e53ac29e9f37cda406f22358e2aec7aa7170f
[fs/lustre-release.git] / lustre / osd-ldiskfs / osd_lproc.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2015, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  *
31  * lustre/osd/osd_lproc.c
32  *
33  * Author: Mikhail Pershin <tappro@sun.com>
34  */
35
36 #define DEBUG_SUBSYSTEM S_OSD
37
38 #include <lprocfs_status.h>
39
40 #include "osd_internal.h"
41
42 #ifdef CONFIG_PROC_FS
43
44 void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf)
45 {
46         struct brw_stats *s = &osd->od_brw_stats;
47         sector_t         *last_block = NULL;
48         struct page     **pages = iobuf->dr_pages;
49         struct page      *last_page = NULL;
50         unsigned long     discont_pages = 0;
51         unsigned long     discont_blocks = 0;
52         sector_t         *blocks = iobuf->dr_blocks;
53         int               i, nr_pages = iobuf->dr_npages;
54         int               blocks_per_page;
55         int               rw = iobuf->dr_rw;
56
57         if (unlikely(nr_pages == 0))
58                 return;
59
60         blocks_per_page = PAGE_SIZE >> osd_sb(osd)->s_blocksize_bits;
61
62         lprocfs_oh_tally_log2(&s->hist[BRW_R_PAGES+rw], nr_pages);
63
64         while (nr_pages-- > 0) {
65                 if (last_page && (*pages)->index != (last_page->index + 1))
66                         discont_pages++;
67                 last_page = *pages;
68                 pages++;
69                 for (i = 0; i < blocks_per_page; i++) {
70                         if (last_block && *blocks != (*last_block + 1))
71                                 discont_blocks++;
72                         last_block = blocks++;
73                 }
74         }
75
76         lprocfs_oh_tally(&s->hist[BRW_R_DISCONT_PAGES+rw], discont_pages);
77         lprocfs_oh_tally(&s->hist[BRW_R_DISCONT_BLOCKS+rw], discont_blocks);
78 }
79
80 static void display_brw_stats(struct seq_file *seq, char *name, char *units,
81         struct obd_histogram *read, struct obd_histogram *write, int scale)
82 {
83         unsigned long read_tot, write_tot, r, w, read_cum = 0, write_cum = 0;
84         int i;
85
86         seq_printf(seq, "\n%26s read      |     write\n", " ");
87         seq_printf(seq, "%-22s %-5s %% cum %% |  %-11s %% cum %%\n",
88                    name, units, units);
89
90         read_tot = lprocfs_oh_sum(read);
91         write_tot = lprocfs_oh_sum(write);
92         for (i = 0; i < OBD_HIST_MAX; i++) {
93                 r = read->oh_buckets[i];
94                 w = write->oh_buckets[i];
95                 read_cum += r;
96                 write_cum += w;
97                 if (read_cum == 0 && write_cum == 0)
98                         continue;
99
100                 if (!scale)
101                         seq_printf(seq, "%u", i);
102                 else if (i < 10)
103                         seq_printf(seq, "%u", scale << i);
104                 else if (i < 20)
105                         seq_printf(seq, "%uK", scale << (i-10));
106                 else
107                         seq_printf(seq, "%uM", scale << (i-20));
108
109                 seq_printf(seq, ":\t\t%10lu %3u %3u   | %4lu %3u %3u\n",
110                            r, pct(r, read_tot), pct(read_cum, read_tot),
111                            w, pct(w, write_tot), pct(write_cum, write_tot));
112
113                 if (read_cum == read_tot && write_cum == write_tot)
114                         break;
115         }
116 }
117
118 static void brw_stats_show(struct seq_file *seq, struct brw_stats *brw_stats)
119 {
120         struct timespec64 now;
121
122         /* this sampling races with updates */
123         ktime_get_real_ts64(&now);
124
125         seq_printf(seq, "snapshot_time:         %lld.%09ld (secs.nsecs)\n",
126                    (s64)now.tv_sec, now.tv_nsec);
127
128         display_brw_stats(seq, "pages per bulk r/w", "rpcs",
129                           &brw_stats->hist[BRW_R_PAGES],
130                           &brw_stats->hist[BRW_W_PAGES], 1);
131
132         display_brw_stats(seq, "discontiguous pages", "rpcs",
133                           &brw_stats->hist[BRW_R_DISCONT_PAGES],
134                           &brw_stats->hist[BRW_W_DISCONT_PAGES], 0);
135
136         display_brw_stats(seq, "discontiguous blocks", "rpcs",
137                           &brw_stats->hist[BRW_R_DISCONT_BLOCKS],
138                           &brw_stats->hist[BRW_W_DISCONT_BLOCKS], 0);
139
140         display_brw_stats(seq, "disk fragmented I/Os", "ios",
141                           &brw_stats->hist[BRW_R_DIO_FRAGS],
142                           &brw_stats->hist[BRW_W_DIO_FRAGS], 0);
143
144         display_brw_stats(seq, "disk I/Os in flight", "ios",
145                           &brw_stats->hist[BRW_R_RPC_HIST],
146                           &brw_stats->hist[BRW_W_RPC_HIST], 0);
147
148         display_brw_stats(seq, "I/O time (1/1000s)", "ios",
149                           &brw_stats->hist[BRW_R_IO_TIME],
150                           &brw_stats->hist[BRW_W_IO_TIME], 1);
151
152         display_brw_stats(seq, "disk I/O size", "ios",
153                           &brw_stats->hist[BRW_R_DISK_IOSIZE],
154                           &brw_stats->hist[BRW_W_DISK_IOSIZE], 1);
155 }
156
157 static int osd_brw_stats_seq_show(struct seq_file *seq, void *v)
158 {
159         struct osd_device *osd = seq->private;
160
161         brw_stats_show(seq, &osd->od_brw_stats);
162
163         return 0;
164 }
165
166 static ssize_t osd_brw_stats_seq_write(struct file *file,
167                                        const char __user *buf,
168                                        size_t len, loff_t *off)
169 {
170         struct seq_file *seq = file->private_data;
171         struct osd_device *osd = seq->private;
172         int i;
173
174         for (i = 0; i < BRW_LAST; i++)
175                 lprocfs_oh_clear(&osd->od_brw_stats.hist[i]);
176
177         return len;
178 }
179
180 LPROC_SEQ_FOPS(osd_brw_stats);
181
182 static int osd_stats_init(struct osd_device *osd)
183 {
184         int i, result;
185         ENTRY;
186
187         for (i = 0; i < BRW_LAST; i++)
188                 spin_lock_init(&osd->od_brw_stats.hist[i].oh_lock);
189
190         osd->od_stats = lprocfs_alloc_stats(LPROC_OSD_LAST, 0);
191         if (osd->od_stats != NULL) {
192                 result = lprocfs_register_stats(osd->od_proc_entry, "stats",
193                                                 osd->od_stats);
194                 if (result)
195                         GOTO(out, result);
196
197                 lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE,
198                                      LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV,
199                                      "get_page", "usec");
200                 lprocfs_counter_init(osd->od_stats, LPROC_OSD_NO_PAGE,
201                                      LPROCFS_CNTR_AVGMINMAX,
202                                      "get_page_failures", "num");
203                 lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_ACCESS,
204                                      LPROCFS_CNTR_AVGMINMAX,
205                                      "cache_access", "pages");
206                 lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_HIT,
207                                      LPROCFS_CNTR_AVGMINMAX,
208                                      "cache_hit", "pages");
209                 lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_MISS,
210                                      LPROCFS_CNTR_AVGMINMAX,
211                                      "cache_miss", "pages");
212 #if OSD_THANDLE_STATS
213                 lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_STARTING,
214                                      LPROCFS_CNTR_AVGMINMAX,
215                                      "thandle starting", "usec");
216                 lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_OPEN,
217                                      LPROCFS_CNTR_AVGMINMAX,
218                                      "thandle open", "usec");
219                 lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_CLOSING,
220                                      LPROCFS_CNTR_AVGMINMAX,
221                                      "thandle closing", "usec");
222 #endif
223                 result = lprocfs_seq_create(osd->od_proc_entry, "brw_stats",
224                                             0644, &osd_brw_stats_fops, osd);
225         } else
226                 result = -ENOMEM;
227
228 out:
229         RETURN(result);
230 }
231
232 static ssize_t fstype_show(struct kobject *kobj, struct attribute *attr,
233                            char *buf)
234 {
235         return sprintf(buf, "ldiskfs\n");
236 }
237 LUSTRE_RO_ATTR(fstype);
238
239 static ssize_t mntdev_show(struct kobject *kobj, struct attribute *attr,
240                            char *buf)
241 {
242         struct dt_device *dt = container_of(kobj, struct dt_device,
243                                             dd_kobj);
244         struct osd_device *osd = osd_dt_dev(dt);
245
246         LASSERT(osd);
247         if (unlikely(!osd->od_mnt))
248                 return -EINPROGRESS;
249
250         return sprintf(buf, "%s\n", osd->od_mntdev);
251 }
252 LUSTRE_RO_ATTR(mntdev);
253
254 static ssize_t read_cache_enable_show(struct kobject *kobj,
255                                       struct attribute *attr,
256                                       char *buf)
257 {
258         struct dt_device *dt = container_of(kobj, struct dt_device,
259                                             dd_kobj);
260         struct osd_device *osd = osd_dt_dev(dt);
261
262         LASSERT(osd);
263         if (unlikely(!osd->od_mnt))
264                 return -EINPROGRESS;
265
266         return sprintf(buf, "%u\n", osd->od_read_cache);
267 }
268
269 static ssize_t read_cache_enable_store(struct kobject *kobj,
270                                        struct attribute *attr,
271                                        const char *buffer, size_t count)
272 {
273         struct dt_device *dt = container_of(kobj, struct dt_device,
274                                             dd_kobj);
275         struct osd_device *osd = osd_dt_dev(dt);
276         bool val;
277         int rc;
278
279         LASSERT(osd);
280         if (unlikely(!osd->od_mnt))
281                 return -EINPROGRESS;
282
283         rc = kstrtobool(buffer, &val);
284         if (rc)
285                 return rc;
286
287         osd->od_read_cache = !!val;
288         return count;
289 }
290 LUSTRE_RW_ATTR(read_cache_enable);
291
292 static ssize_t writethrough_cache_enable_show(struct kobject *kobj,
293                                               struct attribute *attr,
294                                               char *buf)
295 {
296         struct dt_device *dt = container_of(kobj, struct dt_device,
297                                             dd_kobj);
298         struct osd_device *osd = osd_dt_dev(dt);
299
300         LASSERT(osd);
301         if (unlikely(!osd->od_mnt))
302                 return -EINPROGRESS;
303
304         return sprintf(buf, "%u\n", osd->od_writethrough_cache);
305 }
306
307 static ssize_t writethrough_cache_enable_store(struct kobject *kobj,
308                                                struct attribute *attr,
309                                                const char *buffer,
310                                                size_t count)
311 {
312         struct dt_device *dt = container_of(kobj, struct dt_device,
313                                             dd_kobj);
314         struct osd_device *osd = osd_dt_dev(dt);
315         bool val;
316         int rc;
317
318         LASSERT(osd);
319         if (unlikely(!osd->od_mnt))
320                 return -EINPROGRESS;
321
322         rc = kstrtobool(buffer, &val);
323         if (rc)
324                 return rc;
325
326         osd->od_writethrough_cache = !!val;
327         return count;
328 }
329 LUSTRE_RW_ATTR(writethrough_cache_enable);
330
331 static ssize_t fallocate_zero_blocks_show(struct kobject *kobj,
332                                           struct attribute *attr,
333                                           char *buf)
334 {
335         struct dt_device *dt = container_of(kobj, struct dt_device,
336                                             dd_kobj);
337         struct osd_device *osd = osd_dt_dev(dt);
338
339         LASSERT(osd);
340         if (unlikely(!osd->od_mnt))
341                 return -EINPROGRESS;
342
343         return scnprintf(buf, PAGE_SIZE, "%d\n", osd->od_fallocate_zero_blocks);
344 }
345
346 /*
347  * Set how fallocate() interacts with the backing filesystem:
348  * -1: fallocate is disabled and returns -EOPNOTSUPP
349  *  0: fallocate allocates unwritten extents (like ext4)
350  *  1: fallocate zeroes allocated extents on disk
351  */
352 static ssize_t fallocate_zero_blocks_store(struct kobject *kobj,
353                                            struct attribute *attr,
354                                            const char *buffer, size_t count)
355 {
356         struct dt_device *dt = container_of(kobj, struct dt_device,
357                                             dd_kobj);
358         struct osd_device *osd = osd_dt_dev(dt);
359         long val;
360         int rc;
361
362         LASSERT(osd);
363         if (unlikely(!osd->od_mnt))
364                 return -EINPROGRESS;
365
366         rc = kstrtol(buffer, 0, &val);
367         if (rc)
368                 return rc;
369
370         if (val < -1 || val > 1)
371                 return -EINVAL;
372
373         osd->od_fallocate_zero_blocks = val;
374         return count;
375 }
376 LUSTRE_RW_ATTR(fallocate_zero_blocks);
377
378 ssize_t force_sync_store(struct kobject *kobj, struct attribute *attr,
379                          const char *buffer, size_t count)
380 {
381         struct dt_device *dt = container_of(kobj, struct dt_device,
382                                             dd_kobj);
383         struct osd_device *osd = osd_dt_dev(dt);
384         struct lu_env env;
385         int rc;
386
387         LASSERT(osd);
388         if (unlikely(!osd->od_mnt))
389                 return -EINPROGRESS;
390
391         rc = lu_env_init(&env, LCT_LOCAL);
392         if (rc)
393                 return rc;
394
395         rc = dt_sync(&env, dt);
396         lu_env_fini(&env);
397
398         return rc == 0 ? count : rc;
399 }
400 LUSTRE_WO_ATTR(force_sync);
401
402 static ssize_t nonrotational_show(struct kobject *kobj, struct attribute *attr,
403                                   char *buf)
404 {
405         struct dt_device *dt = container_of(kobj, struct dt_device,
406                                             dd_kobj);
407         struct osd_device *osd = osd_dt_dev(dt);
408
409         LASSERT(osd);
410         if (unlikely(!osd->od_mnt))
411                 return -EINPROGRESS;
412
413         return sprintf(buf, "%u\n", osd->od_nonrotational);
414 }
415
416 static ssize_t nonrotational_store(struct kobject *kobj,
417                                    struct attribute *attr, const char *buffer,
418                                    size_t count)
419 {
420         struct dt_device *dt = container_of(kobj, struct dt_device,
421                                             dd_kobj);
422         struct osd_device *osd = osd_dt_dev(dt);
423         bool val;
424         int rc;
425
426         LASSERT(osd);
427         if (unlikely(!osd->od_mnt))
428                 return -EINPROGRESS;
429
430         rc = kstrtobool(buffer, &val);
431         if (rc)
432                 return rc;
433
434         osd->od_nonrotational = val;
435         return count;
436 }
437 LUSTRE_RW_ATTR(nonrotational);
438
439 static ssize_t pdo_show(struct kobject *kobj, struct attribute *attr,
440                         char *buf)
441 {
442         return sprintf(buf, "%s\n", ldiskfs_pdo ? "ON" : "OFF");
443 }
444
445 static ssize_t pdo_store(struct kobject *kobj, struct attribute *attr,
446                          const char *buffer, size_t count)
447 {
448         bool pdo;
449         int rc;
450
451         rc = kstrtobool(buffer, &pdo);
452         if (rc != 0)
453                 return rc;
454
455         ldiskfs_pdo = pdo;
456
457         return count;
458 }
459 LUSTRE_RW_ATTR(pdo);
460
461 static ssize_t auto_scrub_show(struct kobject *kobj, struct attribute *attr,
462                                char *buf)
463 {
464         struct dt_device *dt = container_of(kobj, struct dt_device,
465                                             dd_kobj);
466         struct osd_device *dev = osd_dt_dev(dt);
467
468         LASSERT(dev);
469         if (unlikely(!dev->od_mnt))
470                 return -EINPROGRESS;
471
472         return sprintf(buf, "%lld\n", dev->od_auto_scrub_interval);
473 }
474
475 static ssize_t auto_scrub_store(struct kobject *kobj, struct attribute *attr,
476                                 const char *buffer, size_t count)
477 {
478         struct dt_device *dt = container_of(kobj, struct dt_device,
479                                             dd_kobj);
480         struct osd_device *dev = osd_dt_dev(dt);
481         s64 val;
482         int rc;
483
484         LASSERT(dev);
485         if (unlikely(!dev->od_mnt))
486                 return -EINPROGRESS;
487
488         rc = kstrtoll(buffer, 0, &val);
489         if (rc)
490                 return rc;
491
492         dev->od_auto_scrub_interval = val;
493         return count;
494 }
495 LUSTRE_RW_ATTR(auto_scrub);
496
497 static ssize_t full_scrub_ratio_show(struct kobject *kobj,
498                                      struct attribute *attr,
499                                      char *buf)
500 {
501         struct dt_device *dt = container_of(kobj, struct dt_device,
502                                             dd_kobj);
503         struct osd_device *dev = osd_dt_dev(dt);
504
505         LASSERT(dev);
506         if (unlikely(!dev->od_mnt))
507                 return -EINPROGRESS;
508
509         return sprintf(buf, "%llu\n", dev->od_full_scrub_ratio);
510 }
511
512 static ssize_t full_scrub_ratio_store(struct kobject *kobj,
513                                       struct attribute *attr,
514                                       const char *buffer, size_t count)
515 {
516         struct dt_device *dt = container_of(kobj, struct dt_device,
517                                             dd_kobj);
518         struct osd_device *dev = osd_dt_dev(dt);
519         s64 val;
520         int rc;
521
522         LASSERT(dev);
523         if (unlikely(!dev->od_mnt))
524                 return -EINPROGRESS;
525
526         rc = kstrtoll(buffer, 0, &val);
527         if (rc)
528                 return rc;
529
530         if (val < 0)
531                 return -EINVAL;
532
533         dev->od_full_scrub_ratio = val;
534         return count;
535 }
536 LUSTRE_RW_ATTR(full_scrub_ratio);
537
538 static ssize_t full_scrub_threshold_rate_show(struct kobject *kobj,
539                                               struct attribute *attr,
540                                               char *buf)
541 {
542         struct dt_device *dt = container_of(kobj, struct dt_device,
543                                             dd_kobj);
544         struct osd_device *dev = osd_dt_dev(dt);
545
546         LASSERT(dev);
547         if (unlikely(!dev->od_mnt))
548                 return -EINPROGRESS;
549
550         return sprintf(buf, "%llu (bad OI mappings/minute)\n",
551                        dev->od_full_scrub_threshold_rate);
552 }
553
554 static ssize_t full_scrub_threshold_rate_store(struct kobject *kobj,
555                                                struct attribute *attr,
556                                                const char *buffer, size_t count)
557 {
558         struct dt_device *dt = container_of(kobj, struct dt_device,
559                                             dd_kobj);
560         struct osd_device *dev = osd_dt_dev(dt);
561         u64 val;
562         int rc;
563
564         LASSERT(dev);
565         if (unlikely(!dev->od_mnt))
566                 return -EINPROGRESS;
567
568         rc = kstrtoull(buffer, 0, &val);
569         if (rc != 0)
570                 return rc;
571
572         dev->od_full_scrub_threshold_rate = val;
573         return count;
574 }
575 LUSTRE_RW_ATTR(full_scrub_threshold_rate);
576
577 static ssize_t extent_bytes_allocation_show(struct kobject *kobj,
578                                             struct attribute *attr, char *buf)
579 {
580         struct dt_device *dt = container_of(kobj, struct dt_device,
581                                             dd_kobj);
582         struct osd_device *dev = osd_dt_dev(dt);
583         int i;
584         unsigned int min = (unsigned int)(~0), cur;
585
586         for_each_online_cpu(i) {
587                 cur = *per_cpu_ptr(dev->od_extent_bytes_percpu, i);
588                 if (cur < min)
589                         min = cur;
590         }
591         return snprintf(buf, PAGE_SIZE, "%u\n", min);
592 }
593 LUSTRE_RO_ATTR(extent_bytes_allocation);
594
595 static int ldiskfs_osd_oi_scrub_seq_show(struct seq_file *m, void *data)
596 {
597         struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private);
598
599         LASSERT(dev != NULL);
600         if (unlikely(dev->od_mnt == NULL))
601                 return -EINPROGRESS;
602
603         osd_scrub_dump(m, dev);
604         return 0;
605 }
606
607 LDEBUGFS_SEQ_FOPS_RO(ldiskfs_osd_oi_scrub);
608
609 static int ldiskfs_osd_readcache_seq_show(struct seq_file *m, void *data)
610 {
611         struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
612
613         LASSERT(osd != NULL);
614         if (unlikely(osd->od_mnt == NULL))
615                 return -EINPROGRESS;
616
617         seq_printf(m, "%llu\n", osd->od_readcache_max_filesize);
618         return 0;
619 }
620
621 static ssize_t
622 ldiskfs_osd_readcache_seq_write(struct file *file, const char __user *buffer,
623                                 size_t count, loff_t *off)
624 {
625         struct seq_file *m = file->private_data;
626         struct dt_device *dt = m->private;
627         struct osd_device *osd = osd_dt_dev(dt);
628         char kernbuf[22] = "";
629         u64 val;
630         int rc;
631
632         LASSERT(osd != NULL);
633         if (unlikely(osd->od_mnt == NULL))
634                 return -EINPROGRESS;
635
636         if (count >= sizeof(kernbuf))
637                 return -EINVAL;
638
639         if (copy_from_user(kernbuf, buffer, count))
640                 return -EFAULT;
641         kernbuf[count] = 0;
642
643         rc = sysfs_memparse(kernbuf, count, &val, "B");
644         if (rc < 0)
645                 return rc;
646
647         osd->od_readcache_max_filesize = val > OSD_MAX_CACHE_SIZE ?
648                                          OSD_MAX_CACHE_SIZE : val;
649         return count;
650 }
651
652 LDEBUGFS_SEQ_FOPS(ldiskfs_osd_readcache);
653
654 static int ldiskfs_osd_readcache_max_io_seq_show(struct seq_file *m, void *data)
655 {
656         struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
657
658         LASSERT(osd != NULL);
659         if (unlikely(osd->od_mnt == NULL))
660                 return -EINPROGRESS;
661
662         seq_printf(m, "%lu\n", osd->od_readcache_max_iosize >> 20);
663         return 0;
664 }
665
666 static ssize_t
667 ldiskfs_osd_readcache_max_io_seq_write(struct file *file,
668                                        const char __user *buffer,
669                                        size_t count, loff_t *off)
670 {
671         struct seq_file *m = file->private_data;
672         struct dt_device *dt = m->private;
673         struct osd_device *osd = osd_dt_dev(dt);
674         char kernbuf[22] = "";
675         u64 val;
676         int rc;
677
678         LASSERT(osd != NULL);
679         if (unlikely(osd->od_mnt == NULL))
680                 return -EINPROGRESS;
681
682         if (count >= sizeof(kernbuf))
683                 return -EINVAL;
684
685         if (copy_from_user(kernbuf, buffer, count))
686                 return -EFAULT;
687         kernbuf[count] = 0;
688
689         rc = sysfs_memparse(kernbuf, count, &val, "MiB");
690         if (rc < 0)
691                 return rc;
692
693         if (val > PTLRPC_MAX_BRW_SIZE)
694                 return -ERANGE;
695         osd->od_readcache_max_iosize = val;
696         return count;
697 }
698
699 LDEBUGFS_SEQ_FOPS(ldiskfs_osd_readcache_max_io);
700
701 static int ldiskfs_osd_writethrough_max_io_seq_show(struct seq_file *m,
702                                                     void *data)
703 {
704         struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
705
706         LASSERT(osd != NULL);
707         if (unlikely(osd->od_mnt == NULL))
708                 return -EINPROGRESS;
709
710         seq_printf(m, "%lu\n", osd->od_writethrough_max_iosize >> 20);
711         return 0;
712 }
713
714 static ssize_t
715 ldiskfs_osd_writethrough_max_io_seq_write(struct file *file,
716                                        const char __user *buffer,
717                                        size_t count, loff_t *off)
718 {
719         struct seq_file *m = file->private_data;
720         struct dt_device *dt = m->private;
721         struct osd_device *osd = osd_dt_dev(dt);
722         char kernbuf[22] = "";
723         u64 val;
724         int rc;
725
726         LASSERT(osd != NULL);
727         if (unlikely(osd->od_mnt == NULL))
728                 return -EINPROGRESS;
729
730         if (count >= sizeof(kernbuf))
731                 return -EINVAL;
732
733         if (copy_from_user(kernbuf, buffer, count))
734                 return -EFAULT;
735         kernbuf[count] = 0;
736
737         rc = sysfs_memparse(kernbuf, count, &val, "MiB");
738         if (rc < 0)
739                 return rc;
740
741         if (val > PTLRPC_MAX_BRW_SIZE)
742                 return -ERANGE;
743         osd->od_writethrough_max_iosize = val;
744         return count;
745 }
746
747 LDEBUGFS_SEQ_FOPS(ldiskfs_osd_writethrough_max_io);
748
749 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 52, 0)
750 static ssize_t index_in_idif_show(struct kobject *kobj, struct attribute *attr,
751                                   char *buf)
752 {
753         struct dt_device *dt = container_of(kobj, struct dt_device,
754                                             dd_kobj);
755         struct osd_device *dev = osd_dt_dev(dt);
756
757         LASSERT(dev);
758         if (unlikely(!dev->od_mnt))
759                 return -EINPROGRESS;
760
761         return sprintf(buf, "%d\n", (int)(dev->od_index_in_idif));
762 }
763
764 static ssize_t index_in_idif_store(struct kobject *kobj,
765                                    struct attribute *attr,
766                                    const char *buffer, size_t count)
767 {
768         struct dt_device *dt = container_of(kobj, struct dt_device,
769                                             dd_kobj);
770         struct osd_device *dev = osd_dt_dev(dt);
771         struct lu_target *tgt;
772         struct lu_env env;
773         bool val;
774         int rc;
775
776         LASSERT(dev);
777         if (unlikely(!dev->od_mnt))
778                 return -EINPROGRESS;
779
780         rc = kstrtobool(buffer, &val);
781         if (rc)
782                 return rc;
783
784         if (dev->od_index_in_idif) {
785                 if (val)
786                         return count;
787
788                 LCONSOLE_WARN("%s: OST-index in IDIF has been enabled, "
789                               "it cannot be reverted back.\n", osd_name(dev));
790                 return -EPERM;
791         }
792
793         if (!val)
794                 return count;
795
796         rc = lu_env_init(&env, LCT_DT_THREAD);
797         if (rc)
798                 return rc;
799
800         tgt = dev->od_dt_dev.dd_lu_dev.ld_site->ls_tgt;
801         tgt->lut_lsd.lsd_feature_rocompat |= OBD_ROCOMPAT_IDX_IN_IDIF;
802         rc = tgt_server_data_update(&env, tgt, 1);
803         lu_env_fini(&env);
804         if (rc < 0)
805                 return rc;
806
807         LCONSOLE_INFO("%s: enable OST-index in IDIF successfully, "
808                       "it cannot be reverted back.\n", osd_name(dev));
809
810         dev->od_index_in_idif = 1;
811         return count;
812 }
813 LUSTRE_RW_ATTR(index_in_idif);
814
815 int osd_register_proc_index_in_idif(struct osd_device *osd)
816 {
817         struct dt_device *dt = &osd->od_dt_dev;
818
819         return sysfs_create_file(&dt->dd_kobj, &lustre_attr_index_in_idif.attr);
820 }
821 #endif
822
823 static ssize_t index_backup_show(struct kobject *kobj, struct attribute *attr,
824                                  char *buf)
825 {
826         struct dt_device *dt = container_of(kobj, struct dt_device,
827                                             dd_kobj);
828         struct osd_device *dev = osd_dt_dev(dt);
829
830         LASSERT(dev);
831         if (unlikely(!dev->od_mnt))
832                 return -EINPROGRESS;
833
834         return sprintf(buf, "%d\n", dev->od_index_backup_policy);
835 }
836
837 ssize_t index_backup_store(struct kobject *kobj, struct attribute *attr,
838                            const char *buffer, size_t count)
839 {
840         struct dt_device *dt = container_of(kobj, struct dt_device,
841                                            dd_kobj);
842         struct osd_device *dev = osd_dt_dev(dt);
843         int val;
844         int rc;
845
846         LASSERT(dev);
847         if (unlikely(!dev->od_mnt))
848                 return -EINPROGRESS;
849
850         rc = kstrtoint(buffer, 0, &val);
851         if (rc)
852                 return rc;
853
854         dev->od_index_backup_policy = val;
855         return count;
856 }
857 LUSTRE_RW_ATTR(index_backup);
858
859 struct ldebugfs_vars ldebugfs_osd_obd_vars[] = {
860         { .name =       "oi_scrub",
861           .fops =       &ldiskfs_osd_oi_scrub_fops      },
862         { .name =       "readcache_max_filesize",
863           .fops =       &ldiskfs_osd_readcache_fops     },
864         { .name =       "readcache_max_io_mb",
865           .fops =       &ldiskfs_osd_readcache_max_io_fops      },
866         { .name =       "writethrough_max_io_mb",
867           .fops =       &ldiskfs_osd_writethrough_max_io_fops   },
868         { NULL }
869 };
870
871 static struct attribute *ldiskfs_attrs[] = {
872         &lustre_attr_read_cache_enable.attr,
873         &lustre_attr_writethrough_cache_enable.attr,
874         &lustre_attr_fstype.attr,
875         &lustre_attr_mntdev.attr,
876         &lustre_attr_fallocate_zero_blocks.attr,
877         &lustre_attr_force_sync.attr,
878         &lustre_attr_nonrotational.attr,
879         &lustre_attr_index_backup.attr,
880         &lustre_attr_auto_scrub.attr,
881         &lustre_attr_pdo.attr,
882         &lustre_attr_full_scrub_ratio.attr,
883         &lustre_attr_full_scrub_threshold_rate.attr,
884         &lustre_attr_extent_bytes_allocation.attr,
885         NULL,
886 };
887
888 int osd_procfs_init(struct osd_device *osd, const char *name)
889 {
890         struct obd_type *type;
891         int rc;
892
893         ENTRY;
894
895         /* at the moment there is no linkage between lu_type
896          * and obd_type, so we lookup obd_type this way
897          */
898         type = class_search_type(LUSTRE_OSD_LDISKFS_NAME);
899
900         LASSERT(name);
901         LASSERT(type);
902
903         CDEBUG(D_CONFIG, "%s: register osd-ldiskfs tunable parameters\n", name);
904
905         /* put reference taken by class_search_type */
906         kobject_put(&type->typ_kobj);
907
908         osd->od_dt_dev.dd_ktype.default_attrs = ldiskfs_attrs;
909         rc = dt_tunables_init(&osd->od_dt_dev, type, name,
910                               ldebugfs_osd_obd_vars);
911         if (rc) {
912                 CERROR("%s: cannot setup sysfs / debugfs entry: %d\n",
913                        name, rc);
914                 GOTO(out, rc);
915         }
916
917         if (osd->od_proc_entry)
918                 RETURN(0);
919
920         /* Find the type procroot and add the proc entry for this device */
921         osd->od_proc_entry = lprocfs_register(name, type->typ_procroot,
922                                               NULL, &osd->od_dt_dev);
923         if (IS_ERR(osd->od_proc_entry)) {
924                 rc = PTR_ERR(osd->od_proc_entry);
925                 CERROR("Error %d setting up lprocfs for %s\n",
926                        rc, name);
927                 osd->od_proc_entry = NULL;
928                 GOTO(out, rc);
929         }
930
931         rc = osd_stats_init(osd);
932
933         EXIT;
934 out:
935         if (rc)
936                 osd_procfs_fini(osd);
937         return rc;
938 }
939
940 int osd_procfs_fini(struct osd_device *osd)
941 {
942         if (osd->od_stats)
943                 lprocfs_free_stats(&osd->od_stats);
944
945         if (osd->od_proc_entry)
946                 lprocfs_remove(&osd->od_proc_entry);
947
948         return dt_tunables_fini(&osd->od_dt_dev);
949 }
950 #endif