Whamcloud - gitweb
LU-8475 target: use slab allocation
[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, 2016, 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 int ofd_seqs_seq_show(struct seq_file *m, void *data)
63 {
64         struct obd_device *obd = m->private;
65         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
66
67         seq_printf(m, "%u\n", ofd->ofd_seq_count);
68         return 0;
69 }
70 LPROC_SEQ_FOPS_RO(ofd_seqs);
71
72 /**
73  * Show estimate of total amount of dirty data on clients.
74  *
75  * \param[in] m         seq_file handle
76  * \param[in] data      unused for single entry
77  *
78  * \retval              0 on success
79  * \retval              negative value on error
80  */
81 static int ofd_tot_dirty_seq_show(struct seq_file *m, void *data)
82 {
83         struct obd_device *obd = m->private;
84         struct tg_grants_data *tgd;
85
86         LASSERT(obd != NULL);
87         tgd = &obd->u.obt.obt_lut->lut_tgd;
88         seq_printf(m, "%llu\n", tgd->tgd_tot_dirty);
89         return 0;
90 }
91 LPROC_SEQ_FOPS_RO(ofd_tot_dirty);
92
93 /**
94  * Show total amount of space granted to clients.
95  *
96  * \param[in] m         seq_file handle
97  * \param[in] data      unused for single entry
98  *
99  * \retval              0 on success
100  * \retval              negative value on error
101  */
102 static int ofd_tot_granted_seq_show(struct seq_file *m, void *data)
103 {
104         struct obd_device *obd = m->private;
105         struct tg_grants_data *tgd;
106
107         LASSERT(obd != NULL);
108         tgd = &obd->u.obt.obt_lut->lut_tgd;
109         seq_printf(m, "%llu\n", tgd->tgd_tot_granted);
110         return 0;
111 }
112 LPROC_SEQ_FOPS_RO(ofd_tot_granted);
113
114 /**
115  * Show total amount of space used by IO in progress.
116  *
117  * \param[in] m         seq_file handle
118  * \param[in] data      unused for single entry
119  *
120  * \retval              0 on success
121  * \retval              negative value on error
122  */
123 static int ofd_tot_pending_seq_show(struct seq_file *m, void *data)
124 {
125         struct obd_device *obd = m->private;
126         struct tg_grants_data *tgd;
127
128         LASSERT(obd != NULL);
129         tgd = &obd->u.obt.obt_lut->lut_tgd;
130         seq_printf(m, "%llu\n", tgd->tgd_tot_pending);
131         return 0;
132 }
133 LPROC_SEQ_FOPS_RO(ofd_tot_pending);
134
135 /**
136  * Show total number of grants for precreate.
137  *
138  * \param[in] m         seq_file handle
139  * \param[in] data      unused for single entry
140  *
141  * \retval              0 on success
142  * \retval              negative value on error
143  */
144 static int ofd_grant_precreate_seq_show(struct seq_file *m, void *data)
145 {
146         struct obd_device *obd = m->private;
147
148         LASSERT(obd != NULL);
149         seq_printf(m, "%ld\n",
150                    obd->obd_self_export->exp_target_data.ted_grant);
151         return 0;
152 }
153 LPROC_SEQ_FOPS_RO(ofd_grant_precreate);
154
155 /**
156  * Show number of precreates allowed in a single transaction.
157  *
158  * \param[in] m         seq_file handle
159  * \param[in] data      unused for single entry
160  *
161  * \retval              0 on success
162  * \retval              negative value on error
163  */
164 static int ofd_precreate_batch_seq_show(struct seq_file *m, void *data)
165 {
166         struct obd_device *obd = m->private;
167         struct ofd_device *ofd;
168
169         LASSERT(obd != NULL);
170         ofd = ofd_dev(obd->obd_lu_dev);
171         seq_printf(m, "%d\n", ofd->ofd_precreate_batch);
172         return 0;
173 }
174
175 /**
176  * Change number of precreates allowed in a single transaction.
177  *
178  * \param[in] file      proc file
179  * \param[in] buffer    string which represents maximum number
180  * \param[in] count     \a buffer length
181  * \param[in] off       unused for single entry
182  *
183  * \retval              \a count on success
184  * \retval              negative number on error
185  */
186 static ssize_t
187 ofd_precreate_batch_seq_write(struct file *file, const char __user *buffer,
188                               size_t count, loff_t *off)
189 {
190         struct seq_file *m = file->private_data;
191         struct obd_device *obd = m->private;
192         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
193         __s64 val;
194         int rc;
195
196         rc = lprocfs_str_to_s64(buffer, count, &val);
197         if (rc)
198                 return rc;
199
200         if (val < 1 || val > INT_MAX)
201                 return -EINVAL;
202
203         spin_lock(&ofd->ofd_batch_lock);
204         ofd->ofd_precreate_batch = val;
205         spin_unlock(&ofd->ofd_batch_lock);
206         return count;
207 }
208 LPROC_SEQ_FOPS(ofd_precreate_batch);
209
210 /**
211  * Show the last used ID for each FID sequence used by OFD.
212  *
213  * \param[in] m         seq_file handle
214  * \param[in] data      unused for single entry
215  *
216  * \retval              0 on success
217  * \retval              negative value on error
218  */
219 static int ofd_last_id_seq_show(struct seq_file *m, void *data)
220 {
221         struct obd_device       *obd = m->private;
222         struct ofd_device       *ofd;
223         struct ofd_seq          *oseq = NULL;
224
225         if (obd == NULL)
226                 return 0;
227
228         ofd = ofd_dev(obd->obd_lu_dev);
229
230         read_lock(&ofd->ofd_seq_list_lock);
231         list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
232                 __u64 seq;
233
234                 seq = ostid_seq(&oseq->os_oi) == 0 ?
235                       fid_idif_seq(ostid_id(&oseq->os_oi),
236                                    ofd->ofd_lut.lut_lsd.lsd_osd_index) :
237                       ostid_seq(&oseq->os_oi);
238                 seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
239         }
240         read_unlock(&ofd->ofd_seq_list_lock);
241         return 0;
242 }
243 LPROC_SEQ_FOPS_RO(ofd_last_id);
244
245 /**
246  * Show maximum number of Filter Modification Data (FMD) maintained by OFD.
247  *
248  * \param[in] m         seq_file handle
249  * \param[in] data      unused for single entry
250  *
251  * \retval              0 on success
252  * \retval              negative value on error
253  */
254 static int ofd_fmd_max_num_seq_show(struct seq_file *m, void *data)
255 {
256         struct obd_device *obd = m->private;
257         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
258
259         seq_printf(m, "%u\n", ofd->ofd_fmd_max_num);
260         return 0;
261 }
262
263 /**
264  * Change number of FMDs maintained by OFD.
265  *
266  * This defines how large the list of FMDs can be.
267  *
268  * \param[in] file      proc file
269  * \param[in] buffer    string which represents maximum number
270  * \param[in] count     \a buffer length
271  * \param[in] off       unused for single entry
272  *
273  * \retval              \a count on success
274  * \retval              negative number on error
275  */
276 static ssize_t
277 ofd_fmd_max_num_seq_write(struct file *file, const char __user *buffer,
278                           size_t count, loff_t *off)
279 {
280         struct seq_file *m = file->private_data;
281         struct obd_device *obd = m->private;
282         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
283         __s64 val;
284         int rc;
285
286         rc = lprocfs_str_to_s64(buffer, count, &val);
287         if (rc)
288                 return rc;
289
290         if (val > 65536 || val < 1)
291                 return -EINVAL;
292
293         ofd->ofd_fmd_max_num = val;
294         return count;
295 }
296 LPROC_SEQ_FOPS(ofd_fmd_max_num);
297
298 /**
299  * Show the maximum age of FMD data in seconds.
300  *
301  * \param[in] m         seq_file handle
302  * \param[in] data      unused for single entry
303  *
304  * \retval              0 on success
305  * \retval              negative value on error
306  */
307 static int ofd_fmd_max_age_seq_show(struct seq_file *m, void *data)
308 {
309         struct obd_device *obd = m->private;
310         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
311
312         seq_printf(m, "%lld\n", ofd->ofd_fmd_max_age);
313         return 0;
314 }
315
316 /**
317  * Set the maximum age of FMD data in seconds.
318  *
319  * This defines how long FMD data stays in the FMD list.
320  *
321  * \param[in] file      proc file
322  * \param[in] buffer    string which represents maximum number
323  * \param[in] count     \a buffer length
324  * \param[in] off       unused for single entry
325  *
326  * \retval              \a count on success
327  * \retval              negative number on error
328  */
329 static ssize_t
330 ofd_fmd_max_age_seq_write(struct file *file, const char __user *buffer,
331                           size_t count, loff_t *off)
332 {
333         struct seq_file         *m = file->private_data;
334         struct obd_device       *obd = m->private;
335         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
336         __s64                    val;
337         int                      rc;
338
339         rc = lprocfs_str_to_s64(buffer, count, &val);
340         if (rc)
341                 return rc;
342
343         if (val > 65536 || val < 1)
344                 return -EINVAL;
345
346         ofd->ofd_fmd_max_age = val;
347         return count;
348 }
349 LPROC_SEQ_FOPS(ofd_fmd_max_age);
350
351 /**
352  * Show if the OFD is in degraded mode.
353  *
354  * Degraded means OFD has a failed drive or is undergoing RAID rebuild.
355  * The MDS will try to avoid using this OST for new object allocations
356  * to reduce the impact to global IO performance when clients writing to
357  * this OST are slowed down.  It also reduces the contention on the OST
358  * RAID device, allowing it to rebuild more quickly.
359  *
360  * \param[in] m         seq_file handle
361  * \param[in] data      unused for single entry
362  *
363  * \retval              0 on success
364  * \retval              negative value on error
365  */
366 static int ofd_degraded_seq_show(struct seq_file *m, void *data)
367 {
368         struct obd_device *obd = m->private;
369         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
370
371         seq_printf(m, "%u\n", ofd->ofd_raid_degraded);
372         return 0;
373 }
374
375 /**
376  * Set OFD to degraded mode.
377  *
378  * This is used to interface to userspace administrative tools for
379  * the underlying RAID storage, so that they can mark an OST
380  * as having degraded performance.
381  *
382  * \param[in] file      proc file
383  * \param[in] buffer    string which represents mode
384  *                      1: set degraded mode
385  *                      0: unset degraded mode
386  * \param[in] count     \a buffer length
387  * \param[in] off       unused for single entry
388  *
389  * \retval              \a count on success
390  * \retval              negative number on error
391  */
392 static ssize_t
393 ofd_degraded_seq_write(struct file *file, const char __user *buffer,
394                        size_t count, loff_t *off)
395 {
396         struct seq_file *m = file->private_data;
397         struct obd_device *obd = m->private;
398         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
399         int rc;
400         __s64 val;
401
402         rc = lprocfs_str_to_s64(buffer, count, &val);
403         if (rc)
404                 return rc;
405
406         spin_lock(&ofd->ofd_flags_lock);
407         ofd->ofd_raid_degraded = !!val;
408         spin_unlock(&ofd->ofd_flags_lock);
409         return count;
410 }
411 LPROC_SEQ_FOPS(ofd_degraded);
412
413 /**
414  * Show OFD filesystem type.
415  *
416  * \param[in] m         seq_file handle
417  * \param[in] data      unused for single entry
418  *
419  * \retval              0 on success
420  * \retval              negative value on error
421  */
422 static int ofd_fstype_seq_show(struct seq_file *m, void *data)
423 {
424         struct obd_device *obd = m->private;
425         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
426         struct lu_device  *d;
427
428         LASSERT(ofd->ofd_osd);
429         d = &ofd->ofd_osd->dd_lu_dev;
430         LASSERT(d->ld_type);
431         seq_printf(m, "%s\n", d->ld_type->ldt_name);
432         return 0;
433 }
434 LPROC_SEQ_FOPS_RO(ofd_fstype);
435
436 /**
437  * Show journal handling mode: synchronous or asynchronous.
438  *
439  * When running in asynchronous mode the journal transactions are not
440  * committed to disk before the RPC is replied back to the client.
441  * This will typically improve client performance when only a small number
442  * of clients are writing, since the client(s) can have more write RPCs
443  * in flight. However, it also means that the client has to handle recovery
444  * on bulk RPCs, and will have to keep more dirty pages in cache before they
445  * are committed on the OST.
446  *
447  * \param[in] m         seq_file handle
448  * \param[in] data      unused for single entry
449  *
450  * \retval              0 on success
451  * \retval              negative value on error
452  */
453 static int ofd_syncjournal_seq_show(struct seq_file *m, void *data)
454 {
455         struct obd_device       *obd = m->private;
456         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
457
458         seq_printf(m, "%u\n", ofd->ofd_syncjournal);
459         return 0;
460 }
461
462 /**
463  * Set journal mode to synchronous or asynchronous.
464  *
465  * \param[in] file      proc file
466  * \param[in] buffer    string which represents mode
467  *                      1: synchronous mode
468  *                      0: asynchronous mode
469  * \param[in] count     \a buffer length
470  * \param[in] off       unused for single entry
471  *
472  * \retval              \a count on success
473  * \retval              negative number on error
474  */
475 static ssize_t
476 ofd_syncjournal_seq_write(struct file *file, const char __user *buffer,
477                           size_t count, loff_t *off)
478 {
479         struct seq_file *m = file->private_data;
480         struct obd_device *obd = m->private;
481         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
482         __s64 val;
483         int rc;
484
485         rc = lprocfs_str_to_s64(buffer, count, &val);
486         if (rc)
487                 return rc;
488
489         if (val < 0)
490                 return -EINVAL;
491
492         spin_lock(&ofd->ofd_flags_lock);
493         ofd->ofd_syncjournal = !!val;
494         ofd_slc_set(ofd);
495         spin_unlock(&ofd->ofd_flags_lock);
496
497         return count;
498 }
499 LPROC_SEQ_FOPS(ofd_syncjournal);
500
501 /* This must be longer than the longest string below */
502 #define SYNC_STATES_MAXLEN 16
503
504 static int ofd_brw_size_seq_show(struct seq_file *m, void *data)
505 {
506         struct obd_device       *obd = m->private;
507         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
508
509         seq_printf(m, "%u\n", ofd->ofd_brw_size / ONE_MB_BRW_SIZE);
510         return 0;
511 }
512
513 static ssize_t
514 ofd_brw_size_seq_write(struct file *file, const char __user *buffer,
515                        size_t count, loff_t *off)
516 {
517         struct seq_file *m = file->private_data;
518         struct obd_device *obd = m->private;
519         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
520         __s64 val;
521         int rc;
522
523         rc = lprocfs_str_with_units_to_s64(buffer, count, &val, 'M');
524         if (rc)
525                 return rc;
526
527         if (val <= 0)
528                 return -EINVAL;
529
530         if (val > DT_MAX_BRW_SIZE ||
531             val < (1 << ofd->ofd_lut.lut_tgd.tgd_blockbits))
532                 return -ERANGE;
533
534         spin_lock(&ofd->ofd_flags_lock);
535         ofd->ofd_brw_size = val;
536         spin_unlock(&ofd->ofd_flags_lock);
537
538         return count;
539 }
540 LPROC_SEQ_FOPS(ofd_brw_size);
541
542 static char *sync_on_cancel_states[] = {"never",
543                                         "blocking",
544                                         "always" };
545
546 /**
547  * Show OFD policy for handling dirty data under a lock being cancelled.
548  *
549  * \param[in] m         seq_file handle
550  * \param[in] data      unused for single entry
551  *
552  * \retval              0 on success
553  * \retval              negative value on error
554  */
555 static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
556 {
557         struct obd_device       *obd = m->private;
558         struct lu_target        *tgt = obd->u.obt.obt_lut;
559
560         seq_printf(m, "%s\n",
561                    sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
562         return 0;
563 }
564
565 /**
566  * Change OFD policy for handling dirty data under a lock being cancelled.
567  *
568  * This variable defines what action OFD takes upon lock cancel
569  * There are three possible modes:
570  * 1) never - never do sync upon lock cancel. This can lead to data
571  *    inconsistencies if both the OST and client crash while writing a file
572  *    that is also concurrently being read by another client. In these cases,
573  *    this may allow the file data to "rewind" to an earlier state.
574  * 2) blocking - do sync only if there is blocking lock, e.g. if another
575  *    client is trying to access this same object
576  * 3) always - do sync always
577  *
578  * \param[in] file      proc file
579  * \param[in] buffer    string which represents policy
580  * \param[in] count     \a buffer length
581  * \param[in] off       unused for single entry
582  *
583  * \retval              \a count on success
584  * \retval              negative number on error
585  */
586 static ssize_t
587 ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
588                                size_t count, loff_t *off)
589 {
590         struct seq_file *m = file->private_data;
591         struct obd_device *obd = m->private;
592         struct lu_target *tgt = obd->u.obt.obt_lut;
593         char kernbuf[SYNC_STATES_MAXLEN];
594         __s64 val = -1;
595         int i;
596
597         if (count == 0 || count >= sizeof(kernbuf))
598                 return -EINVAL;
599
600         if (copy_from_user(kernbuf, buffer, count))
601                 return -EFAULT;
602         kernbuf[count] = 0;
603
604         if (kernbuf[count - 1] == '\n')
605                 kernbuf[count - 1] = 0;
606
607         for (i = 0 ; i < NUM_SYNC_ON_CANCEL_STATES; i++) {
608                 if (strcmp(kernbuf, sync_on_cancel_states[i]) == 0) {
609                         val = i;
610                         break;
611                 }
612         }
613
614         /* Legacy numeric codes */
615         if (val == -1) {
616                 int rc = lprocfs_str_to_s64(buffer, count, &val);
617                 if (rc)
618                         return rc;
619         }
620
621         if (val < 0 || val > 2)
622                 return -EINVAL;
623
624         spin_lock(&tgt->lut_flags_lock);
625         tgt->lut_sync_lock_cancel = val;
626         spin_unlock(&tgt->lut_flags_lock);
627         return count;
628 }
629 LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
630
631 /**
632  * Show if grants compatibility mode is disabled.
633  *
634  * When tgd_grant_compat_disable is set, we don't grant any space to clients
635  * not supporting OBD_CONNECT_GRANT_PARAM. Otherwise, space granted to such
636  * a client is inflated since it consumes PAGE_SIZE of grant space per
637  * block, (i.e. typically 4kB units), but underlaying file system might have
638  * block size bigger than page size, e.g. ZFS. See LU-2049 for details.
639  *
640  * \param[in] m         seq_file handle
641  * \param[in] data      unused for single entry
642  *
643  * \retval              0 on success
644  * \retval              negative value on error
645  */
646 static int ofd_grant_compat_disable_seq_show(struct seq_file *m, void *data)
647 {
648         struct obd_device *obd = m->private;
649         struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
650
651         seq_printf(m, "%u\n", tgd->tgd_grant_compat_disable);
652         return 0;
653 }
654
655 /**
656  * Change grant compatibility mode.
657  *
658  * Setting tgd_grant_compat_disable prohibit any space granting to clients
659  * not supporting OBD_CONNECT_GRANT_PARAM. See details above.
660  *
661  * \param[in] file      proc file
662  * \param[in] buffer    string which represents mode
663  *                      1: disable compatibility mode
664  *                      0: enable compatibility mode
665  * \param[in] count     \a buffer length
666  * \param[in] off       unused for single entry
667  *
668  * \retval              \a count on success
669  * \retval              negative number on error
670  */
671 static ssize_t
672 ofd_grant_compat_disable_seq_write(struct file *file,
673                                    const char __user *buffer,
674                                    size_t count, loff_t *off)
675 {
676         struct seq_file *m = file->private_data;
677         struct obd_device *obd = m->private;
678         struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
679         __s64 val;
680         int rc;
681
682         rc = lprocfs_str_to_s64(buffer, count, &val);
683         if (rc)
684                 return rc;
685
686         if (val < 0)
687                 return -EINVAL;
688
689         tgd->tgd_grant_compat_disable = !!val;
690
691         return count;
692 }
693 LPROC_SEQ_FOPS(ofd_grant_compat_disable);
694
695 /**
696  * Show the limit of soft sync RPCs.
697  *
698  * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
699  * are allowed before sync update will be triggered.
700  *
701  * \param[in] m         seq_file handle
702  * \param[in] data      unused for single entry
703  *
704  * \retval              0 on success
705  * \retval              negative value on error
706  */
707 static int ofd_soft_sync_limit_seq_show(struct seq_file *m, void *data)
708 {
709         struct obd_device       *obd = m->private;
710         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
711
712         return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
713 }
714
715 /**
716  * Change the limit of soft sync RPCs.
717  *
718  * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
719  * allowed before sync update will be done.
720  *
721  * This limit is global across all exports.
722  *
723  * \param[in] file      proc file
724  * \param[in] buffer    string which represents limit
725  * \param[in] count     \a buffer length
726  * \param[in] off       unused for single entry
727  *
728  * \retval              \a count on success
729  * \retval              negative number on error
730  */
731 static ssize_t
732 ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
733                               size_t count, loff_t *off)
734 {
735         struct seq_file   *m = file->private_data;
736         struct obd_device *obd = m->private;
737         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
738
739         return lprocfs_uint_seq_write(file, buffer, count,
740                                       (loff_t *) &ofd->ofd_soft_sync_limit);
741 }
742 LPROC_SEQ_FOPS(ofd_soft_sync_limit);
743
744 /**
745  * Show the LFSCK speed limit.
746  *
747  * The maximum number of items scanned per second.
748  *
749  * \param[in] m         seq_file handle
750  * \param[in] data      unused for single entry
751  *
752  * \retval              0 on success
753  * \retval              negative value on error
754  */
755 static int ofd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
756 {
757         struct obd_device       *obd = m->private;
758         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
759
760         return lfsck_get_speed(m, ofd->ofd_osd);
761 }
762
763 /**
764  * Change the LFSCK speed limit.
765  *
766  * Limit number of items that may be scanned per second.
767  *
768  * \param[in] file      proc file
769  * \param[in] buffer    string which represents limit
770  * \param[in] count     \a buffer length
771  * \param[in] off       unused for single entry
772  *
773  * \retval              \a count on success
774  * \retval              negative number on error
775  */
776 static ssize_t
777 ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
778                                 size_t count, loff_t *off)
779 {
780         struct seq_file *m = file->private_data;
781         struct obd_device *obd = m->private;
782         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
783         __s64 val;
784         int rc;
785
786         rc = lprocfs_str_to_s64(buffer, count, &val);
787         if (rc != 0)
788                 return rc;
789
790         if (val < 0)
791                 return -ERANGE;
792
793         rc = lfsck_set_speed(ofd->ofd_osd, val);
794
795         return rc != 0 ? rc : count;
796 }
797 LPROC_SEQ_FOPS(ofd_lfsck_speed_limit);
798
799 /**
800  * Show LFSCK layout verification stats from the most recent LFSCK run.
801  *
802  * \param[in] m         seq_file handle
803  * \param[in] data      unused for single entry
804  *
805  * \retval              0 on success
806  * \retval              negative value on error
807  */
808 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
809 {
810         struct obd_device *obd = m->private;
811         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
812
813         return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
814 }
815 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
816
817 /**
818  * Show if LFSCK performed parent FID verification.
819  *
820  * \param[in] m         seq_file handle
821  * \param[in] data      unused for single entry
822  *
823  * \retval              0 on success
824  * \retval              negative value on error
825  */
826 static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
827 {
828         struct obd_device *obd = m->private;
829         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
830
831         seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
832                    ofd->ofd_lfsck_verify_pfid ? "on" : "off",
833                    ofd->ofd_inconsistency_self_detected,
834                    ofd->ofd_inconsistency_self_repaired);
835         return 0;
836 }
837
838 /**
839  * Set the LFSCK behavior to verify parent FID correctness.
840  *
841  * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
842  * verification during read/write operations.
843  *
844  * \param[in] file      proc file
845  * \param[in] buffer    string which represents behavior
846  *                      1: verify parent FID
847  *                      0: don't verify parent FID
848  * \param[in] count     \a buffer length
849  * \param[in] off       unused for single entry
850  *
851  * \retval              \a count on success
852  * \retval              negative number on error
853  */
854 static ssize_t
855 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
856                                 size_t count, loff_t *off)
857 {
858         struct seq_file *m = file->private_data;
859         struct obd_device *obd = m->private;
860         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
861         __s64 val;
862         int rc;
863
864         rc = lprocfs_str_to_s64(buffer, count, &val);
865         if (rc != 0)
866                 return rc;
867
868         ofd->ofd_lfsck_verify_pfid = !!val;
869         if (!ofd->ofd_lfsck_verify_pfid) {
870                 ofd->ofd_inconsistency_self_detected = 0;
871                 ofd->ofd_inconsistency_self_repaired = 0;
872         }
873
874         return count;
875 }
876 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
877
878 static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
879 {
880         struct obd_device *obd = m->private;
881
882         return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
883 }
884 LPROC_SEQ_FOPS_RO(ofd_site_stats);
885
886 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
887 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_soft);
888 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_hard);
889 LPROC_SEQ_FOPS_WR_ONLY(ofd, evict_client);
890 LPROC_SEQ_FOPS_RO_TYPE(ofd, num_exports);
891 LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
892 LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
893 LPROC_SEQ_FOPS_RW_TYPE(ofd, checksum_dump);
894 LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
895
896 struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
897         { .name =       "seqs_allocated",
898           .fops =       &ofd_seqs_fops                  },
899         { .name =       "fstype",
900           .fops =       &ofd_fstype_fops                },
901         { .name =       "last_id",
902           .fops =       &ofd_last_id_fops               },
903         { .name =       "tot_dirty",
904           .fops =       &ofd_tot_dirty_fops             },
905         { .name =       "tot_pending",
906           .fops =       &ofd_tot_pending_fops           },
907         { .name =       "tot_granted",
908           .fops =       &ofd_tot_granted_fops           },
909         { .name =       "grant_precreate",
910           .fops =       &ofd_grant_precreate_fops       },
911         { .name =       "precreate_batch",
912           .fops =       &ofd_precreate_batch_fops       },
913         { .name =       "recovery_status",
914           .fops =       &ofd_recovery_status_fops       },
915         { .name =       "recovery_time_soft",
916           .fops =       &ofd_recovery_time_soft_fops    },
917         { .name =       "recovery_time_hard",
918           .fops =       &ofd_recovery_time_hard_fops    },
919         { .name =       "evict_client",
920           .fops =       &ofd_evict_client_fops          },
921         { .name =       "num_exports",
922           .fops =       &ofd_num_exports_fops           },
923         { .name =       "degraded",
924           .fops =       &ofd_degraded_fops              },
925         { .name =       "sync_journal",
926           .fops =       &ofd_syncjournal_fops           },
927         { .name =       "brw_size",
928           .fops =       &ofd_brw_size_fops              },
929         { .name =       "sync_on_lock_cancel",
930           .fops =       &ofd_sync_lock_cancel_fops      },
931         { .name =       "instance",
932           .fops =       &ofd_target_instance_fops       },
933         { .name =       "ir_factor",
934           .fops =       &ofd_ir_factor_fops             },
935         { .name =       "checksum_dump",
936           .fops =       &ofd_checksum_dump_fops         },
937         { .name =       "grant_compat_disable",
938           .fops =       &ofd_grant_compat_disable_fops  },
939         { .name =       "client_cache_count",
940           .fops =       &ofd_fmd_max_num_fops           },
941         { .name =       "client_cache_seconds",
942           .fops =       &ofd_fmd_max_age_fops           },
943         { .name =       "job_cleanup_interval",
944           .fops =       &ofd_job_interval_fops          },
945         { .name =       "soft_sync_limit",
946           .fops =       &ofd_soft_sync_limit_fops       },
947         { .name =       "lfsck_speed_limit",
948           .fops =       &ofd_lfsck_speed_limit_fops     },
949         { .name =       "lfsck_layout",
950           .fops =       &ofd_lfsck_layout_fops          },
951         { .name =       "lfsck_verify_pfid",
952           .fops =       &ofd_lfsck_verify_pfid_fops     },
953         { .name =       "site_stats",
954           .fops =       &ofd_site_stats_fops            },
955         { NULL }
956 };
957
958 /**
959  * Initialize OFD statistics counters
960  *
961  * param[in] stats      statistics counters
962  */
963 void ofd_stats_counter_init(struct lprocfs_stats *stats)
964 {
965         LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
966
967         lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
968                              LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
969         lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
970                              LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
971         lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
972                              0, "getattr", "reqs");
973         lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
974                              0, "setattr", "reqs");
975         lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
976                              0, "punch", "reqs");
977         lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
978                              0, "sync", "reqs");
979         lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
980                              0, "destroy", "reqs");
981         lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
982                              0, "create", "reqs");
983         lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
984                              0, "statfs", "reqs");
985         lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
986                              0, "get_info", "reqs");
987         lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
988                              0, "set_info", "reqs");
989         lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
990                              0, "quotactl", "reqs");
991 }
992
993 #endif /* CONFIG_PROC_FS */