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 }