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_sync_perm_seq_show(struct seq_file *m, void *data)
 398 {
 399         struct mdd_device *mdd = m->private;
 400
 401         LASSERT(mdd != NULL);
 402         seq_printf(m, "%d\n", mdd->mdd_sync_permission);
 403         return 0;
 404 }
 405
 406 static ssize_t
 407 mdd_sync_perm_seq_write(struct file *file, const char __user *buffer,
 408                         size_t count, loff_t *off)
 409 {
 410         struct seq_file *m = file->private_data;
 411         struct mdd_device *mdd = m->private;
 412         int rc;
 413         __s64 val;
 414
 415         LASSERT(mdd != NULL);
 416         rc = lprocfs_str_to_s64(buffer, count, &val);
 417         if (rc)
 418                 return rc;
 419
 420         mdd->mdd_sync_permission = !!val;
 421
 422         return count;
 423 }
 424 LPROC_SEQ_FOPS(mdd_sync_perm);
 425
 426 static int mdd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
 427 {
 428         struct mdd_device *mdd = m->private;
 429
 430         LASSERT(mdd != NULL);
 431         return lfsck_get_speed(m, mdd->mdd_bottom);
 432 }
 433
 434 static ssize_t
 435 mdd_lfsck_speed_limit_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         __s64 val;
 441         int rc;
 442
 443         LASSERT(mdd != NULL);
 444         rc = lprocfs_str_to_s64(buffer, count, &val);
 445         if (rc != 0)
 446                 return rc;
 447         if (val < 0 || val > INT_MAX)
 448                 return -ERANGE;
 449
 450         rc = lfsck_set_speed(mdd->mdd_bottom, val);
 451         return rc != 0 ? rc : count;
 452 }
 453 LPROC_SEQ_FOPS(mdd_lfsck_speed_limit);
 454
 455 static int mdd_lfsck_async_windows_seq_show(struct seq_file *m, void *data)
 456 {
 457         struct mdd_device *mdd = m->private;
 458
 459         LASSERT(mdd != NULL);
 460         return lfsck_get_windows(m, mdd->mdd_bottom);
 461 }
 462
 463 static ssize_t
 464 mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer,
 465                                   size_t count, loff_t *off)
 466 {
 467         struct seq_file   *m = file->private_data;
 468         struct mdd_device *mdd = m->private;
 469         __s64              val;
 470         int                rc;
 471
 472         LASSERT(mdd != NULL);
 473         rc = lprocfs_str_to_s64(buffer, count, &val);
 474         if (rc)
 475                 return rc;
 476         if (val < 0 || val > INT_MAX)
 477                 return -ERANGE;
 478
 479         rc = lfsck_set_windows(mdd->mdd_bottom, val);
 480
 481         return rc != 0 ? rc : count;
 482 }
 483 LPROC_SEQ_FOPS(mdd_lfsck_async_windows);
 484
 485 static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
 486 {
 487         struct mdd_device *mdd = m->private;
 488
 489         LASSERT(mdd != NULL);
 490
 491         return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE);
 492 }
 493 LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace);
 494
 495 static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
 496 {
 497         struct mdd_device *mdd = m->private;
 498
 499         LASSERT(mdd != NULL);
 500
 501         return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT);
 502 }
 503 LPROC_SEQ_FOPS_RO(mdd_lfsck_layout);
 504
 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          },
 534         { NULL }
 535 };
 536
 537 int mdd_procfs_init(struct mdd_device *mdd, const char *name)
 538 {
 539         struct obd_device *obd = mdd2obd_dev(mdd);
 540         struct obd_type   *type;
 541         int                rc;
 542         ENTRY;
 543
 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);
 547
 548         LASSERT(name != NULL);
 549         LASSERT(type != NULL);
 550         LASSERT(obd  != NULL);
 551
 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,
 555                                                obd->obd_vars, mdd);
 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",
 559                        rc, name);
 560                 mdd->mdd_proc_entry = NULL;
 561                 GOTO(out, rc);
 562         }
 563         rc = 0;
 564         EXIT;
 565 out:
 566         if (rc)
 567                 mdd_procfs_fini(mdd);
 568         return rc;
 569 }
 570
 571 void mdd_procfs_fini(struct mdd_device *mdd)
 572 {
 573         if (mdd->mdd_proc_entry)
 574                 lprocfs_remove(&mdd->mdd_proc_entry);
 575 }