Whamcloud - gitweb
LU-11997 ptlrpc: Properly swab ll_fiemap_info_key
[fs/lustre-release.git] / lustre / ofd / lproc_ofd.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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2012, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lustre/ofd/lproc_ofd.c
33  *
34  * This file provides functions of procfs interface for OBD Filter Device (OFD).
35  *
36  * Author: Andreas Dilger <andreas.dilger@intel.com>
37  * Author: Mikhail Pershin <mike.pershin@intel.com>
38  * Author: Johann Lombardi <johann.lombardi@intel.com>
39  * Author: Fan Yong <fan.yong@intel.com>
40  */
41
42 #define DEBUG_SUBSYSTEM S_CLASS
43
44 #include <obd.h>
45 #include <lprocfs_status.h>
46 #include <linux/seq_file.h>
47 #include <lustre_lfsck.h>
48
49 #include "ofd_internal.h"
50
51 #ifdef CONFIG_PROC_FS
52
53 /**
54  * Show number of FID allocation sequences.
55  *
56  * \param[in] m         seq_file handle
57  * \param[in] data      unused for single entry
58  *
59  * \retval              0 on success
60  * \retval              negative value on error
61  */
62 static ssize_t seqs_allocated_show(struct kobject *kobj, struct attribute *attr,
63                                    char *buf)
64 {
65         struct obd_device *obd = container_of(kobj, struct obd_device,
66                                               obd_kset.kobj);
67         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
68
69         return sprintf(buf, "%u\n", ofd->ofd_seq_count);
70 }
71 LUSTRE_RO_ATTR(seqs_allocated);
72
73 /**
74  * Show total number of grants for precreate.
75  *
76  * \param[in] m         seq_file handle
77  * \param[in] data      unused for single entry
78  *
79  * \retval              0 on success
80  * \retval              negative value on error
81  */
82 static ssize_t grant_precreate_show(struct kobject *kobj,
83                                     struct attribute *attr,
84                                     char *buf)
85 {
86         struct obd_device *obd = container_of(kobj, struct obd_device,
87                                               obd_kset.kobj);
88
89         return sprintf(buf, "%ld\n",
90                        obd->obd_self_export->exp_target_data.ted_grant);
91 }
92 LUSTRE_RO_ATTR(grant_precreate);
93
94 /**
95  * Show number of precreates allowed in a single transaction.
96  *
97  * \param[in] m         seq_file handle
98  * \param[in] data      unused for single entry
99  *
100  * \retval              0 on success
101  * \retval              negative value on error
102  */
103 static ssize_t precreate_batch_show(struct kobject *kobj,
104                                     struct attribute *attr,
105                                     char *buf)
106 {
107         struct obd_device *obd = container_of(kobj, struct obd_device,
108                                               obd_kset.kobj);
109         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
110
111         return sprintf(buf, "%d\n", ofd->ofd_precreate_batch);
112 }
113
114 /**
115  * Change number of precreates allowed in a single transaction.
116  *
117  * \param[in] file      proc file
118  * \param[in] buffer    string which represents maximum number
119  * \param[in] count     \a buffer length
120  * \param[in] off       unused for single entry
121  *
122  * \retval              \a count on success
123  * \retval              negative number on error
124  */
125 static ssize_t precreate_batch_store(struct kobject *kobj,
126                                      struct attribute *attr,
127                                      const char *buffer, size_t count)
128 {
129         struct obd_device *obd = container_of(kobj, struct obd_device,
130                                               obd_kset.kobj);
131         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
132         unsigned int val;
133         int rc;
134
135         rc = kstrtouint(buffer, 0, &val);
136         if (rc)
137                 return rc;
138
139         if (val < 1 || val > 65536)
140                 return -EINVAL;
141
142         spin_lock(&ofd->ofd_batch_lock);
143         ofd->ofd_precreate_batch = val;
144         spin_unlock(&ofd->ofd_batch_lock);
145         return count;
146 }
147 LUSTRE_RW_ATTR(precreate_batch);
148
149 /**
150  * Show the last used ID for each FID sequence used by OFD.
151  *
152  * \param[in] m         seq_file handle
153  * \param[in] data      unused for single entry
154  *
155  * \retval              0 on success
156  * \retval              negative value on error
157  */
158 static int ofd_last_id_seq_show(struct seq_file *m, void *data)
159 {
160         struct obd_device       *obd = m->private;
161         struct ofd_device       *ofd;
162         struct ofd_seq          *oseq = NULL;
163
164         if (obd == NULL)
165                 return 0;
166
167         ofd = ofd_dev(obd->obd_lu_dev);
168
169         read_lock(&ofd->ofd_seq_list_lock);
170         list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
171                 __u64 seq;
172
173                 seq = ostid_seq(&oseq->os_oi) == 0 ?
174                       fid_idif_seq(ostid_id(&oseq->os_oi),
175                                    ofd->ofd_lut.lut_lsd.lsd_osd_index) :
176                       ostid_seq(&oseq->os_oi);
177                 seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
178         }
179         read_unlock(&ofd->ofd_seq_list_lock);
180         return 0;
181 }
182
183 LPROC_SEQ_FOPS_RO(ofd_last_id);
184
185 /**
186  * Show if the OFD is in degraded mode.
187  *
188  * Degraded means OFD has a failed drive or is undergoing RAID rebuild.
189  * The MDS will try to avoid using this OST for new object allocations
190  * to reduce the impact to global IO performance when clients writing to
191  * this OST are slowed down.  It also reduces the contention on the OST
192  * RAID device, allowing it to rebuild more quickly.
193  *
194  * \param[in] m         seq_file handle
195  * \param[in] data      unused for single entry
196  *
197  * \retval              0 on success
198  * \retval              negative value on error
199  */
200 static ssize_t degraded_show(struct kobject *kobj, struct attribute *attr,
201                              char *buf)
202 {
203         struct obd_device *obd = container_of(kobj, struct obd_device,
204                                               obd_kset.kobj);
205         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
206
207         return sprintf(buf, "%u\n", ofd->ofd_raid_degraded);
208 }
209
210 /**
211  * Set OFD to degraded mode.
212  *
213  * This is used to interface to userspace administrative tools for
214  * the underlying RAID storage, so that they can mark an OST
215  * as having degraded performance.
216  *
217  * \param[in] file      proc file
218  * \param[in] buffer    string which represents mode
219  *                      1: set degraded mode
220  *                      0: unset degraded mode
221  * \param[in] count     \a buffer length
222  * \param[in] off       unused for single entry
223  *
224  * \retval              \a count on success
225  * \retval              negative number on error
226  */
227 static ssize_t degraded_store(struct kobject *kobj, struct attribute *attr,
228                               const char *buffer, size_t count)
229 {
230         struct obd_device *obd = container_of(kobj, struct obd_device,
231                                               obd_kset.kobj);
232         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
233         bool val;
234         int rc;
235
236         rc = kstrtobool(buffer, &val);
237         if (rc)
238                 return rc;
239
240         spin_lock(&ofd->ofd_flags_lock);
241         ofd->ofd_raid_degraded = val;
242         spin_unlock(&ofd->ofd_flags_lock);
243         return count;
244 }
245 LUSTRE_RW_ATTR(degraded);
246
247 /**
248  * Show OFD filesystem type.
249  *
250  * \param[in] m         seq_file handle
251  * \param[in] data      unused for single entry
252  *
253  * \retval              0 on success
254  * \retval              negative value on error
255  */
256 static ssize_t fstype_show(struct kobject *kobj, struct attribute *attr,
257                            char *buf)
258 {
259         struct obd_device *obd = container_of(kobj, struct obd_device,
260                                               obd_kset.kobj);
261         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
262         struct lu_device  *d;
263
264         LASSERT(ofd->ofd_osd);
265         d = &ofd->ofd_osd->dd_lu_dev;
266         LASSERT(d->ld_type);
267         return sprintf(buf, "%s\n", d->ld_type->ldt_name);
268 }
269 LUSTRE_RO_ATTR(fstype);
270
271 /**
272  * Show journal handling mode: synchronous or asynchronous.
273  *
274  * When running in asynchronous mode the journal transactions are not
275  * committed to disk before the RPC is replied back to the client.
276  * This will typically improve client performance when only a small number
277  * of clients are writing, since the client(s) can have more write RPCs
278  * in flight. However, it also means that the client has to handle recovery
279  * on bulk RPCs, and will have to keep more dirty pages in cache before they
280  * are committed on the OST.
281  *
282  * \param[in] m         seq_file handle
283  * \param[in] data      unused for single entry
284  *
285  * \retval              0 on success
286  * \retval              negative value on error
287  */
288 static ssize_t sync_journal_show(struct kobject *kobj, struct attribute *attr,
289                                 char *buf)
290 {
291         struct obd_device *obd = container_of(kobj, struct obd_device,
292                                               obd_kset.kobj);
293         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
294
295         return sprintf(buf, "%u\n", ofd->ofd_sync_journal);
296 }
297
298 /**
299  * Set journal mode to synchronous or asynchronous.
300  *
301  * \param[in] file      proc file
302  * \param[in] buffer    string which represents mode
303  *                      1: synchronous mode
304  *                      0: asynchronous mode
305  * \param[in] count     \a buffer length
306  * \param[in] off       unused for single entry
307  *
308  * \retval              \a count on success
309  * \retval              negative number on error
310  */
311 static ssize_t sync_journal_store(struct kobject *kobj, struct attribute *attr,
312                                  const char *buffer, size_t count)
313 {
314         struct obd_device *obd = container_of(kobj, struct obd_device,
315                                               obd_kset.kobj);
316         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
317         bool val;
318         int rc;
319
320         rc = kstrtobool(buffer, &val);
321         if (rc)
322                 return rc;
323
324         spin_lock(&ofd->ofd_flags_lock);
325         ofd->ofd_sync_journal = val;
326         ofd_slc_set(ofd);
327         spin_unlock(&ofd->ofd_flags_lock);
328
329         return count;
330 }
331 LUSTRE_RW_ATTR(sync_journal);
332
333 static int ofd_brw_size_seq_show(struct seq_file *m, void *data)
334 {
335         struct obd_device       *obd = m->private;
336         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
337
338         seq_printf(m, "%u\n", ofd->ofd_brw_size / ONE_MB_BRW_SIZE);
339         return 0;
340 }
341
342 static ssize_t
343 ofd_brw_size_seq_write(struct file *file, const char __user *buffer,
344                        size_t count, loff_t *off)
345 {
346         struct seq_file *m = file->private_data;
347         struct obd_device *obd = m->private;
348         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
349         __s64 val;
350         int rc;
351
352         rc = lprocfs_str_with_units_to_s64(buffer, count, &val, 'M');
353         if (rc)
354                 return rc;
355
356         if (val <= 0)
357                 return -EINVAL;
358
359         if (val > DT_MAX_BRW_SIZE ||
360             val < (1 << ofd->ofd_lut.lut_tgd.tgd_blockbits))
361                 return -ERANGE;
362
363         spin_lock(&ofd->ofd_flags_lock);
364         ofd->ofd_brw_size = val;
365         spin_unlock(&ofd->ofd_flags_lock);
366
367         return count;
368 }
369
370 LPROC_SEQ_FOPS(ofd_brw_size);
371
372 /**
373  * Show the limit of soft sync RPCs.
374  *
375  * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
376  * are allowed before sync update will be triggered.
377  *
378  * \param[in] m         seq_file handle
379  * \param[in] data      unused for single entry
380  *
381  * \retval              0 on success
382  * \retval              negative value on error
383  */
384 static ssize_t soft_sync_limit_show(struct kobject *kobj,
385                                     struct attribute *attr, char *buf)
386 {
387         struct obd_device *obd = container_of(kobj, struct obd_device,
388                                               obd_kset.kobj);
389         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
390
391         return sprintf(buf, "%u\n", ofd->ofd_soft_sync_limit);
392 }
393
394 /**
395  * Change the limit of soft sync RPCs.
396  *
397  * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
398  * allowed before sync update will be done.
399  *
400  * This limit is global across all exports.
401  *
402  * \param[in] file      proc file
403  * \param[in] buffer    string which represents limit
404  * \param[in] count     \a buffer length
405  * \param[in] off       unused for single entry
406  *
407  * \retval              \a count on success
408  * \retval              negative number on error
409  */
410 static ssize_t soft_sync_limit_store(struct kobject *kobj,
411                                      struct attribute *attr,
412                                      const char *buffer, size_t count)
413 {
414         struct obd_device *obd = container_of(kobj, struct obd_device,
415                                               obd_kset.kobj);
416         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
417         unsigned int val;
418         int rc;
419
420         rc = kstrtouint(buffer, 0, &val);
421         if (rc < 0)
422                 return rc;
423
424         ofd->ofd_soft_sync_limit = val;
425         return 0;
426 }
427 LUSTRE_RW_ATTR(soft_sync_limit);
428
429 /**
430  * Show the LFSCK speed limit.
431  *
432  * The maximum number of items scanned per second.
433  *
434  * \param[in] m         seq_file handle
435  * \param[in] data      unused for single entry
436  *
437  * \retval              0 on success
438  * \retval              negative value on error
439  */
440 static ssize_t lfsck_speed_limit_show(struct kobject *kobj,
441                                       struct attribute *attr, char *buf)
442 {
443         struct obd_device *obd = container_of(kobj, struct obd_device,
444                                               obd_kset.kobj);
445         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
446
447         return lfsck_get_speed(buf, ofd->ofd_osd);
448 }
449
450 /**
451  * Change the LFSCK speed limit.
452  *
453  * Limit number of items that may be scanned per second.
454  *
455  * \param[in] file      proc file
456  * \param[in] buffer    string which represents limit
457  * \param[in] count     \a buffer length
458  * \param[in] off       unused for single entry
459  *
460  * \retval              \a count on success
461  * \retval              negative number on error
462  */
463 static ssize_t lfsck_speed_limit_store(struct kobject *kobj,
464                                        struct attribute *attr,
465                                        const char *buffer, size_t count)
466 {
467         struct obd_device *obd = container_of(kobj, struct obd_device,
468                                               obd_kset.kobj);
469         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
470         unsigned int val;
471         int rc;
472
473         rc = kstrtouint(buffer, 0, &val);
474         if (rc != 0)
475                 return rc;
476
477         rc = lfsck_set_speed(ofd->ofd_osd, val);
478
479         return rc != 0 ? rc : count;
480 }
481 LUSTRE_RW_ATTR(lfsck_speed_limit);
482
483 /**
484  * Show LFSCK layout verification stats from the most recent LFSCK run.
485  *
486  * \param[in] m         seq_file handle
487  * \param[in] data      unused for single entry
488  *
489  * \retval              0 on success
490  * \retval              negative value on error
491  */
492 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
493 {
494         struct obd_device *obd = m->private;
495         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
496
497         return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
498 }
499
500 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
501
502 /**
503  * Show if LFSCK performed parent FID verification.
504  *
505  * \param[in] m         seq_file handle
506  * \param[in] data      unused for single entry
507  *
508  * \retval              0 on success
509  * \retval              negative value on error
510  */
511 static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
512 {
513         struct obd_device *obd = m->private;
514         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
515
516         seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
517                    ofd->ofd_lfsck_verify_pfid ? "on" : "off",
518                    ofd->ofd_inconsistency_self_detected,
519                    ofd->ofd_inconsistency_self_repaired);
520         return 0;
521 }
522
523 /**
524  * Set the LFSCK behavior to verify parent FID correctness.
525  *
526  * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
527  * verification during read/write operations.
528  *
529  * \param[in] file      proc file
530  * \param[in] buffer    string which represents behavior
531  *                      1: verify parent FID
532  *                      0: don't verify parent FID
533  * \param[in] count     \a buffer length
534  * \param[in] off       unused for single entry
535  *
536  * \retval              \a count on success
537  * \retval              negative number on error
538  */
539 static ssize_t
540 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
541                                 size_t count, loff_t *off)
542 {
543         struct seq_file *m = file->private_data;
544         struct obd_device *obd = m->private;
545         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
546         bool val;
547         int rc;
548
549         rc = kstrtobool_from_user(buffer, count, &val);
550         if (rc)
551                 return rc;
552
553         ofd->ofd_lfsck_verify_pfid = val;
554         if (!ofd->ofd_lfsck_verify_pfid) {
555                 ofd->ofd_inconsistency_self_detected = 0;
556                 ofd->ofd_inconsistency_self_repaired = 0;
557         }
558
559         return count;
560 }
561
562 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
563
564 static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
565 {
566         struct obd_device *obd = m->private;
567
568         return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
569 }
570
571 LPROC_SEQ_FOPS_RO(ofd_site_stats);
572
573 /**
574  * Show if the OFD enforces T10PI checksum.
575  *
576  * \param[in] m         seq_file handle
577  * \param[in] data      unused for single entry
578  *
579  * \retval              0 on success
580  * \retval              negative value on error
581  */
582 static ssize_t checksum_t10pi_enforce_show(struct kobject *kobj,
583                                            struct attribute *attr,
584                                            char *buf)
585 {
586         struct obd_device *obd = container_of(kobj, struct obd_device,
587                                               obd_kset.kobj);
588         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
589
590         return sprintf(buf, "%u\n", ofd->ofd_checksum_t10pi_enforce);
591 }
592
593 /**
594  * Force specific T10PI checksum modes to be enabled
595  *
596  * If T10PI *is* supported in hardware, allow only the supported T10PI type
597  * to be used. If T10PI is *not* supported by the OSD, setting the enforce
598  * parameter forces all T10PI types to be enabled (even if slower) for
599  * testing.
600  *
601  * The final determination of which algorithm to be used depends whether
602  * the client supports T10PI or not, and is handled at client connect time.
603  *
604  * \param[in] file      proc file
605  * \param[in] buffer    string which represents mode
606  *                      1: set T10PI checksums enforced
607  *                      0: unset T10PI checksums enforced
608  * \param[in] count     \a buffer length
609  * \param[in] off       unused for single entry
610  *
611  * \retval              \a count on success
612  * \retval              negative number on error
613  */
614 static ssize_t checksum_t10pi_enforce_store(struct kobject *kobj,
615                                             struct attribute *attr,
616                                             const char *buffer, size_t count)
617 {
618         struct obd_device *obd = container_of(kobj, struct obd_device,
619                                               obd_kset.kobj);
620         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
621         bool enforce;
622         int rc;
623
624         rc = kstrtobool(buffer, &enforce);
625         if (rc)
626                 return rc;
627
628         spin_lock(&ofd->ofd_flags_lock);
629         ofd->ofd_checksum_t10pi_enforce = enforce;
630         spin_unlock(&ofd->ofd_flags_lock);
631         return count;
632 }
633 LUSTRE_RW_ATTR(checksum_t10pi_enforce);
634
635 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0)
636 static bool max_file_warned;
637 static bool rd_cache_warned;
638 static bool wr_cache_warned;
639
640 static ssize_t read_cache_enable_show(struct kobject *kobj,
641                                       struct attribute *attr,
642                                       char *buf)
643 {
644         struct obd_device *obd = container_of(kobj, struct obd_device,
645                                               obd_kset.kobj);
646         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
647
648         if (!rd_cache_warned) {
649                 rd_cache_warned = true;
650                 pr_info("ofd: 'obdfilter.*.read_cache_enabled' is deprecated, use 'osd-*.read_cache_enabled' instead\n");
651         }
652
653         if (!ofd->ofd_read_cache_enable)
654                 return -EOPNOTSUPP;
655
656         return lustre_attr_show(&ofd->ofd_osd->dd_kobj,
657                                 ofd->ofd_read_cache_enable, buf);
658 }
659
660 static ssize_t read_cache_enable_store(struct kobject *kobj,
661                                        struct attribute *attr,
662                                        const char *buffer, size_t count)
663 {
664         struct obd_device *obd = container_of(kobj, struct obd_device,
665                                               obd_kset.kobj);
666         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
667
668         if (!rd_cache_warned) {
669                 rd_cache_warned = true;
670                 pr_info("ofd: 'obdfilter.*.read_cache_enabled' is deprecated, use 'osd-*.read_cache_enabled' instead\n");
671         }
672
673         if (!ofd->ofd_read_cache_enable)
674                 return -EOPNOTSUPP;
675
676         return lustre_attr_store(&ofd->ofd_osd->dd_kobj,
677                                  ofd->ofd_read_cache_enable, buffer, count);
678 }
679 LUSTRE_RW_ATTR(read_cache_enable);
680
681 static ssize_t readcache_max_filesize_show(struct kobject *kobj,
682                                            struct attribute *attr,
683                                            char *buf)
684 {
685         struct obd_device *obd = container_of(kobj, struct obd_device,
686                                               obd_kset.kobj);
687         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
688
689         if (!max_file_warned) {
690                 max_file_warned = true;
691                 pr_info("ofd: 'obdfilter.*.readcache_max_filesize' is deprecated, use 'osd-*.readcache_max_filesize' instead\n");
692         }
693
694         if (!ofd->ofd_read_cache_max_filesize)
695                 return -EOPNOTSUPP;
696
697         return lustre_attr_show(&ofd->ofd_osd->dd_kobj,
698                                 ofd->ofd_read_cache_max_filesize, buf);
699 }
700
701 static ssize_t readcache_max_filesize_store(struct kobject *kobj,
702                                             struct attribute *attr,
703                                             const char *buffer, size_t count)
704 {
705         struct obd_device *obd = container_of(kobj, struct obd_device,
706                                               obd_kset.kobj);
707         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
708
709         if (!max_file_warned) {
710                 max_file_warned = true;
711                 pr_info("ofd: 'obdfilter.*.readcache_max_filesize' is deprecated, use 'osd-*.readcache_max_filesize' instead\n");
712         }
713
714         if (!ofd->ofd_read_cache_max_filesize)
715                 return -EOPNOTSUPP;
716
717         return lustre_attr_store(&ofd->ofd_osd->dd_kobj,
718                                  ofd->ofd_read_cache_max_filesize,
719                                  buffer, count);
720 }
721 LUSTRE_RW_ATTR(readcache_max_filesize);
722
723 static ssize_t writethrough_cache_enable_show(struct kobject *kobj,
724                                               struct attribute *attr,
725                                               char *buf)
726 {
727         struct obd_device *obd = container_of(kobj, struct obd_device,
728                                               obd_kset.kobj);
729         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
730
731         if (!wr_cache_warned) {
732                 wr_cache_warned = true;
733                 pr_info("ofd: 'obdfilter.*.writethrough_cache_enabled' is deprecated, use 'osd-*.writethrough_cache_enabled' instead\n");
734         }
735
736         if (!ofd->ofd_write_cache_enable)
737                 return -EOPNOTSUPP;
738
739         return lustre_attr_show(&ofd->ofd_osd->dd_kobj,
740                                 ofd->ofd_write_cache_enable, buf);
741 }
742
743 static ssize_t writethrough_cache_enable_store(struct kobject *kobj,
744                                                struct attribute *attr,
745                                                const char *buffer, size_t count)
746 {
747         struct obd_device *obd = container_of(kobj, struct obd_device,
748                                               obd_kset.kobj);
749         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
750
751         if (!ofd->ofd_write_cache_enable)
752                 return -EOPNOTSUPP;
753
754         return lustre_attr_store(&ofd->ofd_osd->dd_kobj,
755                                  ofd->ofd_write_cache_enable,
756                                  buffer, count);
757 }
758 LUSTRE_RW_ATTR(writethrough_cache_enable);
759 #endif
760
761 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
762 LUSTRE_RW_ATTR(recovery_time_hard);
763 LUSTRE_RW_ATTR(recovery_time_soft);
764 LUSTRE_RW_ATTR(ir_factor);
765
766 LPROC_SEQ_FOPS_WR_ONLY(ofd, evict_client);
767 LPROC_SEQ_FOPS_RW_TYPE(ofd, checksum_dump);
768 LUSTRE_RW_ATTR(job_cleanup_interval);
769
770 LUSTRE_RO_ATTR(tot_dirty);
771 LUSTRE_RO_ATTR(tot_granted);
772 LUSTRE_RO_ATTR(tot_pending);
773 LUSTRE_RW_ATTR(grant_compat_disable);
774 LUSTRE_RO_ATTR(instance);
775
776 LUSTRE_RO_ATTR(num_exports);
777
778 struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
779         { .name =       "last_id",
780           .fops =       &ofd_last_id_fops               },
781         { .name =       "recovery_status",
782           .fops =       &ofd_recovery_status_fops       },
783         { .name =       "evict_client",
784           .fops =       &ofd_evict_client_fops          },
785         { .name =       "brw_size",
786           .fops =       &ofd_brw_size_fops              },
787         { .name =       "checksum_dump",
788           .fops =       &ofd_checksum_dump_fops         },
789         { .name =       "lfsck_layout",
790           .fops =       &ofd_lfsck_layout_fops          },
791         { .name =       "lfsck_verify_pfid",
792           .fops =       &ofd_lfsck_verify_pfid_fops     },
793         { .name =       "site_stats",
794           .fops =       &ofd_site_stats_fops            },
795         { NULL }
796 };
797
798 /**
799  * Initialize OFD statistics counters
800  *
801  * param[in] stats      statistics counters
802  */
803 void ofd_stats_counter_init(struct lprocfs_stats *stats)
804 {
805         LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
806
807         lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
808                              LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
809         lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
810                              LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
811         lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
812                              0, "getattr", "reqs");
813         lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
814                              0, "setattr", "reqs");
815         lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
816                              0, "punch", "reqs");
817         lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
818                              0, "sync", "reqs");
819         lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
820                              0, "destroy", "reqs");
821         lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
822                              0, "create", "reqs");
823         lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
824                              0, "statfs", "reqs");
825         lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
826                              0, "get_info", "reqs");
827         lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
828                              0, "set_info", "reqs");
829         lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
830                              0, "quotactl", "reqs");
831 }
832
833 LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);
834
835 static struct attribute *ofd_attrs[] = {
836         &lustre_attr_tot_dirty.attr,
837         &lustre_attr_tot_granted.attr,
838         &lustre_attr_tot_pending.attr,
839         &lustre_attr_grant_compat_disable.attr,
840         &lustre_attr_instance.attr,
841         &lustre_attr_recovery_time_hard.attr,
842         &lustre_attr_recovery_time_soft.attr,
843         &lustre_attr_ir_factor.attr,
844         &lustre_attr_num_exports.attr,
845         &lustre_attr_seqs_allocated.attr,
846         &lustre_attr_grant_precreate.attr,
847         &lustre_attr_precreate_batch.attr,
848         &lustre_attr_degraded.attr,
849         &lustre_attr_fstype.attr,
850         &lustre_attr_sync_journal.attr,
851         &lustre_attr_soft_sync_limit.attr,
852         &lustre_attr_lfsck_speed_limit.attr,
853         &lustre_attr_job_cleanup_interval.attr,
854         &lustre_attr_checksum_t10pi_enforce.attr,
855 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0)
856         &lustre_attr_read_cache_enable.attr,
857         &lustre_attr_readcache_max_filesize.attr,
858         &lustre_attr_writethrough_cache_enable.attr,
859 #endif
860         NULL,
861 };
862
863 /**
864  * Initialize all needed procfs entries for OFD device.
865  *
866  * \param[in] ofd       OFD device
867  *
868  * \retval              0 if successful
869  * \retval              negative value on error
870  */
871 int ofd_tunables_init(struct ofd_device *ofd)
872 {
873         struct obd_device *obd = ofd_obd(ofd);
874         struct proc_dir_entry *entry;
875         int rc = 0;
876
877         ENTRY;
878         /* lprocfs must be setup before the ofd so state can be safely added
879          * to /proc incrementally as the ofd is setup
880          */
881         obd->obd_ktype.default_attrs = ofd_attrs;
882         obd->obd_vars = lprocfs_ofd_obd_vars;
883         rc = lprocfs_obd_setup(obd, false);
884         if (rc) {
885                 CERROR("%s: lprocfs_obd_setup failed: %d.\n",
886                        obd->obd_name, rc);
887                 RETURN(rc);
888         }
889
890         rc = tgt_tunables_init(&ofd->ofd_lut);
891         if (rc) {
892                 CERROR("%s: tgt_tunables_init failed: rc = %d\n",
893                        obd->obd_name, rc);
894                 GOTO(obd_cleanup, rc);
895         }
896
897         rc = lprocfs_alloc_obd_stats(obd, LPROC_OFD_STATS_LAST);
898         if (rc) {
899                 CERROR("%s: lprocfs_alloc_obd_stats failed: %d.\n",
900                        obd->obd_name, rc);
901                 GOTO(tgt_cleanup, rc);
902         }
903
904         entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL);
905         if (IS_ERR(entry)) {
906                 rc = PTR_ERR(entry);
907                 CERROR("%s: error %d setting up lprocfs for %s\n",
908                        obd->obd_name, rc, "exports");
909                 GOTO(obd_free_stats, rc);
910         }
911         obd->obd_proc_exports_entry = entry;
912
913         entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
914                                    obd, &lprocfs_nid_stats_clear_fops);
915         if (IS_ERR(entry)) {
916                 rc = PTR_ERR(entry);
917                 CERROR("%s: add proc entry 'clear' failed: %d.\n",
918                        obd->obd_name, rc);
919                 GOTO(obd_free_stats, rc);
920         }
921
922         ofd_stats_counter_init(obd->obd_stats);
923
924         rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST,
925                                     ofd_stats_counter_init);
926         if (rc)
927                 GOTO(obd_free_stats, rc);
928
929         RETURN(0);
930
931 obd_free_stats:
932         lprocfs_free_obd_stats(obd);
933 tgt_cleanup:
934         tgt_tunables_fini(&ofd->ofd_lut);
935 obd_cleanup:
936         lprocfs_obd_cleanup(obd);
937
938         return rc;
939 }
940 #endif /* CONFIG_PROC_FS */