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         /* XXX may need to limit with reasonable elapsed/idle times */
 277         if (val < 1)
 278                 return -ERANGE;
 279
 280         mdd->mdd_changelog_max_idle_time = val;
 281
 282         return count;
 283 }
 284 LPROC_SEQ_FOPS(mdd_changelog_max_idle_time);
 285
 286 static int mdd_changelog_max_idle_indexes_seq_show(struct seq_file *m,
 287                                                    void *data)
 288 {
 289         struct mdd_device *mdd = m->private;
 290
 291         LASSERT(mdd != NULL);
 292         seq_printf(m, "%lu\n", mdd->mdd_changelog_max_idle_indexes);
 293         return 0;
 294 }
 295
 296 static ssize_t
 297 mdd_changelog_max_idle_indexes_seq_write(struct file *file,
 298                                          const char __user *buffer,
 299                                          size_t count, loff_t *off)
 300 {
 301         struct seq_file *m = file->private_data;
 302         struct mdd_device *mdd = m->private;
 303         unsigned long val;
 304         int rc;
 305
 306         LASSERT(mdd != NULL);
 307         rc = kstrtoul_from_user(buffer, count, 0, &val);
 308         if (rc)
 309                 return rc;
 310
 311         /* XXX may need to limit/check with reasonable elapsed/idle indexes */
 312         /* XXX may better allow to specify a % of full ChangeLogs */
 313
 314         mdd->mdd_changelog_max_idle_indexes = val;
 315
 316         return count;
 317 }
 318 LPROC_SEQ_FOPS(mdd_changelog_max_idle_indexes);
 319
 320 static int mdd_changelog_min_gc_interval_seq_show(struct seq_file *m,
 321                                                   void *data)
 322 {
 323         struct mdd_device *mdd = m->private;
 324
 325         LASSERT(mdd != NULL);
 326         seq_printf(m, "%lld\n", mdd->mdd_changelog_min_gc_interval);
 327         return 0;
 328 }
 329
 330 static ssize_t
 331 mdd_changelog_min_gc_interval_seq_write(struct file *file,
 332                                         const char __user *buffer,
 333                                         size_t count, loff_t *off)
 334 {
 335         struct seq_file *m = file->private_data;
 336         struct mdd_device *mdd = m->private;
 337         time64_t val;
 338         int rc;
 339
 340         LASSERT(mdd != NULL);
 341         rc = kstrtoll_from_user(buffer, count, 0, &val);
 342         if (rc)
 343                 return rc;
 344
 345         /* XXX may need to limit with reasonable elapsed/interval times */
 346         if (val < 1)
 347                 return -ERANGE;
 348
 349         mdd->mdd_changelog_min_gc_interval = val;
 350
 351         return count;
 352 }
 353 LPROC_SEQ_FOPS(mdd_changelog_min_gc_interval);
 354
 355 static int mdd_changelog_min_free_cat_entries_seq_show(struct seq_file *m,
 356                                                        void *data)
 357 {
 358         struct mdd_device *mdd = m->private;
 359
 360         LASSERT(mdd != NULL);
 361         seq_printf(m, "%u\n", mdd->mdd_changelog_min_free_cat_entries);
 362         return 0;
 363 }
 364
 365 static ssize_t
 366 mdd_changelog_min_free_cat_entries_seq_write(struct file *file,
 367                                              const char __user *buffer,
 368                                              size_t count, loff_t *off)
 369 {
 370         struct seq_file *m = file->private_data;
 371         struct mdd_device *mdd = m->private;
 372         unsigned int val;
 373         int rc;
 374
 375         LASSERT(mdd != NULL);
 376         rc = kstrtouint_from_user(buffer, count, 0, &val);
 377         if (rc)
 378                 return rc;
 379
 380         /* XXX may need to limit with more reasonable number of free entries */
 381         if (val < 1)
 382                 return -ERANGE;
 383
 384         mdd->mdd_changelog_min_free_cat_entries = val;
 385
 386         return count;
 387 }
 388 LPROC_SEQ_FOPS(mdd_changelog_min_free_cat_entries);
 389
 390 static int mdd_changelog_deniednext_seq_show(struct seq_file *m, void *data)
 391 {
 392         struct mdd_device *mdd = m->private;
 393
 394         seq_printf(m, "%u\n", mdd->mdd_cl.mc_deniednext);
 395         return 0;
 396 }
 397
 398 static ssize_t
 399 mdd_changelog_deniednext_seq_write(struct file *file, const char __user *buffer,
 400                                    size_t count, loff_t *off)
 401 {
 402         struct seq_file *m = file->private_data;
 403         struct mdd_device *mdd = m->private;
 404         char kernbuf[11];
 405         unsigned int time = 0;
 406         int rc;
 407
 408         if (count > (sizeof(kernbuf) - 1))
 409                 return -EINVAL;
 410
 411         if (copy_from_user(kernbuf, buffer, count))
 412                 return -EFAULT;
 413
 414         kernbuf[count] = '\0';
 415
 416         rc = kstrtoul(kernbuf, 0, (unsigned long int *)&time);
 417         if (rc)
 418                 return rc;
 419
 420         mdd->mdd_cl.mc_deniednext = time;
 421         return count;
 422 }
 423 LPROC_SEQ_FOPS(mdd_changelog_deniednext);
 424
 425 static int mdd_sync_perm_seq_show(struct seq_file *m, void *data)
 426 {
 427         struct mdd_device *mdd = m->private;
 428
 429         LASSERT(mdd != NULL);
 430         seq_printf(m, "%d\n", mdd->mdd_sync_permission);
 431         return 0;
 432 }
 433
 434 static ssize_t
 435 mdd_sync_perm_seq_write(struct file *file, const char __user *buffer,
 436                         size_t count, loff_t *off)
 437 {
 438         struct seq_file *m = file->private_data;
 439         struct mdd_device *mdd = m->private;
 440         bool val;
 441         int rc;
 442
 443         LASSERT(mdd != NULL);
 444         rc = kstrtobool_from_user(buffer, count, &val);
 445         if (rc)
 446                 return rc;
 447
 448         mdd->mdd_sync_permission = val;
 449
 450         return count;
 451 }
 452 LPROC_SEQ_FOPS(mdd_sync_perm);
 453
 454 static int mdd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
 455 {
 456         struct mdd_device *mdd = m->private;
 457
 458         LASSERT(mdd != NULL);
 459         return lfsck_get_speed(m, mdd->mdd_bottom);
 460 }
 461
 462 static ssize_t
 463 mdd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
 464                                 size_t count, loff_t *off)
 465 {
 466         struct seq_file *m = file->private_data;
 467         struct mdd_device *mdd = m->private;
 468         unsigned int val;
 469         int rc;
 470
 471         LASSERT(mdd != NULL);
 472         rc = kstrtouint_from_user(buffer, count, 0, &val);
 473         if (rc != 0)
 474                 return rc;
 475
 476         rc = lfsck_set_speed(mdd->mdd_bottom, val);
 477         return rc != 0 ? rc : count;
 478 }
 479 LPROC_SEQ_FOPS(mdd_lfsck_speed_limit);
 480
 481 static int mdd_lfsck_async_windows_seq_show(struct seq_file *m, void *data)
 482 {
 483         struct mdd_device *mdd = m->private;
 484
 485         LASSERT(mdd != NULL);
 486         return lfsck_get_windows(m, mdd->mdd_bottom);
 487 }
 488
 489 static ssize_t
 490 mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer,
 491                                   size_t count, loff_t *off)
 492 {
 493         struct seq_file *m = file->private_data;
 494         struct mdd_device *mdd = m->private;
 495         unsigned int val;
 496         int rc;
 497
 498         LASSERT(mdd != NULL);
 499         rc = kstrtouint_from_user(buffer, count, 0, &val);
 500         if (rc)
 501                 return rc;
 502
 503         rc = lfsck_set_windows(mdd->mdd_bottom, val);
 504
 505         return rc != 0 ? rc : count;
 506 }
 507 LPROC_SEQ_FOPS(mdd_lfsck_async_windows);
 508
 509 static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
 510 {
 511         struct mdd_device *mdd = m->private;
 512
 513         LASSERT(mdd != NULL);
 514
 515         return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE);
 516 }
 517 LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace);
 518
 519 static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
 520 {
 521         struct mdd_device *mdd = m->private;
 522
 523         LASSERT(mdd != NULL);
 524
 525         return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT);
 526 }
 527 LPROC_SEQ_FOPS_RO(mdd_lfsck_layout);
 528
 529 static struct lprocfs_vars lprocfs_mdd_obd_vars[] = {
 530         { .name =       "atime_diff",
 531           .fops =       &mdd_atime_diff_fops            },
 532         { .name =       "changelog_mask",
 533           .fops =       &mdd_changelog_mask_fops        },
 534         { .name =       "changelog_users",
 535           .fops =       &mdd_changelog_users_fops       },
 536         { .name =       "changelog_size",
 537           .fops =       &mdd_changelog_size_fops        },
 538         { .name =       "changelog_gc",
 539           .fops =       &mdd_changelog_gc_fops          },
 540         { .name =       "changelog_max_idle_time",
 541           .fops =       &mdd_changelog_max_idle_time_fops       },
 542         { .name =       "changelog_max_idle_indexes",
 543           .fops =       &mdd_changelog_max_idle_indexes_fops    },
 544         { .name =       "changelog_min_gc_interval",
 545           .fops =       &mdd_changelog_min_gc_interval_fops     },
 546         { .name =       "changelog_min_free_cat_entries",
 547           .fops =       &mdd_changelog_min_free_cat_entries_fops        },
 548         { .name =       "changelog_deniednext",
 549           .fops =       &mdd_changelog_deniednext_fops  },
 550         { .name =       "sync_permission",
 551           .fops =       &mdd_sync_perm_fops             },
 552         { .name =       "lfsck_speed_limit",
 553           .fops =       &mdd_lfsck_speed_limit_fops     },
 554         { .name =       "lfsck_async_windows",
 555           .fops =       &mdd_lfsck_async_windows_fops   },
 556         { .name =       "lfsck_namespace",
 557           .fops =       &mdd_lfsck_namespace_fops       },
 558         { .name =       "lfsck_layout",
 559           .fops =       &mdd_lfsck_layout_fops          },
 560         { NULL }
 561 };
 562
 563 int mdd_procfs_init(struct mdd_device *mdd, const char *name)
 564 {
 565         struct obd_device *obd = mdd2obd_dev(mdd);
 566         struct obd_type   *type;
 567         int                rc;
 568         ENTRY;
 569
 570         /* at the moment there is no linkage between lu_type
 571          * and obd_type, so we lookup obd_type this way */
 572         type = class_search_type(LUSTRE_MDD_NAME);
 573
 574         LASSERT(name != NULL);
 575         LASSERT(type != NULL);
 576         LASSERT(obd  != NULL);
 577
 578         /* Find the type procroot and add the proc entry for this device */
 579         obd->obd_vars = lprocfs_mdd_obd_vars;
 580         mdd->mdd_proc_entry = lprocfs_register(name, type->typ_procroot,
 581                                                obd->obd_vars, mdd);
 582         if (IS_ERR(mdd->mdd_proc_entry)) {
 583                 rc = PTR_ERR(mdd->mdd_proc_entry);
 584                 CERROR("Error %d setting up lprocfs for %s\n",
 585                        rc, name);
 586                 mdd->mdd_proc_entry = NULL;
 587                 GOTO(out, rc);
 588         }
 589         rc = 0;
 590         EXIT;
 591 out:
 592         if (rc)
 593                 mdd_procfs_fini(mdd);
 594         return rc;
 595 }
 596
 597 void mdd_procfs_fini(struct mdd_device *mdd)
 598 {
 599         if (mdd->mdd_proc_entry)
 600                 lprocfs_remove(&mdd->mdd_proc_entry);
 601 }