Whamcloud - gitweb
78366e3fd9edaa959dc76bb9487226040dc85390
[fs/lustre-release.git] / lustre / mdd / mdd_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) 2007, 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/mdd/mdd_lproc.c
33  *
34  * Lustre Metadata Server (mdd) routines
35  *
36  * Author: Wang Di <wangdi@clusterfs.com>
37  */
38
39 #define DEBUG_SUBSYSTEM S_MDS
40
41 #include <obd.h>
42 #include <obd_class.h>
43 #include <obd_support.h>
44 #include <lprocfs_status.h>
45 #include <libcfs/libcfs_string.h>
46 #include "mdd_internal.h"
47
48 static ssize_t
49 mdd_atime_diff_seq_write(struct file *file, const char __user *buffer,
50                          size_t count, loff_t *off)
51 {
52         struct seq_file *m = file->private_data;
53         struct mdd_device *mdd = m->private;
54         time64_t diff = 0;
55         int rc;
56
57         rc = kstrtoll_from_user(buffer, count, 0, &diff);
58         if (rc)
59                 return rc;
60
61         mdd->mdd_atime_diff = diff;
62         return count;
63 }
64
65 static int mdd_atime_diff_seq_show(struct seq_file *m, void *data)
66 {
67         struct mdd_device *mdd = m->private;
68
69         seq_printf(m, "%lld\n", mdd->mdd_atime_diff);
70         return 0;
71 }
72 LPROC_SEQ_FOPS(mdd_atime_diff);
73
74 /**** changelogs ****/
75 static int mdd_changelog_mask_seq_show(struct seq_file *m, void *data)
76 {
77         struct mdd_device *mdd = m->private;
78         int i = 0;
79
80         while (i < CL_LAST) {
81                 if (mdd->mdd_cl.mc_mask & (1 << i))
82                         seq_printf(m, "%s ", changelog_type2str(i));
83                 i++;
84         }
85         seq_putc(m, '\n');
86         return 0;
87 }
88
89 static ssize_t
90 mdd_changelog_mask_seq_write(struct file *file, const char __user *buffer,
91                              size_t count, loff_t *off)
92 {
93         struct seq_file *m = file->private_data;
94         struct mdd_device *mdd = m->private;
95         char *kernbuf;
96         int rc;
97         ENTRY;
98
99         if (count >= PAGE_SIZE)
100                 RETURN(-EINVAL);
101         OBD_ALLOC(kernbuf, PAGE_SIZE);
102         if (kernbuf == NULL)
103                 RETURN(-ENOMEM);
104         if (copy_from_user(kernbuf, buffer, count))
105                 GOTO(out, rc = -EFAULT);
106         kernbuf[count] = 0;
107
108         rc = cfs_str2mask(kernbuf, changelog_type2str, &mdd->mdd_cl.mc_mask,
109                           CHANGELOG_MINMASK, CHANGELOG_ALLMASK);
110         if (rc == 0)
111                 rc = count;
112 out:
113         OBD_FREE(kernbuf, PAGE_SIZE);
114         return rc;
115 }
116 LPROC_SEQ_FOPS(mdd_changelog_mask);
117
118 static int lprocfs_changelog_users_cb(const struct lu_env *env,
119                                       struct llog_handle *llh,
120                                       struct llog_rec_hdr *hdr, void *data)
121 {
122         struct llog_changelog_user_rec *rec;
123         struct seq_file *m = data;
124
125         LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
126
127         rec = (struct llog_changelog_user_rec *)hdr;
128
129         seq_printf(m, CHANGELOG_USER_PREFIX"%-3d %llu (%u)\n",
130                    rec->cur_id, rec->cur_endrec, (__u32)get_seconds() -
131                                                  rec->cur_time);
132         return 0;
133 }
134
135 static int mdd_changelog_users_seq_show(struct seq_file *m, void *data)
136 {
137         struct lu_env            env;
138         struct mdd_device       *mdd = m->private;
139         struct llog_ctxt        *ctxt;
140         __u64                    cur;
141         int                      rc;
142
143         ctxt = llog_get_context(mdd2obd_dev(mdd),
144                                 LLOG_CHANGELOG_USER_ORIG_CTXT);
145         if (ctxt == NULL)
146                 return -ENXIO;
147         LASSERT(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT);
148
149         rc = lu_env_init(&env, LCT_LOCAL);
150         if (rc) {
151                 llog_ctxt_put(ctxt);
152                 return rc;
153         }
154
155         spin_lock(&mdd->mdd_cl.mc_lock);
156         cur = mdd->mdd_cl.mc_index;
157         spin_unlock(&mdd->mdd_cl.mc_lock);
158
159         seq_printf(m, "current index: %llu\n", cur);
160         seq_printf(m, "%-5s %s %s\n", "ID", "index", "(idle seconds)");
161
162         llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb,
163                          m, 0, 0);
164
165         lu_env_fini(&env);
166         llog_ctxt_put(ctxt);
167         return 0;
168 }
169 LPROC_SEQ_FOPS_RO(mdd_changelog_users);
170
171 static int mdd_changelog_size_ctxt(const struct lu_env *env,
172                                    struct mdd_device *mdd,
173                                    int index, __u64 *val)
174 {
175         struct llog_ctxt        *ctxt;
176
177         ctxt = llog_get_context(mdd2obd_dev(mdd),
178                                 index);
179         if (ctxt == NULL)
180                 return -ENXIO;
181
182         if (!(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT)) {
183                 CERROR("%s: ChangeLog has wrong flags: rc = %d\n",
184                        ctxt->loc_obd->obd_name, -EINVAL);
185                 llog_ctxt_put(ctxt);
186                 return -EINVAL;
187         }
188
189         *val += llog_cat_size(env, ctxt->loc_handle);
190
191         llog_ctxt_put(ctxt);
192
193         return 0;
194 }
195
196 static int mdd_changelog_size_seq_show(struct seq_file *m, void *data)
197 {
198         struct lu_env            env;
199         struct mdd_device       *mdd = m->private;
200         __u64                    tmp = 0;
201         int                      rc;
202
203         rc = lu_env_init(&env, LCT_LOCAL);
204         if (rc)
205                 return rc;
206
207         rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_ORIG_CTXT, &tmp);
208         if (rc) {
209                 lu_env_fini(&env);
210                 return rc;
211         }
212
213         rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT,
214                                      &tmp);
215
216         seq_printf(m, "%llu\n", tmp);
217         lu_env_fini(&env);
218         return rc;
219 }
220 LPROC_SEQ_FOPS_RO(mdd_changelog_size);
221
222 static int mdd_changelog_gc_seq_show(struct seq_file *m, void *data)
223 {
224         struct mdd_device *mdd = m->private;
225
226         LASSERT(mdd != NULL);
227         seq_printf(m, "%u\n", mdd->mdd_changelog_gc);
228         return 0;
229 }
230
231 static ssize_t
232 mdd_changelog_gc_seq_write(struct file *file, const char __user *buffer,
233                            size_t count, loff_t *off)
234 {
235         struct seq_file *m = file->private_data;
236         struct mdd_device *mdd = m->private;
237         bool val;
238         int rc;
239
240         LASSERT(mdd != NULL);
241         rc = kstrtobool_from_user(buffer, count, &val);
242         if (rc)
243                 return rc;
244
245         mdd->mdd_changelog_gc = val;
246
247         return count;
248 }
249 LPROC_SEQ_FOPS(mdd_changelog_gc);
250
251 static int mdd_changelog_max_idle_time_seq_show(struct seq_file *m, void *data)
252 {
253         struct mdd_device *mdd = m->private;
254
255         LASSERT(mdd != NULL);
256         seq_printf(m, "%lld\n", mdd->mdd_changelog_max_idle_time);
257         return 0;
258 }
259
260 static ssize_t
261 mdd_changelog_max_idle_time_seq_write(struct file *file,
262                                       const char __user *buffer, size_t count,
263                                       loff_t *off)
264 {
265         struct seq_file *m = file->private_data;
266         struct mdd_device *mdd = m->private;
267         time64_t val;
268         int rc;
269
270         LASSERT(mdd != NULL);
271
272         rc = kstrtoll_from_user(buffer, count, 0, &val);
273         if (rc)
274                 return rc;
275
276         /* as it sounds reasonable, do not allow a user to be idle since
277          * more than about 68 years, this will allow to use 32bits
278          * timestamps for comparison
279          */
280         if (val < 1 || val > INT_MAX)
281                 return -ERANGE;
282
283         mdd->mdd_changelog_max_idle_time = val;
284
285         return count;
286 }
287 LPROC_SEQ_FOPS(mdd_changelog_max_idle_time);
288
289 static int mdd_changelog_max_idle_indexes_seq_show(struct seq_file *m,
290                                                    void *data)
291 {
292         struct mdd_device *mdd = m->private;
293
294         LASSERT(mdd != NULL);
295         seq_printf(m, "%lu\n", mdd->mdd_changelog_max_idle_indexes);
296         return 0;
297 }
298
299 static ssize_t
300 mdd_changelog_max_idle_indexes_seq_write(struct file *file,
301                                          const char __user *buffer,
302                                          size_t count, loff_t *off)
303 {
304         struct seq_file *m = file->private_data;
305         struct mdd_device *mdd = m->private;
306         unsigned long val;
307         int rc;
308
309         LASSERT(mdd != NULL);
310         rc = kstrtoul_from_user(buffer, count, 0, &val);
311         if (rc)
312                 return rc;
313
314         /* XXX may need to limit/check with reasonable elapsed/idle indexes */
315         /* XXX may better allow to specify a % of full ChangeLogs */
316
317         mdd->mdd_changelog_max_idle_indexes = val;
318
319         return count;
320 }
321 LPROC_SEQ_FOPS(mdd_changelog_max_idle_indexes);
322
323 static int mdd_changelog_min_gc_interval_seq_show(struct seq_file *m,
324                                                   void *data)
325 {
326         struct mdd_device *mdd = m->private;
327
328         LASSERT(mdd != NULL);
329         seq_printf(m, "%lld\n", mdd->mdd_changelog_min_gc_interval);
330         return 0;
331 }
332
333 static ssize_t
334 mdd_changelog_min_gc_interval_seq_write(struct file *file,
335                                         const char __user *buffer,
336                                         size_t count, loff_t *off)
337 {
338         struct seq_file *m = file->private_data;
339         struct mdd_device *mdd = m->private;
340         time64_t val;
341         int rc;
342
343         LASSERT(mdd != NULL);
344         rc = kstrtoll_from_user(buffer, count, 0, &val);
345         if (rc)
346                 return rc;
347
348         /* XXX may need to limit with reasonable elapsed/interval times */
349         if (val < 1)
350                 return -ERANGE;
351
352         mdd->mdd_changelog_min_gc_interval = val;
353
354         return count;
355 }
356 LPROC_SEQ_FOPS(mdd_changelog_min_gc_interval);
357
358 static int mdd_changelog_min_free_cat_entries_seq_show(struct seq_file *m,
359                                                        void *data)
360 {
361         struct mdd_device *mdd = m->private;
362
363         LASSERT(mdd != NULL);
364         seq_printf(m, "%u\n", mdd->mdd_changelog_min_free_cat_entries);
365         return 0;
366 }
367
368 static ssize_t
369 mdd_changelog_min_free_cat_entries_seq_write(struct file *file,
370                                              const char __user *buffer,
371                                              size_t count, loff_t *off)
372 {
373         struct seq_file *m = file->private_data;
374         struct mdd_device *mdd = m->private;
375         unsigned int val;
376         int rc;
377
378         LASSERT(mdd != NULL);
379         rc = kstrtouint_from_user(buffer, count, 0, &val);
380         if (rc)
381                 return rc;
382
383         /* XXX may need to limit with more reasonable number of free entries */
384         if (val < 1)
385                 return -ERANGE;
386
387         mdd->mdd_changelog_min_free_cat_entries = val;
388
389         return count;
390 }
391 LPROC_SEQ_FOPS(mdd_changelog_min_free_cat_entries);
392
393 static int mdd_changelog_deniednext_seq_show(struct seq_file *m, void *data)
394 {
395         struct mdd_device *mdd = m->private;
396
397         seq_printf(m, "%u\n", mdd->mdd_cl.mc_deniednext);
398         return 0;
399 }
400
401 static ssize_t
402 mdd_changelog_deniednext_seq_write(struct file *file, const char __user *buffer,
403                                    size_t count, loff_t *off)
404 {
405         struct seq_file *m = file->private_data;
406         struct mdd_device *mdd = m->private;
407         char kernbuf[11];
408         unsigned int time = 0;
409         int rc;
410
411         if (count > (sizeof(kernbuf) - 1))
412                 return -EINVAL;
413
414         if (copy_from_user(kernbuf, buffer, count))
415                 return -EFAULT;
416
417         kernbuf[count] = '\0';
418
419         rc = kstrtoul(kernbuf, 0, (unsigned long int *)&time);
420         if (rc)
421                 return rc;
422
423         mdd->mdd_cl.mc_deniednext = time;
424         return count;
425 }
426 LPROC_SEQ_FOPS(mdd_changelog_deniednext);
427
428 static int mdd_sync_perm_seq_show(struct seq_file *m, void *data)
429 {
430         struct mdd_device *mdd = m->private;
431
432         LASSERT(mdd != NULL);
433         seq_printf(m, "%d\n", mdd->mdd_sync_permission);
434         return 0;
435 }
436
437 static ssize_t
438 mdd_sync_perm_seq_write(struct file *file, const char __user *buffer,
439                         size_t count, loff_t *off)
440 {
441         struct seq_file *m = file->private_data;
442         struct mdd_device *mdd = m->private;
443         bool val;
444         int rc;
445
446         LASSERT(mdd != NULL);
447         rc = kstrtobool_from_user(buffer, count, &val);
448         if (rc)
449                 return rc;
450
451         mdd->mdd_sync_permission = val;
452
453         return count;
454 }
455 LPROC_SEQ_FOPS(mdd_sync_perm);
456
457 static int mdd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
458 {
459         struct mdd_device *mdd = m->private;
460
461         LASSERT(mdd != NULL);
462         return lfsck_get_speed(m, NULL, mdd->mdd_bottom);
463 }
464
465 static ssize_t
466 mdd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
467                                 size_t count, loff_t *off)
468 {
469         struct seq_file *m = file->private_data;
470         struct mdd_device *mdd = m->private;
471         unsigned int val;
472         int rc;
473
474         LASSERT(mdd != NULL);
475         rc = kstrtouint_from_user(buffer, count, 0, &val);
476         if (rc != 0)
477                 return rc;
478
479         rc = lfsck_set_speed(mdd->mdd_bottom, val);
480         return rc != 0 ? rc : count;
481 }
482 LPROC_SEQ_FOPS(mdd_lfsck_speed_limit);
483
484 static int mdd_lfsck_async_windows_seq_show(struct seq_file *m, void *data)
485 {
486         struct mdd_device *mdd = m->private;
487
488         LASSERT(mdd != NULL);
489         return lfsck_get_windows(m, mdd->mdd_bottom);
490 }
491
492 static ssize_t
493 mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer,
494                                   size_t count, loff_t *off)
495 {
496         struct seq_file *m = file->private_data;
497         struct mdd_device *mdd = m->private;
498         unsigned int val;
499         int rc;
500
501         LASSERT(mdd != NULL);
502         rc = kstrtouint_from_user(buffer, count, 0, &val);
503         if (rc)
504                 return rc;
505
506         rc = lfsck_set_windows(mdd->mdd_bottom, val);
507
508         return rc != 0 ? rc : count;
509 }
510 LPROC_SEQ_FOPS(mdd_lfsck_async_windows);
511
512 static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
513 {
514         struct mdd_device *mdd = m->private;
515
516         LASSERT(mdd != NULL);
517
518         return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE);
519 }
520 LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace);
521
522 static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
523 {
524         struct mdd_device *mdd = m->private;
525
526         LASSERT(mdd != NULL);
527
528         return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT);
529 }
530 LPROC_SEQ_FOPS_RO(mdd_lfsck_layout);
531
532 static struct lprocfs_vars lprocfs_mdd_obd_vars[] = {
533         { .name =       "atime_diff",
534           .fops =       &mdd_atime_diff_fops            },
535         { .name =       "changelog_mask",
536           .fops =       &mdd_changelog_mask_fops        },
537         { .name =       "changelog_users",
538           .fops =       &mdd_changelog_users_fops       },
539         { .name =       "changelog_size",
540           .fops =       &mdd_changelog_size_fops        },
541         { .name =       "changelog_gc",
542           .fops =       &mdd_changelog_gc_fops          },
543         { .name =       "changelog_max_idle_time",
544           .fops =       &mdd_changelog_max_idle_time_fops       },
545         { .name =       "changelog_max_idle_indexes",
546           .fops =       &mdd_changelog_max_idle_indexes_fops    },
547         { .name =       "changelog_min_gc_interval",
548           .fops =       &mdd_changelog_min_gc_interval_fops     },
549         { .name =       "changelog_min_free_cat_entries",
550           .fops =       &mdd_changelog_min_free_cat_entries_fops        },
551         { .name =       "changelog_deniednext",
552           .fops =       &mdd_changelog_deniednext_fops  },
553         { .name =       "sync_permission",
554           .fops =       &mdd_sync_perm_fops             },
555         { .name =       "lfsck_speed_limit",
556           .fops =       &mdd_lfsck_speed_limit_fops     },
557         { .name =       "lfsck_async_windows",
558           .fops =       &mdd_lfsck_async_windows_fops   },
559         { .name =       "lfsck_namespace",
560           .fops =       &mdd_lfsck_namespace_fops       },
561         { .name =       "lfsck_layout",
562           .fops =       &mdd_lfsck_layout_fops          },
563         { NULL }
564 };
565
566 int mdd_procfs_init(struct mdd_device *mdd, const char *name)
567 {
568         struct obd_device *obd = mdd2obd_dev(mdd);
569         struct obd_type   *type;
570         int                rc;
571         ENTRY;
572
573         /* at the moment there is no linkage between lu_type
574          * and obd_type, so we lookup obd_type this way */
575         type = class_search_type(LUSTRE_MDD_NAME);
576
577         LASSERT(name != NULL);
578         LASSERT(type != NULL);
579         LASSERT(obd  != NULL);
580
581         /* Find the type procroot and add the proc entry for this device */
582         obd->obd_vars = lprocfs_mdd_obd_vars;
583         mdd->mdd_proc_entry = lprocfs_register(name, type->typ_procroot,
584                                                obd->obd_vars, mdd);
585         if (IS_ERR(mdd->mdd_proc_entry)) {
586                 rc = PTR_ERR(mdd->mdd_proc_entry);
587                 CERROR("Error %d setting up lprocfs for %s\n",
588                        rc, name);
589                 mdd->mdd_proc_entry = NULL;
590                 GOTO(out, rc);
591         }
592         rc = 0;
593         EXIT;
594 out:
595         if (rc)
596                 mdd_procfs_fini(mdd);
597         return rc;
598 }
599
600 void mdd_procfs_fini(struct mdd_device *mdd)
601 {
602         if (mdd->mdd_proc_entry)
603                 lprocfs_remove(&mdd->mdd_proc_entry);
604 }