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