4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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).
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
23 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2012, 2017, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Sun Microsystems, Inc.
32 * lustre/mdd/mdd_lproc.c
34 * Lustre Metadata Server (mdd) routines
36 * Author: Wang Di <wangdi@clusterfs.com>
39 #define DEBUG_SUBSYSTEM S_MDS
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"
49 mdd_atime_diff_seq_write(struct file *file, const char __user *buffer,
50 size_t count, loff_t *off)
52 struct seq_file *m = file->private_data;
53 struct mdd_device *mdd = m->private;
54 char kernbuf[20], *end;
55 unsigned long diff = 0;
57 if (count > (sizeof(kernbuf) - 1))
60 if (copy_from_user(kernbuf, buffer, count))
63 kernbuf[count] = '\0';
65 diff = simple_strtoul(kernbuf, &end, 0);
69 mdd->mdd_atime_diff = diff;
73 static int mdd_atime_diff_seq_show(struct seq_file *m, void *data)
75 struct mdd_device *mdd = m->private;
77 seq_printf(m, "%lu\n", mdd->mdd_atime_diff);
80 LPROC_SEQ_FOPS(mdd_atime_diff);
82 /**** changelogs ****/
83 static int mdd_changelog_mask_seq_show(struct seq_file *m, void *data)
85 struct mdd_device *mdd = m->private;
89 if (mdd->mdd_cl.mc_mask & (1 << i))
90 seq_printf(m, "%s ", changelog_type2str(i));
98 mdd_changelog_mask_seq_write(struct file *file, const char __user *buffer,
99 size_t count, loff_t *off)
101 struct seq_file *m = file->private_data;
102 struct mdd_device *mdd = m->private;
107 if (count >= PAGE_SIZE)
109 OBD_ALLOC(kernbuf, PAGE_SIZE);
112 if (copy_from_user(kernbuf, buffer, count))
113 GOTO(out, rc = -EFAULT);
116 rc = cfs_str2mask(kernbuf, changelog_type2str, &mdd->mdd_cl.mc_mask,
117 CHANGELOG_MINMASK, CHANGELOG_ALLMASK);
121 OBD_FREE(kernbuf, PAGE_SIZE);
124 LPROC_SEQ_FOPS(mdd_changelog_mask);
126 static int lprocfs_changelog_users_cb(const struct lu_env *env,
127 struct llog_handle *llh,
128 struct llog_rec_hdr *hdr, void *data)
130 struct llog_changelog_user_rec *rec;
131 struct seq_file *m = data;
133 LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
135 rec = (struct llog_changelog_user_rec *)hdr;
137 seq_printf(m, CHANGELOG_USER_PREFIX"%-3d %llu (%u)\n",
138 rec->cur_id, rec->cur_endrec, (__u32)get_seconds() -
143 static int mdd_changelog_users_seq_show(struct seq_file *m, void *data)
146 struct mdd_device *mdd = m->private;
147 struct llog_ctxt *ctxt;
151 ctxt = llog_get_context(mdd2obd_dev(mdd),
152 LLOG_CHANGELOG_USER_ORIG_CTXT);
155 LASSERT(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT);
157 rc = lu_env_init(&env, LCT_LOCAL);
163 spin_lock(&mdd->mdd_cl.mc_lock);
164 cur = mdd->mdd_cl.mc_index;
165 spin_unlock(&mdd->mdd_cl.mc_lock);
167 seq_printf(m, "current index: %llu\n", cur);
168 seq_printf(m, "%-5s %s %s\n", "ID", "index", "(idle seconds)");
170 llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb,
177 LPROC_SEQ_FOPS_RO(mdd_changelog_users);
179 static int mdd_changelog_size_ctxt(const struct lu_env *env,
180 struct mdd_device *mdd,
181 int index, __u64 *val)
183 struct llog_ctxt *ctxt;
185 ctxt = llog_get_context(mdd2obd_dev(mdd),
190 if (!(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT)) {
191 CERROR("%s: ChangeLog has wrong flags: rc = %d\n",
192 ctxt->loc_obd->obd_name, -EINVAL);
197 *val += llog_cat_size(env, ctxt->loc_handle);
204 static int mdd_changelog_size_seq_show(struct seq_file *m, void *data)
207 struct mdd_device *mdd = m->private;
211 rc = lu_env_init(&env, LCT_LOCAL);
215 rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_ORIG_CTXT, &tmp);
221 rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT,
224 seq_printf(m, "%llu\n", tmp);
228 LPROC_SEQ_FOPS_RO(mdd_changelog_size);
230 static int mdd_changelog_gc_seq_show(struct seq_file *m, void *data)
232 struct mdd_device *mdd = m->private;
234 LASSERT(mdd != NULL);
235 seq_printf(m, "%u\n", mdd->mdd_changelog_gc);
240 mdd_changelog_gc_seq_write(struct file *file, const char __user *buffer,
241 size_t count, loff_t *off)
243 struct seq_file *m = file->private_data;
244 struct mdd_device *mdd = m->private;
248 LASSERT(mdd != NULL);
249 rc = lprocfs_str_to_s64(buffer, count, &val);
253 mdd->mdd_changelog_gc = !!val;
257 LPROC_SEQ_FOPS(mdd_changelog_gc);
259 static int mdd_changelog_max_idle_time_seq_show(struct seq_file *m, void *data)
261 struct mdd_device *mdd = m->private;
263 LASSERT(mdd != NULL);
264 seq_printf(m, "%u\n", mdd->mdd_changelog_max_idle_time);
269 mdd_changelog_max_idle_time_seq_write(struct file *file,
270 const char __user *buffer, size_t count,
273 struct seq_file *m = file->private_data;
274 struct mdd_device *mdd = m->private;
278 LASSERT(mdd != NULL);
279 rc = lprocfs_str_to_s64(buffer, count, &val);
283 /* XXX may need to limit with reasonable elapsed/idle times */
284 if (val < 1 || val > INT_MAX)
287 mdd->mdd_changelog_max_idle_time = val;
291 LPROC_SEQ_FOPS(mdd_changelog_max_idle_time);
293 static int mdd_changelog_max_idle_indexes_seq_show(struct seq_file *m,
296 struct mdd_device *mdd = m->private;
298 LASSERT(mdd != NULL);
299 seq_printf(m, "%lu\n", mdd->mdd_changelog_max_idle_indexes);
304 mdd_changelog_max_idle_indexes_seq_write(struct file *file,
305 const char __user *buffer,
306 size_t count, loff_t *off)
308 struct seq_file *m = file->private_data;
309 struct mdd_device *mdd = m->private;
313 LASSERT(mdd != NULL);
314 rc = lprocfs_str_to_s64(buffer, count, &val);
318 /* XXX may need to limit/check with reasonable elapsed/idle indexes */
319 /* XXX may better allow to specify a % of full ChangeLogs */
321 mdd->mdd_changelog_max_idle_indexes = val;
325 LPROC_SEQ_FOPS(mdd_changelog_max_idle_indexes);
327 static int mdd_changelog_min_gc_interval_seq_show(struct seq_file *m,
330 struct mdd_device *mdd = m->private;
332 LASSERT(mdd != NULL);
333 seq_printf(m, "%u\n", mdd->mdd_changelog_min_gc_interval);
338 mdd_changelog_min_gc_interval_seq_write(struct file *file,
339 const char __user *buffer,
340 size_t count, loff_t *off)
342 struct seq_file *m = file->private_data;
343 struct mdd_device *mdd = m->private;
347 LASSERT(mdd != NULL);
348 rc = lprocfs_str_to_s64(buffer, count, &val);
352 /* XXX may need to limit with reasonable elapsed/interval times */
353 if (val < 1 || val > UINT_MAX)
356 mdd->mdd_changelog_min_gc_interval = val;
360 LPROC_SEQ_FOPS(mdd_changelog_min_gc_interval);
362 static int mdd_changelog_min_free_cat_entries_seq_show(struct seq_file *m,
365 struct mdd_device *mdd = m->private;
367 LASSERT(mdd != NULL);
368 seq_printf(m, "%u\n", mdd->mdd_changelog_min_free_cat_entries);
373 mdd_changelog_min_free_cat_entries_seq_write(struct file *file,
374 const char __user *buffer,
375 size_t count, loff_t *off)
377 struct seq_file *m = file->private_data;
378 struct mdd_device *mdd = m->private;
382 LASSERT(mdd != NULL);
383 rc = lprocfs_str_to_s64(buffer, count, &val);
387 /* XXX may need to limit with more reasonable number of free entries */
388 if (val < 1 || (__u64)val > UINT_MAX)
391 mdd->mdd_changelog_min_free_cat_entries = val;
395 LPROC_SEQ_FOPS(mdd_changelog_min_free_cat_entries);
397 static int mdd_sync_perm_seq_show(struct seq_file *m, void *data)
399 struct mdd_device *mdd = m->private;
401 LASSERT(mdd != NULL);
402 seq_printf(m, "%d\n", mdd->mdd_sync_permission);
407 mdd_sync_perm_seq_write(struct file *file, const char __user *buffer,
408 size_t count, loff_t *off)
410 struct seq_file *m = file->private_data;
411 struct mdd_device *mdd = m->private;
415 LASSERT(mdd != NULL);
416 rc = lprocfs_str_to_s64(buffer, count, &val);
420 mdd->mdd_sync_permission = !!val;
424 LPROC_SEQ_FOPS(mdd_sync_perm);
426 static int mdd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
428 struct mdd_device *mdd = m->private;
430 LASSERT(mdd != NULL);
431 return lfsck_get_speed(m, mdd->mdd_bottom);
435 mdd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
436 size_t count, loff_t *off)
438 struct seq_file *m = file->private_data;
439 struct mdd_device *mdd = m->private;
443 LASSERT(mdd != NULL);
444 rc = lprocfs_str_to_s64(buffer, count, &val);
447 if (val < 0 || val > INT_MAX)
450 rc = lfsck_set_speed(mdd->mdd_bottom, val);
451 return rc != 0 ? rc : count;
453 LPROC_SEQ_FOPS(mdd_lfsck_speed_limit);
455 static int mdd_lfsck_async_windows_seq_show(struct seq_file *m, void *data)
457 struct mdd_device *mdd = m->private;
459 LASSERT(mdd != NULL);
460 return lfsck_get_windows(m, mdd->mdd_bottom);
464 mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer,
465 size_t count, loff_t *off)
467 struct seq_file *m = file->private_data;
468 struct mdd_device *mdd = m->private;
472 LASSERT(mdd != NULL);
473 rc = lprocfs_str_to_s64(buffer, count, &val);
476 if (val < 0 || val > INT_MAX)
479 rc = lfsck_set_windows(mdd->mdd_bottom, val);
481 return rc != 0 ? rc : count;
483 LPROC_SEQ_FOPS(mdd_lfsck_async_windows);
485 static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
487 struct mdd_device *mdd = m->private;
489 LASSERT(mdd != NULL);
491 return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE);
493 LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace);
495 static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
497 struct mdd_device *mdd = m->private;
499 LASSERT(mdd != NULL);
501 return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT);
503 LPROC_SEQ_FOPS_RO(mdd_lfsck_layout);
505 static struct lprocfs_vars lprocfs_mdd_obd_vars[] = {
506 { .name = "atime_diff",
507 .fops = &mdd_atime_diff_fops },
508 { .name = "changelog_mask",
509 .fops = &mdd_changelog_mask_fops },
510 { .name = "changelog_users",
511 .fops = &mdd_changelog_users_fops },
512 { .name = "changelog_size",
513 .fops = &mdd_changelog_size_fops },
514 { .name = "changelog_gc",
515 .fops = &mdd_changelog_gc_fops },
516 { .name = "changelog_max_idle_time",
517 .fops = &mdd_changelog_max_idle_time_fops },
518 { .name = "changelog_max_idle_indexes",
519 .fops = &mdd_changelog_max_idle_indexes_fops },
520 { .name = "changelog_min_gc_interval",
521 .fops = &mdd_changelog_min_gc_interval_fops },
522 { .name = "changelog_min_free_cat_entries",
523 .fops = &mdd_changelog_min_free_cat_entries_fops },
524 { .name = "sync_permission",
525 .fops = &mdd_sync_perm_fops },
526 { .name = "lfsck_speed_limit",
527 .fops = &mdd_lfsck_speed_limit_fops },
528 { .name = "lfsck_async_windows",
529 .fops = &mdd_lfsck_async_windows_fops },
530 { .name = "lfsck_namespace",
531 .fops = &mdd_lfsck_namespace_fops },
532 { .name = "lfsck_layout",
533 .fops = &mdd_lfsck_layout_fops },
537 int mdd_procfs_init(struct mdd_device *mdd, const char *name)
539 struct obd_device *obd = mdd2obd_dev(mdd);
540 struct obd_type *type;
544 /* at the moment there is no linkage between lu_type
545 * and obd_type, so we lookup obd_type this way */
546 type = class_search_type(LUSTRE_MDD_NAME);
548 LASSERT(name != NULL);
549 LASSERT(type != NULL);
550 LASSERT(obd != NULL);
552 /* Find the type procroot and add the proc entry for this device */
553 obd->obd_vars = lprocfs_mdd_obd_vars;
554 mdd->mdd_proc_entry = lprocfs_register(name, type->typ_procroot,
556 if (IS_ERR(mdd->mdd_proc_entry)) {
557 rc = PTR_ERR(mdd->mdd_proc_entry);
558 CERROR("Error %d setting up lprocfs for %s\n",
560 mdd->mdd_proc_entry = NULL;
567 mdd_procfs_fini(mdd);
571 void mdd_procfs_fini(struct mdd_device *mdd)
573 if (mdd->mdd_proc_entry)
574 lprocfs_remove(&mdd->mdd_proc_entry);