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  *
  31  * lustre/mdd/mdd_lproc.c
  32  *
  33  * Lustre Metadata Server (mdd) routines
  34  *
  35  * Author: Wang Di <wangdi@clusterfs.com>
  36  */
  37
  38 #define DEBUG_SUBSYSTEM S_MDS
  39
  40 #include <obd.h>
  41 #include <obd_class.h>
  42 #include <obd_support.h>
  43 #include <lprocfs_status.h>
  44 #include <libcfs/libcfs_string.h>
  45 #include "mdd_internal.h"
  46
  47 static ssize_t uuid_show(struct kobject *kobj, struct attribute *attr,
  48                          char *buf)
  49 {
  50         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
  51                                               mdd_kobj);
  52         struct obd_device *obd = mdd2obd_dev(mdd);
  53
  54         return sprintf(buf, "%s\n", obd->obd_uuid.uuid);
  55 }
  56 LUSTRE_RO_ATTR(uuid);
  57
  58 static ssize_t atime_diff_show(struct kobject *kobj, struct attribute *attr,
  59                                char *buf)
  60 {
  61         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
  62                                               mdd_kobj);
  63
  64         return sprintf(buf, "%lld\n", mdd->mdd_atime_diff);
  65 }
  66
  67 static ssize_t atime_diff_store(struct kobject *kobj,
  68                                 struct attribute *attr,
  69                                 const char *buffer, size_t count)
  70 {
  71         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
  72                                               mdd_kobj);
  73         time64_t diff = 0;
  74         int rc;
  75
  76         rc = kstrtoll(buffer, 10, &diff);
  77         if (rc)
  78                 return rc;
  79
  80         mdd->mdd_atime_diff = diff;
  81         return count;
  82 }
  83 LUSTRE_RW_ATTR(atime_diff);
  84
  85 /**** changelogs ****/
  86 static int mdd_changelog_current_mask_seq_show(struct seq_file *m, void *data)
  87 {
  88         struct mdd_device *mdd = m->private;
  89         int i = 0;
  90
  91         while (i < CL_LAST) {
  92                 if (mdd->mdd_cl.mc_current_mask & BIT(i))
  93                         seq_printf(m, "%s ", changelog_type2str(i));
  94                 i++;
  95         }
  96         seq_putc(m, '\n');
  97         return 0;
  98 }
  99 LDEBUGFS_SEQ_FOPS_RO(mdd_changelog_current_mask);
 100
 101 static int mdd_changelog_mask_seq_show(struct seq_file *m, void *data)
 102 {
 103         struct mdd_device *mdd = m->private;
 104         int i = 0;
 105
 106         while (i < CL_LAST) {
 107                 if (mdd->mdd_cl.mc_proc_mask & BIT(i))
 108                         seq_printf(m, "%s ", changelog_type2str(i));
 109                 i++;
 110         }
 111         seq_putc(m, '\n');
 112         return 0;
 113 }
 114
 115 static ssize_t
 116 mdd_changelog_mask_seq_write(struct file *file, const char __user *buffer,
 117                              size_t count, loff_t *off)
 118 {
 119         struct seq_file *m = file->private_data;
 120         struct mdd_device *mdd = m->private;
 121         char *kernbuf;
 122         int rc;
 123         int oldmask = mdd->mdd_cl.mc_proc_mask;
 124         int newmask = oldmask;
 125
 126         ENTRY;
 127
 128         if (count >= PAGE_SIZE)
 129                 RETURN(-EINVAL);
 130         OBD_ALLOC(kernbuf, PAGE_SIZE);
 131         if (kernbuf == NULL)
 132                 RETURN(-ENOMEM);
 133         if (copy_from_user(kernbuf, buffer, count))
 134                 GOTO(out, rc = -EFAULT);
 135         kernbuf[count] = 0;
 136
 137         /* if the new mask is relative and proc mask is minimal then assume
 138          * it is relative to DEFMASK, otherwise apply new mask on the current
 139          * proc mask.
 140          */
 141         if (oldmask == CHANGELOG_MINMASK) {
 142                 char *str = kernbuf;
 143
 144                 while (isspace(*str))
 145                         str++;
 146                 if (*str == '+' || *str == '-')
 147                         newmask = CHANGELOG_DEFMASK;
 148         }
 149
 150         rc = cfs_str2mask(kernbuf, changelog_type2str, &newmask,
 151                           CHANGELOG_MINMASK, CHANGELOG_ALLMASK,
 152                           CHANGELOG_DEFMASK);
 153         if (rc)
 154                 GOTO(out, rc);
 155
 156         mdd->mdd_cl.mc_proc_mask = newmask;
 157
 158         /* if mask keeps all bits from oldmask then just extend the current
 159          * mask, otherwise the current mask should be recalculated through
 160          * all user masks.
 161          */
 162         if ((newmask & oldmask) == oldmask) {
 163                 spin_lock(&mdd->mdd_cl.mc_user_lock);
 164                 mdd->mdd_cl.mc_current_mask |= newmask;
 165                 spin_unlock(&mdd->mdd_cl.mc_user_lock);
 166         } else {
 167                 struct lu_env env;
 168
 169                 rc = lu_env_init(&env, LCT_LOCAL);
 170                 if (rc)
 171                         GOTO(out, rc);
 172
 173                 mdd_changelog_recalc_mask(&env, mdd);
 174                 lu_env_fini(&env);
 175         }
 176
 177         if (!rc)
 178                 rc = count;
 179
 180 out:
 181         OBD_FREE(kernbuf, PAGE_SIZE);
 182         return rc;
 183 }
 184 LDEBUGFS_SEQ_FOPS(mdd_changelog_mask);
 185
 186 static int lprocfs_changelog_users_cb(const struct lu_env *env,
 187                                       struct llog_handle *llh,
 188                                       struct llog_rec_hdr *hdr, void *data)
 189 {
 190         struct llog_changelog_user_rec2 *rec;
 191         struct seq_file *m = data;
 192         char user_name[CHANGELOG_USER_NAMELEN_FULL];
 193
 194         LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
 195
 196         rec = container_of(hdr, typeof(*rec), cur_hdr);
 197
 198         seq_printf(m, "%-24s %10llu (%u)",
 199                    mdd_chlg_username(rec, user_name, sizeof(user_name)),
 200                    rec->cur_endrec,
 201                    (__u32)ktime_get_real_seconds() - rec->cur_time);
 202         if (mdd_chlg_usermask(rec)) {
 203                 char *sep = "";
 204                 int i;
 205
 206                 seq_puts(m, " mask=");
 207                 for (i = 0; i < CL_LAST; i++) {
 208                         if (!(mdd_chlg_usermask(rec) & BIT(i)))
 209                                 continue;
 210                         if (*sep)
 211                                 seq_puts(m, sep);
 212                         seq_puts(m, changelog_type2str(i));
 213                         sep = ",";
 214                 }
 215         }
 216         seq_puts(m, "\n");
 217
 218         return 0;
 219 }
 220
 221 static int mdd_changelog_users_seq_show(struct seq_file *m, void *data)
 222 {
 223         struct lu_env            env;
 224         struct mdd_device       *mdd = m->private;
 225         struct llog_ctxt        *ctxt;
 226         __u64                    cur;
 227         int                      rc;
 228
 229         ctxt = llog_get_context(mdd2obd_dev(mdd),
 230                                 LLOG_CHANGELOG_USER_ORIG_CTXT);
 231         if (ctxt == NULL)
 232                 return -ENXIO;
 233         LASSERT(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT);
 234
 235         rc = lu_env_init(&env, LCT_LOCAL);
 236         if (rc) {
 237                 llog_ctxt_put(ctxt);
 238                 return rc;
 239         }
 240
 241         spin_lock(&mdd->mdd_cl.mc_lock);
 242         cur = mdd->mdd_cl.mc_index;
 243         spin_unlock(&mdd->mdd_cl.mc_lock);
 244
 245         seq_printf(m, "current_index: %llu\n", cur);
 246         seq_printf(m, "%-24s %10s %s %s\n", "ID", "index", "(idle)", "mask");
 247
 248         llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb,
 249                          m, 0, 0);
 250
 251         lu_env_fini(&env);
 252         llog_ctxt_put(ctxt);
 253         return 0;
 254 }
 255 LDEBUGFS_SEQ_FOPS_RO(mdd_changelog_users);
 256
 257 static int mdd_changelog_size_ctxt(const struct lu_env *env,
 258                                    struct mdd_device *mdd,
 259                                    int index, __u64 *val)
 260 {
 261         struct llog_ctxt        *ctxt;
 262
 263         ctxt = llog_get_context(mdd2obd_dev(mdd),
 264                                 index);
 265         if (ctxt == NULL)
 266                 return -ENXIO;
 267
 268         if (!(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT)) {
 269                 CERROR("%s: ChangeLog has wrong flags: rc = %d\n",
 270                        ctxt->loc_obd->obd_name, -EINVAL);
 271                 llog_ctxt_put(ctxt);
 272                 return -EINVAL;
 273         }
 274
 275         *val += llog_cat_size(env, ctxt->loc_handle);
 276
 277         llog_ctxt_put(ctxt);
 278
 279         return 0;
 280 }
 281
 282 static ssize_t changelog_size_show(struct kobject *kobj,
 283                                    struct attribute *attr,
 284                                    char *buf)
 285 {
 286         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 287                                               mdd_kobj);
 288         struct lu_env env;
 289         u64 tmp = 0;
 290         int rc;
 291
 292         rc = lu_env_init(&env, LCT_LOCAL);
 293         if (rc)
 294                 return rc;
 295
 296         rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_ORIG_CTXT, &tmp);
 297         if (rc) {
 298                 lu_env_fini(&env);
 299                 return rc;
 300         }
 301
 302         rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT,
 303                                      &tmp);
 304
 305         rc = sprintf(buf, "%llu\n", tmp);
 306         lu_env_fini(&env);
 307         return rc;
 308 }
 309 LUSTRE_RO_ATTR(changelog_size);
 310
 311 static ssize_t changelog_gc_show(struct kobject *kobj,
 312                                  struct attribute *attr,
 313                                  char *buf)
 314 {
 315         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 316                                               mdd_kobj);
 317
 318         return sprintf(buf, "%u\n", mdd->mdd_changelog_gc);
 319 }
 320
 321 static ssize_t changelog_gc_store(struct kobject *kobj,
 322                                   struct attribute *attr,
 323                                   const char *buffer, size_t count)
 324 {
 325         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 326                                               mdd_kobj);
 327         bool val;
 328         int rc;
 329
 330         rc = kstrtobool(buffer, &val);
 331         if (rc)
 332                 return rc;
 333
 334         mdd->mdd_changelog_gc = val;
 335
 336         return count;
 337 }
 338 LUSTRE_RW_ATTR(changelog_gc);
 339
 340 static ssize_t changelog_max_idle_time_show(struct kobject *kobj,
 341                                             struct attribute *attr,
 342                                             char *buf)
 343 {
 344         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 345                                               mdd_kobj);
 346
 347         return sprintf(buf, "%lld\n", mdd->mdd_changelog_max_idle_time);
 348 }
 349
 350 static ssize_t changelog_max_idle_time_store(struct kobject *kobj,
 351                                              struct attribute *attr,
 352                                              const char *buffer, size_t count)
 353 {
 354         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 355                                               mdd_kobj);
 356         time64_t val;
 357         int rc;
 358
 359         rc = kstrtoll(buffer, 10, &val);
 360         if (rc)
 361                 return rc;
 362
 363         /* as it sounds reasonable, do not allow a user to be idle since
 364          * more than about 68 years, this will allow to use 32bits
 365          * timestamps for comparison
 366          */
 367         if (val < 1 || val > INT_MAX)
 368                 return -ERANGE;
 369
 370         mdd->mdd_changelog_max_idle_time = val;
 371
 372         return count;
 373 }
 374 LUSTRE_RW_ATTR(changelog_max_idle_time);
 375
 376 static ssize_t changelog_max_idle_indexes_show(struct kobject *kobj,
 377                                                struct attribute *attr,
 378                                                char *buf)
 379 {
 380         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 381                                               mdd_kobj);
 382
 383         return sprintf(buf, "%lu\n", mdd->mdd_changelog_max_idle_indexes);
 384 }
 385
 386 static ssize_t changelog_max_idle_indexes_store(struct kobject *kobj,
 387                                                 struct attribute *attr,
 388                                                 const char *buffer,
 389                                                 size_t count)
 390 {
 391         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 392                                               mdd_kobj);
 393         unsigned long val;
 394         int rc;
 395
 396         LASSERT(mdd != NULL);
 397         rc = kstrtoul(buffer, 0, &val);
 398         if (rc)
 399                 return rc;
 400
 401         /* XXX may need to limit/check with reasonable elapsed/idle indexes */
 402         /* XXX may better allow to specify a % of full ChangeLogs */
 403
 404         mdd->mdd_changelog_max_idle_indexes = val;
 405
 406         return count;
 407 }
 408 LUSTRE_RW_ATTR(changelog_max_idle_indexes);
 409
 410 static ssize_t changelog_min_gc_interval_show(struct kobject *kobj,
 411                                               struct attribute *attr,
 412                                               char *buf)
 413 {
 414         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 415                                               mdd_kobj);
 416
 417         return sprintf(buf, "%lld\n", mdd->mdd_changelog_min_gc_interval);
 418 }
 419
 420 static ssize_t changelog_min_gc_interval_store(struct kobject *kobj,
 421                                                struct attribute *attr,
 422                                                const char *buffer,
 423                                                size_t count)
 424 {
 425         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 426                                               mdd_kobj);
 427         time64_t val;
 428         int rc;
 429
 430         rc = kstrtoll(buffer, 10, &val);
 431         if (rc)
 432                 return rc;
 433
 434         /* XXX may need to limit with reasonable elapsed/interval times */
 435         if (val < 1)
 436                 return -ERANGE;
 437
 438         mdd->mdd_changelog_min_gc_interval = val;
 439
 440         return count;
 441 }
 442 LUSTRE_RW_ATTR(changelog_min_gc_interval);
 443
 444 static ssize_t changelog_min_free_cat_entries_show(struct kobject *kobj,
 445                                                    struct attribute *attr,
 446                                                    char *buf)
 447 {
 448         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 449                                               mdd_kobj);
 450
 451         return sprintf(buf, "%u\n", mdd->mdd_changelog_min_free_cat_entries);
 452 }
 453
 454 static ssize_t changelog_min_free_cat_entries_store(struct kobject *kobj,
 455                                                     struct attribute *attr,
 456                                                     const char *buffer,
 457                                                     size_t count)
 458 {
 459         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 460                                               mdd_kobj);
 461         unsigned int val;
 462         int rc;
 463
 464         rc = kstrtouint(buffer, 10, &val);
 465         if (rc)
 466                 return rc;
 467
 468         /* XXX may need to limit with more reasonable number of free entries */
 469         if (val < 1)
 470                 return -ERANGE;
 471
 472         mdd->mdd_changelog_min_free_cat_entries = val;
 473
 474         return count;
 475 }
 476 LUSTRE_RW_ATTR(changelog_min_free_cat_entries);
 477
 478 static ssize_t changelog_deniednext_show(struct kobject *kobj,
 479                                          struct attribute *attr,
 480                                          char *buf)
 481 {
 482         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 483                                               mdd_kobj);
 484
 485         return sprintf(buf, "%u\n", mdd->mdd_cl.mc_deniednext);
 486 }
 487
 488 static ssize_t changelog_deniednext_store(struct kobject *kobj,
 489                                           struct attribute *attr,
 490                                           const char *buffer,
 491                                           size_t count)
 492 {
 493         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 494                                               mdd_kobj);
 495         unsigned int time = 0;
 496         int rc;
 497
 498         rc = kstrtouint(buffer, 0, &time);
 499         if (rc)
 500                 return rc;
 501
 502         mdd->mdd_cl.mc_deniednext = time;
 503         return count;
 504 }
 505 LUSTRE_RW_ATTR(changelog_deniednext);
 506
 507 static ssize_t sync_permission_show(struct kobject *kobj,
 508                                     struct attribute *attr, char *buf)
 509 {
 510         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 511                                               mdd_kobj);
 512
 513         return sprintf(buf, "%d\n", mdd->mdd_sync_permission);
 514 }
 515
 516 static ssize_t sync_permission_store(struct kobject *kobj,
 517                                      struct attribute *attr,
 518                                      const char *buffer, size_t count)
 519 {
 520         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 521                                               mdd_kobj);
 522         bool val;
 523         int rc;
 524
 525         rc = kstrtobool(buffer, &val);
 526         if (rc)
 527                 return rc;
 528
 529         mdd->mdd_sync_permission = val;
 530
 531         return count;
 532 }
 533 LUSTRE_RW_ATTR(sync_permission);
 534
 535 static ssize_t lfsck_speed_limit_show(struct kobject *kobj,
 536                                       struct attribute *attr, char *buf)
 537 {
 538         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 539                                               mdd_kobj);
 540
 541         return lfsck_get_speed(buf, mdd->mdd_bottom);
 542 }
 543
 544 static ssize_t lfsck_speed_limit_store(struct kobject *kobj,
 545                                        struct attribute *attr,
 546                                        const char *buffer, size_t count)
 547 {
 548         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 549                                               mdd_kobj);
 550         unsigned int val;
 551         int rc;
 552
 553         rc = kstrtouint(buffer, 10, &val);
 554         if (rc != 0)
 555                 return rc;
 556
 557         rc = lfsck_set_speed(mdd->mdd_bottom, val);
 558         return rc != 0 ? rc : count;
 559 }
 560 LUSTRE_RW_ATTR(lfsck_speed_limit);
 561
 562 static ssize_t lfsck_async_windows_show(struct kobject *kobj,
 563                                         struct attribute *attr, char *buf)
 564 {
 565         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 566                                               mdd_kobj);
 567
 568         return lfsck_get_windows(buf, mdd->mdd_bottom);
 569 }
 570
 571 static ssize_t lfsck_async_windows_store(struct kobject *kobj,
 572                                          struct attribute *attr,
 573                                          const char *buffer, size_t count)
 574 {
 575         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 576                                               mdd_kobj);
 577         unsigned int val;
 578         int rc;
 579
 580         rc = kstrtouint(buffer, 10, &val);
 581         if (rc)
 582                 return rc;
 583
 584         rc = lfsck_set_windows(mdd->mdd_bottom, val);
 585
 586         return rc != 0 ? rc : count;
 587 }
 588 LUSTRE_RW_ATTR(lfsck_async_windows);
 589
 590 static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
 591 {
 592         struct mdd_device *mdd = m->private;
 593
 594         LASSERT(mdd != NULL);
 595
 596         return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE);
 597 }
 598 LDEBUGFS_SEQ_FOPS_RO(mdd_lfsck_namespace);
 599
 600 static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
 601 {
 602         struct mdd_device *mdd = m->private;
 603
 604         LASSERT(mdd != NULL);
 605
 606         return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT);
 607 }
 608 LDEBUGFS_SEQ_FOPS_RO(mdd_lfsck_layout);
 609
 610 /**
 611  * Show default number of stripes for O_APPEND files.
 612  *
 613  * \param[in] m         seq file
 614  * \param[in] v         unused for single entry
 615  *
 616  * \retval 0            on success,
 617  * \retval negative     error code if failed
 618  */
 619 static ssize_t append_stripe_count_show(struct kobject *kobj,
 620                                         struct attribute *attr, char *buf)
 621 {
 622         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 623                                               mdd_kobj);
 624
 625         return scnprintf(buf, PAGE_SIZE, "%d\n", mdd->mdd_append_stripe_count);
 626 }
 627
 628 /**
 629  * Set default number of stripes for O_APPEND files.
 630  *
 631  * \param[in] file      proc file
 632  * \param[in] buffer    string containing the default number of stripes
 633  *                      for new files
 634  * \param[in] count     @buffer length
 635  * \param[in] off       unused for single entry
 636  *
 637  * \retval @count       on success
 638  * \retval negative     error code otherwise
 639  */
 640 static ssize_t append_stripe_count_store(struct kobject *kobj,
 641                                          struct attribute *attr,
 642                                          const char *buffer, size_t count)
 643 {
 644         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 645                                               mdd_kobj);
 646         int stripe_count;
 647         int rc;
 648
 649         rc = kstrtoint(buffer, 0, &stripe_count);
 650         if (rc)
 651                 return rc;
 652
 653         if (stripe_count < -1)
 654                 return -ERANGE;
 655
 656         mdd->mdd_append_stripe_count = stripe_count;
 657
 658         return count;
 659 }
 660 LUSTRE_RW_ATTR(append_stripe_count);
 661
 662 /**
 663  * Show default OST pool for O_APPEND files.
 664  *
 665  * \param[in] kobject   proc object
 666  * \param[in] attribute proc attribute
 667  * \param[in] buf       output buffer
 668  *
 669  * \retval 0            on success,
 670  * \retval negative     error code if failed
 671  */
 672 static ssize_t append_pool_show(struct kobject *kobj,
 673                                 struct attribute *attr, char *buf)
 674 {
 675         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 676                                               mdd_kobj);
 677
 678         return scnprintf(buf, PAGE_SIZE, "%s\n", mdd->mdd_append_pool);
 679 }
 680
 681 /**
 682  * Set default OST pool for O_APPEND files.
 683  *
 684  * \param[in] kobject   proc object
 685  * \param[in] attribute proc attribute
 686  * \param[in] buffer    user inputted pool name
 687  * \param[in] count     @buffer length
 688  *
 689  * \retval @count       on success
 690  * \retval negative     error code otherwise
 691  */
 692 static ssize_t append_pool_store(struct kobject *kobj, struct attribute *attr,
 693                                  const char *buffer, size_t count)
 694 {
 695         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 696                                               mdd_kobj);
 697
 698         if (!count || count > LOV_MAXPOOLNAME + 1)
 699                 return -EINVAL;
 700
 701         /* clear previous value */
 702         memset(mdd->mdd_append_pool, 0, LOV_MAXPOOLNAME + 1);
 703
 704         /* entering "none" clears the pool, otherwise copy the new pool */
 705         if (strncmp("none", buffer, 4)) {
 706                 memcpy(mdd->mdd_append_pool, buffer, count);
 707
 708                 /* Trim the trailing '\n' if any */
 709                 if (mdd->mdd_append_pool[count - 1] == '\n') {
 710                         /* Don't echo just a newline */
 711                         if (count == 1)
 712                                 return -EINVAL;
 713                         mdd->mdd_append_pool[count - 1] = 0;
 714                 }
 715         }
 716
 717         return count;
 718 }
 719 LUSTRE_RW_ATTR(append_pool);
 720
 721 static struct ldebugfs_vars ldebugfs_mdd_obd_vars[] = {
 722         { .name =       "changelog_mask",
 723           .fops =       &mdd_changelog_mask_fops        },
 724         { .name =       "changelog_current_mask",
 725           .fops =       &mdd_changelog_current_mask_fops },
 726         { .name =       "changelog_users",
 727           .fops =       &mdd_changelog_users_fops       },
 728         { .name =       "lfsck_namespace",
 729           .fops =       &mdd_lfsck_namespace_fops       },
 730         { .name =       "lfsck_layout",
 731           .fops =       &mdd_lfsck_layout_fops          },
 732         { NULL }
 733 };
 734
 735 static struct attribute *mdd_attrs[] = {
 736         &lustre_attr_uuid.attr,
 737         &lustre_attr_atime_diff.attr,
 738         &lustre_attr_changelog_size.attr,
 739         &lustre_attr_changelog_gc.attr,
 740         &lustre_attr_changelog_max_idle_time.attr,
 741         &lustre_attr_changelog_max_idle_indexes.attr,
 742         &lustre_attr_changelog_min_gc_interval.attr,
 743         &lustre_attr_changelog_min_free_cat_entries.attr,
 744         &lustre_attr_changelog_deniednext.attr,
 745         &lustre_attr_lfsck_async_windows.attr,
 746         &lustre_attr_lfsck_speed_limit.attr,
 747         &lustre_attr_sync_permission.attr,
 748         &lustre_attr_append_stripe_count.attr,
 749         &lustre_attr_append_pool.attr,
 750         NULL,
 751 };
 752
 753 static void mdd_sysfs_release(struct kobject *kobj)
 754 {
 755         struct mdd_device *mdd = container_of(kobj, struct mdd_device,
 756                                               mdd_kobj);
 757         struct obd_device *obd = mdd2obd_dev(mdd);
 758
 759         debugfs_remove_recursive(obd->obd_debugfs_entry);
 760         obd->obd_debugfs_entry = NULL;
 761
 762         complete(&mdd->mdd_kobj_unregister);
 763 }
 764
 765 int mdd_procfs_init(struct mdd_device *mdd, const char *name)
 766 {
 767         struct obd_device *obd = mdd2obd_dev(mdd);
 768         struct obd_type *type;
 769         int rc;
 770
 771         ENTRY;
 772         /* at the moment there is no linkage between lu_type
 773          * and obd_type, so we lookup obd_type this way
 774          */
 775         type = class_search_type(LUSTRE_MDD_NAME);
 776
 777         LASSERT(name != NULL);
 778         LASSERT(type != NULL);
 779         LASSERT(obd  != NULL);
 780
 781         /* put reference taken by class_search_type */
 782         kobject_put(&type->typ_kobj);
 783
 784         mdd->mdd_ktype.default_attrs = mdd_attrs;
 785         mdd->mdd_ktype.release = mdd_sysfs_release;
 786         mdd->mdd_ktype.sysfs_ops = &lustre_sysfs_ops;
 787
 788         init_completion(&mdd->mdd_kobj_unregister);
 789         rc = kobject_init_and_add(&mdd->mdd_kobj, &mdd->mdd_ktype,
 790                                   &type->typ_kobj, "%s", name);
 791         if (rc)
 792                 return rc;
 793
 794         /* Find the type procroot and add the proc entry for this device */
 795         obd->obd_debugfs_vars = ldebugfs_mdd_obd_vars;
 796         obd->obd_debugfs_entry = debugfs_create_dir(name,
 797                                                      type->typ_debugfs_entry);
 798         ldebugfs_add_vars(obd->obd_debugfs_entry, obd->obd_debugfs_vars, mdd);
 799
 800         RETURN(rc);
 801 }
 802
 803 void mdd_procfs_fini(struct mdd_device *mdd)
 804 {
 805         kobject_put(&mdd->mdd_kobj);
 806         wait_for_completion(&mdd->mdd_kobj_unregister);
 807 }