lustre/mdt/mdt_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) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  *
  31  * lustre/mdt/mdt_lproc.c
  32  *
  33  * Author: Lai Siyao <lsy@clusterfs.com>
  34  * Author: Fan Yong <fanyong@clusterfs.com>
  35  */
  36
  37 #define DEBUG_SUBSYSTEM S_MDS
  38
  39 #include <linux/version.h>
  40 #include <asm/statfs.h>
  41
  42 #include <linux/module.h>
  43 #include <uapi/linux/lnet/nidstr.h>
  44 /* LUSTRE_VERSION_CODE */
  45 #include <uapi/linux/lustre/lustre_ver.h>
  46 /*
  47  * struct OBD_{ALLOC,FREE}*()
  48  * MDT_FAIL_CHECK
  49  */
  50 #include <obd_support.h>
  51 /* struct obd_export */
  52 #include <lustre_export.h>
  53 /* struct obd_device */
  54 #include <obd.h>
  55 #include <obd_class.h>
  56 #include <lustre_mds.h>
  57 #include <lprocfs_status.h>
  58 #include "mdt_internal.h"
  59 #include <obd_cksum.h>
  60
  61 /**
  62  * The rename stats output would be YAML formats, like
  63  * rename_stats:
  64  * - snapshot_time: 1234567890.123456789
  65  * - start_time:    1234567880.987654321
  66  * - elapsed_time:  9.135802468
  67  * - same_dir:
  68  *     4kB: { samples: 1230, pct: 33, cum_pct: 45 }
  69  *     8kB: { samples: 1242, pct: 33, cum_pct: 78 }
  70  *     16kB: { samples: 132, pct: 3, cum_pct: 81 }
  71  * - crossdir_src:
  72  *     4kB: { samples: 123, pct: 33, cum_pct: 45 }
  73  *     8kB: { samples: 124, pct: 33, cum_pct: 78 }
  74  *     16kB: { samples: 12, pct: 3, cum_pct: 81 }
  75  * - crossdir_tgt:
  76  *     4kB: { samples: 123, pct: 33, cum_pct: 45 }
  77  *     8kB: { samples: 124, pct: 33, cum_pct: 78 }
  78  *     16kB: { samples: 12, pct: 3, cum_pct: 81 }
  79  **/
  80
  81 static void display_rename_stats(struct seq_file *seq, char *name,
  82                                  struct obd_histogram *rs_hist)
  83 {
  84         unsigned long tot, t, cum = 0;
  85         int i;
  86
  87         tot = lprocfs_oh_sum(rs_hist);
  88         if (tot > 0)
  89                 seq_printf(seq, "- %s\n", name);
  90
  91         for (i = 0; i < OBD_HIST_MAX; i++) {
  92                 t = rs_hist->oh_buckets[i];
  93                 cum += t;
  94                 if (cum == 0)
  95                         continue;
  96
  97                 if (i < 10)
  98                         seq_printf(seq, "%6s%d%s", " ", 1 << i, "bytes:");
  99                 else if (i < 20)
 100                         seq_printf(seq, "%6s%d%s", " ", 1 << (i - 10), "KB:");
 101                 else
 102                         seq_printf(seq, "%6s%d%s", " ", 1 << (i - 20), "MB:");
 103
 104                 seq_printf(seq, " { sample: %3lu, pct: %3u, cum_pct: %3u }\n",
 105                            t, pct(t, tot), pct(cum, tot));
 106
 107                 if (cum == tot)
 108                         break;
 109         }
 110 }
 111
 112 static void rename_stats_show(struct seq_file *seq,
 113                               struct rename_stats *rename_stats)
 114 {
 115         /* this sampling races with updates */
 116         seq_puts(seq, "rename_stats:\n- ");
 117         lprocfs_stats_header(seq, ktime_get(), rename_stats->rs_init, 15, ":",
 118                              false);
 119
 120         display_rename_stats(seq, "same_dir",
 121                              &rename_stats->rs_hist[RENAME_SAMEDIR_SIZE]);
 122         display_rename_stats(seq, "crossdir_src",
 123                              &rename_stats->rs_hist[RENAME_CROSSDIR_SRC_SIZE]);
 124         display_rename_stats(seq, "crossdir_tgt",
 125                              &rename_stats->rs_hist[RENAME_CROSSDIR_TGT_SIZE]);
 126 }
 127
 128 static int mdt_rename_stats_seq_show(struct seq_file *seq, void *v)
 129 {
 130         struct mdt_device *mdt = seq->private;
 131
 132         rename_stats_show(seq, &mdt->mdt_rename_stats);
 133
 134         return 0;
 135 }
 136
 137 static ssize_t
 138 mdt_rename_stats_seq_write(struct file *file, const char __user *buf,
 139                            size_t len, loff_t *off)
 140 {
 141         struct seq_file *seq = file->private_data;
 142         struct mdt_device *mdt = seq->private;
 143         int i;
 144
 145         for (i = 0; i < RENAME_LAST; i++)
 146                 lprocfs_oh_clear(&mdt->mdt_rename_stats.rs_hist[i]);
 147         mdt->mdt_rename_stats.rs_init = ktime_get();
 148
 149         return len;
 150 }
 151 LPROC_SEQ_FOPS(mdt_rename_stats);
 152
 153 static int lproc_mdt_attach_rename_seqstat(struct mdt_device *mdt)
 154 {
 155         int i;
 156
 157         for (i = 0; i < RENAME_LAST; i++)
 158                 spin_lock_init(&mdt->mdt_rename_stats.rs_hist[i].oh_lock);
 159
 160         return lprocfs_obd_seq_create(mdt2obd_dev(mdt), "rename_stats", 0644,
 161                                       &mdt_rename_stats_fops, mdt);
 162 }
 163
 164 void mdt_rename_counter_tally(struct mdt_thread_info *info,
 165                               struct mdt_device *mdt,
 166                               struct ptlrpc_request *req,
 167                               struct mdt_object *src,
 168                               struct mdt_object *tgt, long count)
 169 {
 170         struct md_attr *ma = &info->mti_attr;
 171         struct rename_stats *rstats = &mdt->mdt_rename_stats;
 172         int rc;
 173
 174         ma->ma_need = MA_INODE;
 175         ma->ma_valid = 0;
 176         rc = mo_attr_get(info->mti_env, mdt_object_child(src), ma);
 177         if (rc) {
 178                 CERROR("%s: "DFID" attr_get, rc = %d\n",
 179                        mdt_obd_name(mdt), PFID(mdt_object_fid(src)), rc);
 180                 return;
 181         }
 182
 183         if (src == tgt) {
 184                 mdt_counter_incr(req, LPROC_MDT_SAMEDIR_RENAME, count);
 185                 lprocfs_oh_tally_log2(&rstats->rs_hist[RENAME_SAMEDIR_SIZE],
 186                                       (unsigned int)ma->ma_attr.la_size);
 187                 return;
 188         }
 189
 190         mdt_counter_incr(req, LPROC_MDT_CROSSDIR_RENAME, count);
 191         lprocfs_oh_tally_log2(&rstats->rs_hist[RENAME_CROSSDIR_SRC_SIZE],
 192                               (unsigned int)ma->ma_attr.la_size);
 193
 194         ma->ma_need = MA_INODE;
 195         ma->ma_valid = 0;
 196         rc = mo_attr_get(info->mti_env, mdt_object_child(tgt), ma);
 197         if (rc) {
 198                 CERROR("%s: "DFID" attr_get, rc = %d\n",
 199                        mdt_obd_name(mdt), PFID(mdt_object_fid(tgt)), rc);
 200                 return;
 201         }
 202
 203         lprocfs_oh_tally_log2(&rstats->rs_hist[RENAME_CROSSDIR_TGT_SIZE],
 204                               (unsigned int)ma->ma_attr.la_size);
 205 }
 206
 207 static ssize_t identity_expire_show(struct kobject *kobj,
 208                                     struct attribute *attr, char *buf)
 209 {
 210         struct obd_device *obd = container_of(kobj, struct obd_device,
 211                                               obd_kset.kobj);
 212         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 213
 214         return scnprintf(buf, PAGE_SIZE, "%lld\n",
 215                          mdt->mdt_identity_cache->uc_entry_expire);
 216 }
 217
 218 static ssize_t identity_expire_store(struct kobject *kobj,
 219                                      struct attribute *attr,
 220                                      const char *buffer, size_t count)
 221 {
 222         struct obd_device *obd = container_of(kobj, struct obd_device,
 223                                               obd_kset.kobj);
 224         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 225         time64_t val;
 226         int rc;
 227
 228         rc = kstrtoll(buffer, 10, &val);
 229         if (rc)
 230                 return rc;
 231
 232         if (val < 0)
 233                 return -ERANGE;
 234
 235         mdt->mdt_identity_cache->uc_entry_expire = val;
 236
 237         return count;
 238 }
 239 LUSTRE_RW_ATTR(identity_expire);
 240
 241 static ssize_t identity_acquire_expire_show(struct kobject *kobj,
 242                                             struct attribute *attr, char *buf)
 243 {
 244         struct obd_device *obd = container_of(kobj, struct obd_device,
 245                                               obd_kset.kobj);
 246         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 247
 248         return scnprintf(buf, PAGE_SIZE, "%lld\n",
 249                          mdt->mdt_identity_cache->uc_acquire_expire);
 250 }
 251
 252 static ssize_t identity_acquire_expire_store(struct kobject *kobj,
 253                                              struct attribute *attr,
 254                                              const char *buffer, size_t count)
 255 {
 256         struct obd_device *obd = container_of(kobj, struct obd_device,
 257                                               obd_kset.kobj);
 258         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 259         time64_t val;
 260         int rc;
 261
 262         rc = kstrtoll(buffer, 0, &val);
 263         if (rc)
 264                 return rc;
 265
 266         if (val < 0 || val > INT_MAX)
 267                 return -ERANGE;
 268
 269         mdt->mdt_identity_cache->uc_acquire_expire = val;
 270
 271         return count;
 272 }
 273 LUSTRE_RW_ATTR(identity_acquire_expire);
 274
 275 static ssize_t identity_upcall_show(struct kobject *kobj,
 276                                     struct attribute *attr, char *buf)
 277 {
 278         struct obd_device *obd = container_of(kobj, struct obd_device,
 279                                               obd_kset.kobj);
 280         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 281         struct upcall_cache *hash = mdt->mdt_identity_cache;
 282         int rc;
 283
 284         down_read(&hash->uc_upcall_rwsem);
 285         rc = scnprintf(buf, PAGE_SIZE, "%s\n", hash->uc_upcall);
 286         up_read(&hash->uc_upcall_rwsem);
 287         return rc;
 288 }
 289
 290 static ssize_t identity_upcall_store(struct kobject *kobj,
 291                                      struct attribute *attr,
 292                                      const char *buffer, size_t count)
 293 {
 294         struct obd_device *obd = container_of(kobj, struct obd_device,
 295                                               obd_kset.kobj);
 296         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 297         struct upcall_cache *hash = mdt->mdt_identity_cache;
 298
 299         if (count >= UC_CACHE_UPCALL_MAXPATH) {
 300                 CERROR("%s: identity upcall too long\n", mdt_obd_name(mdt));
 301                 return -EINVAL;
 302         }
 303
 304         /* Remove any extraneous bits from the upcall (e.g. linefeeds) */
 305         down_write(&hash->uc_upcall_rwsem);
 306         sscanf(buffer, "%s", hash->uc_upcall);
 307         up_write(&hash->uc_upcall_rwsem);
 308
 309         if (strcmp(hash->uc_name, mdt_obd_name(mdt)) != 0)
 310                 CWARN("%s: write to upcall name %s\n",
 311                       mdt_obd_name(mdt), hash->uc_upcall);
 312
 313         if (strcmp(hash->uc_upcall, "NONE") == 0 && mdt->mdt_opts.mo_acl)
 314                 CWARN("%s: disable \"identity_upcall\" with ACL enabled maybe "
 315                       "cause unexpected \"EACCESS\"\n", mdt_obd_name(mdt));
 316
 317         CDEBUG(D_CONFIG, "%s: identity upcall set to %s\n", mdt_obd_name(mdt),
 318                hash->uc_upcall);
 319         RETURN(count);
 320 }
 321 LUSTRE_RW_ATTR(identity_upcall);
 322
 323 static ssize_t identity_flush_store(struct kobject *kobj,
 324                                     struct attribute *attr,
 325                                     const char *buffer, size_t count)
 326 {
 327         struct obd_device *obd = container_of(kobj, struct obd_device,
 328                                               obd_kset.kobj);
 329         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 330         int uid;
 331         int rc;
 332
 333         rc = kstrtoint(buffer, 0, &uid);
 334         if (rc)
 335                 return rc;
 336
 337         mdt_flush_identity(mdt->mdt_identity_cache, uid);
 338         return count;
 339 }
 340 LUSTRE_WO_ATTR(identity_flush);
 341
 342 static ssize_t
 343 lprocfs_identity_info_seq_write(struct file *file, const char __user *buffer,
 344                                 size_t count, void *data)
 345 {
 346         struct seq_file   *m = file->private_data;
 347         struct obd_device *obd = m->private;
 348         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 349         struct identity_downcall_data *param;
 350         int size = sizeof(*param), rc, checked = 0;
 351
 352 again:
 353         if (count < size) {
 354                 CERROR("%s: invalid data count = %lu, size = %d\n",
 355                        mdt_obd_name(mdt), (unsigned long) count, size);
 356                 return -EINVAL;
 357         }
 358
 359         OBD_ALLOC(param, size);
 360         if (param == NULL)
 361                 return -ENOMEM;
 362
 363         if (copy_from_user(param, buffer, size)) {
 364                 CERROR("%s: bad identity data\n", mdt_obd_name(mdt));
 365                 GOTO(out, rc = -EFAULT);
 366         }
 367
 368         if (checked == 0) {
 369                 checked = 1;
 370                 if (param->idd_magic != IDENTITY_DOWNCALL_MAGIC) {
 371                         CERROR("%s: MDS identity downcall bad params\n",
 372                                mdt_obd_name(mdt));
 373                         GOTO(out, rc = -EINVAL);
 374                 }
 375
 376                 if (param->idd_nperms > N_PERMS_MAX) {
 377                         CERROR("%s: perm count %d more than maximum %d\n",
 378                                mdt_obd_name(mdt), param->idd_nperms,
 379                                N_PERMS_MAX);
 380                         GOTO(out, rc = -EINVAL);
 381                 }
 382
 383                 if (param->idd_ngroups > NGROUPS_MAX) {
 384                         CERROR("%s: group count %d more than maximum %d\n",
 385                                mdt_obd_name(mdt), param->idd_ngroups,
 386                                NGROUPS_MAX);
 387                         GOTO(out, rc = -EINVAL);
 388                 }
 389
 390                 if (param->idd_ngroups) {
 391                         rc = param->idd_ngroups; /* save idd_ngroups */
 392                         OBD_FREE(param, size);
 393                         size = offsetof(struct identity_downcall_data,
 394                                         idd_groups[rc]);
 395                         goto again;
 396                 }
 397         }
 398
 399         rc = upcall_cache_downcall(mdt->mdt_identity_cache, param->idd_err,
 400                                    param->idd_uid, param);
 401
 402 out:
 403         if (param != NULL)
 404                 OBD_FREE(param, size);
 405
 406         return rc ? rc : count;
 407 }
 408 LPROC_SEQ_FOPS_WR_ONLY(mdt, identity_info);
 409
 410 static int mdt_site_stats_seq_show(struct seq_file *m, void *data)
 411 {
 412         struct obd_device *obd = m->private;
 413         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 414
 415         return lu_site_stats_seq_print(mdt_lu_site(mdt), m);
 416 }
 417 LPROC_SEQ_FOPS_RO(mdt_site_stats);
 418
 419 #define BUFLEN (UUID_MAX + 4)
 420
 421 static ssize_t
 422 lprocfs_mds_evict_client_seq_write(struct file *file, const char __user *buf,
 423                                    size_t count, loff_t *off)
 424 {
 425         struct seq_file   *m = file->private_data;
 426         struct obd_device *obd = m->private;
 427         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 428         char *kbuf;
 429         char *tmpbuf;
 430         int rc = 0;
 431
 432         OBD_ALLOC(kbuf, BUFLEN);
 433         if (kbuf == NULL)
 434                 return -ENOMEM;
 435
 436         /*
 437          * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1
 438          * bytes into kbuf, to ensure that the string is NUL-terminated.
 439          * UUID_MAX should include a trailing NUL already.
 440          */
 441         if (copy_from_user(kbuf, buf, min_t(unsigned long, BUFLEN - 1, count)))
 442                 GOTO(out, rc = -EFAULT);
 443         tmpbuf = skip_spaces(kbuf);
 444         tmpbuf = strsep(&tmpbuf, " \t\n\f\v\r");
 445
 446         if (strncmp(tmpbuf, "nid:", 4) != 0) {
 447                 count = lprocfs_evict_client_seq_write(file, buf, count, off);
 448                 goto out;
 449         }
 450
 451         if (mdt->mdt_opts.mo_evict_tgt_nids) {
 452                 rc = obd_set_info_async(NULL, mdt->mdt_child_exp,
 453                                         sizeof(KEY_EVICT_BY_NID),
 454                                         KEY_EVICT_BY_NID,
 455                                         strlen(tmpbuf + 4) + 1,
 456                                         tmpbuf + 4, NULL);
 457                 if (rc)
 458                         CERROR("Failed to evict nid %s from OSTs: rc %d\n",
 459                                tmpbuf + 4, rc);
 460         }
 461
 462         /* See the comments in function lprocfs_wr_evict_client()
 463          * in ptlrpc/lproc_ptlrpc.c for details. - jay */
 464         class_incref(obd, __func__, current);
 465         obd_export_evict_by_nid(obd, tmpbuf + 4);
 466         class_decref(obd, __func__, current);
 467
 468
 469 out:
 470         OBD_FREE(kbuf, BUFLEN);
 471         return rc < 0 ? rc : count;
 472 }
 473
 474 #undef BUFLEN
 475
 476 static ssize_t evict_tgt_nids_show(struct kobject *kobj,
 477                                    struct attribute *attr, char *buf)
 478 {
 479         struct obd_device *obd = container_of(kobj, struct obd_device,
 480                                               obd_kset.kobj);
 481         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 482
 483         return scnprintf(buf, PAGE_SIZE, "%u\n",
 484                          mdt->mdt_opts.mo_evict_tgt_nids);
 485 }
 486
 487 static ssize_t evict_tgt_nids_store(struct kobject *kobj,
 488                                     struct attribute *attr, const char *buffer,
 489                                     size_t count)
 490 {
 491         struct obd_device *obd = container_of(kobj, struct obd_device,
 492                                               obd_kset.kobj);
 493         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 494         bool val;
 495         int rc;
 496
 497         rc = kstrtobool(buffer, &val);
 498         if (rc)
 499                 return rc;
 500
 501         mdt->mdt_opts.mo_evict_tgt_nids = val;
 502         return count;
 503 }
 504 LUSTRE_RW_ATTR(evict_tgt_nids);
 505
 506 static ssize_t commit_on_sharing_show(struct kobject *kobj,
 507                                       struct attribute *attr, char *buf)
 508 {
 509         struct obd_device *obd = container_of(kobj, struct obd_device,
 510                                               obd_kset.kobj);
 511         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 512
 513         return scnprintf(buf, PAGE_SIZE, "%u\n", mdt_cos_is_enabled(mdt));
 514 }
 515
 516 static ssize_t commit_on_sharing_store(struct kobject *kobj,
 517                                        struct attribute *attr,
 518                                        const char *buffer, size_t count)
 519 {
 520         struct obd_device *obd = container_of(kobj, struct obd_device,
 521                                               obd_kset.kobj);
 522         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 523         bool val;
 524         int rc;
 525
 526         rc = kstrtobool(buffer, &val);
 527         if (rc)
 528                 return rc;
 529
 530         mdt_enable_cos(mdt, val);
 531         return count;
 532 }
 533 LUSTRE_RW_ATTR(commit_on_sharing);
 534
 535 static ssize_t local_recovery_show(struct kobject *kobj,
 536                                       struct attribute *attr, char *buf)
 537 {
 538         struct obd_device *obd = container_of(kobj, struct obd_device,
 539                                               obd_kset.kobj);
 540
 541         return scnprintf(buf, PAGE_SIZE, "%u\n",
 542                          obd->u.obt.obt_lut->lut_local_recovery);
 543 }
 544
 545 static ssize_t local_recovery_store(struct kobject *kobj,
 546                                        struct attribute *attr,
 547                                        const char *buffer, size_t count)
 548 {
 549         struct obd_device *obd = container_of(kobj, struct obd_device,
 550                                               obd_kset.kobj);
 551         bool val;
 552         int rc;
 553
 554         rc = kstrtobool(buffer, &val);
 555         if (rc)
 556                 return rc;
 557
 558         obd->u.obt.obt_lut->lut_local_recovery = !!val;
 559         return count;
 560 }
 561 LUSTRE_RW_ATTR(local_recovery);
 562
 563 static int mdt_root_squash_seq_show(struct seq_file *m, void *data)
 564 {
 565         struct obd_device *obd = m->private;
 566         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 567         struct root_squash_info *squash = &mdt->mdt_squash;
 568
 569         seq_printf(m, "%u:%u\n", squash->rsi_uid,
 570                    squash->rsi_gid);
 571         return 0;
 572 }
 573
 574 static ssize_t
 575 mdt_root_squash_seq_write(struct file *file, const char __user *buffer,
 576                           size_t count, loff_t *off)
 577 {
 578         struct seq_file   *m = file->private_data;
 579         struct obd_device *obd = m->private;
 580         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 581         struct root_squash_info *squash = &mdt->mdt_squash;
 582
 583         return lprocfs_wr_root_squash(buffer, count, squash,
 584                                       mdt_obd_name(mdt));
 585 }
 586 LPROC_SEQ_FOPS(mdt_root_squash);
 587
 588 static int mdt_nosquash_nids_seq_show(struct seq_file *m, void *data)
 589 {
 590         struct obd_device *obd = m->private;
 591         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 592         struct root_squash_info *squash = &mdt->mdt_squash;
 593         int len = 0;
 594
 595         spin_lock(&squash->rsi_lock);
 596         if (!list_empty(&squash->rsi_nosquash_nids)) {
 597                 len = cfs_print_nidlist(m->buf + m->count, m->size - m->count,
 598                                         &squash->rsi_nosquash_nids);
 599                 m->count += len;
 600                 seq_putc(m, '\n');
 601         } else
 602                 seq_puts(m, "NONE\n");
 603         spin_unlock(&squash->rsi_lock);
 604
 605         return 0;
 606 }
 607
 608 static ssize_t
 609 mdt_nosquash_nids_seq_write(struct file *file, const char __user *buffer,
 610                             size_t count, loff_t *off)
 611 {
 612         struct seq_file   *m = file->private_data;
 613         struct obd_device *obd = m->private;
 614         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 615         struct root_squash_info *squash = &mdt->mdt_squash;
 616
 617         return lprocfs_wr_nosquash_nids(buffer, count, squash,
 618                                         mdt_obd_name(mdt));
 619 }
 620 LPROC_SEQ_FOPS(mdt_nosquash_nids);
 621
 622 static ssize_t enable_remote_dir_show(struct kobject *kobj,
 623                                       struct attribute *attr, char *buf)
 624 {
 625         struct obd_device *obd = container_of(kobj, struct obd_device,
 626                                               obd_kset.kobj);
 627         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 628
 629         return scnprintf(buf, PAGE_SIZE, "%u\n", mdt->mdt_enable_remote_dir);
 630 }
 631
 632 static ssize_t enable_remote_dir_store(struct kobject *kobj,
 633                                        struct attribute *attr,
 634                                        const char *buffer, size_t count)
 635 {
 636         struct obd_device *obd = container_of(kobj, struct obd_device,
 637                                               obd_kset.kobj);
 638         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 639         bool val;
 640         int rc;
 641
 642         rc = kstrtobool(buffer, &val);
 643         if (rc)
 644                 return rc;
 645
 646         mdt->mdt_enable_remote_dir = val;
 647         return count;
 648 }
 649 LUSTRE_RW_ATTR(enable_remote_dir);
 650
 651 static ssize_t enable_remote_dir_gid_show(struct kobject *kobj,
 652                                           struct attribute *attr, char *buf)
 653 {
 654         struct obd_device *obd = container_of(kobj, struct obd_device,
 655                                               obd_kset.kobj);
 656         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 657
 658         return scnprintf(buf, PAGE_SIZE, "%d\n",
 659                          (int)mdt->mdt_enable_remote_dir_gid);
 660 }
 661
 662 static ssize_t enable_remote_dir_gid_store(struct kobject *kobj,
 663                                            struct attribute *attr,
 664                                            const char *buffer, size_t count)
 665 {
 666         struct obd_device *obd = container_of(kobj, struct obd_device,
 667                                               obd_kset.kobj);
 668         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 669         int val;
 670         int rc;
 671
 672         rc = kstrtoint(buffer, 0, &val);
 673         if (rc)
 674                 return rc;
 675
 676         mdt->mdt_enable_remote_dir_gid = val;
 677         return count;
 678 }
 679 LUSTRE_RW_ATTR(enable_remote_dir_gid);
 680
 681 static ssize_t enable_chprojid_gid_show(struct kobject *kobj,
 682                                         struct attribute *attr, char *buf)
 683 {
 684         struct obd_device *obd = container_of(kobj, struct obd_device,
 685                                               obd_kset.kobj);
 686         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 687
 688         return scnprintf(buf, PAGE_SIZE, "%d\n",
 689                          (int)mdt->mdt_enable_chprojid_gid);
 690 }
 691
 692 static ssize_t enable_chprojid_gid_store(struct kobject *kobj,
 693                                          struct attribute *attr,
 694                                          const char *buffer, size_t count)
 695 {
 696         struct obd_device *obd = container_of(kobj, struct obd_device,
 697                                               obd_kset.kobj);
 698         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 699         int val;
 700         int rc;
 701
 702         rc = kstrtoint(buffer, 0, &val);
 703         if (rc)
 704                 return rc;
 705
 706         mdt->mdt_enable_chprojid_gid = val;
 707         return count;
 708 }
 709 LUSTRE_RW_ATTR(enable_chprojid_gid);
 710
 711 static ssize_t enable_striped_dir_show(struct kobject *kobj,
 712                                        struct attribute *attr, char *buf)
 713 {
 714         struct obd_device *obd = container_of(kobj, struct obd_device,
 715                                               obd_kset.kobj);
 716         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 717
 718         return scnprintf(buf, PAGE_SIZE, "%u\n", mdt->mdt_enable_striped_dir);
 719 }
 720
 721 static ssize_t enable_striped_dir_store(struct kobject *kobj,
 722                                         struct attribute *attr,
 723                                         const char *buffer, size_t count)
 724 {
 725         struct obd_device *obd = container_of(kobj, struct obd_device,
 726                                               obd_kset.kobj);
 727         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 728         bool val;
 729         int rc;
 730
 731         rc = kstrtobool(buffer, &val);
 732         if (rc)
 733                 return rc;
 734
 735         mdt->mdt_enable_striped_dir = val;
 736         return count;
 737 }
 738 LUSTRE_RW_ATTR(enable_striped_dir);
 739
 740 static ssize_t enable_dir_migration_show(struct kobject *kobj,
 741                                          struct attribute *attr, char *buf)
 742 {
 743         struct obd_device *obd = container_of(kobj, struct obd_device,
 744                                               obd_kset.kobj);
 745         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 746
 747         return scnprintf(buf, PAGE_SIZE, "%u\n", mdt->mdt_enable_dir_migration);
 748 }
 749
 750 static ssize_t enable_dir_migration_store(struct kobject *kobj,
 751                                           struct attribute *attr,
 752                                           const char *buffer, size_t count)
 753 {
 754         struct obd_device *obd = container_of(kobj, struct obd_device,
 755                                               obd_kset.kobj);
 756         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 757         bool val;
 758         int rc;
 759
 760         rc = kstrtobool(buffer, &val);
 761         if (rc)
 762                 return rc;
 763
 764         mdt->mdt_enable_dir_migration = val;
 765         return count;
 766 }
 767 LUSTRE_RW_ATTR(enable_dir_migration);
 768
 769 static ssize_t enable_dir_restripe_show(struct kobject *kobj,
 770                                         struct attribute *attr, char *buf)
 771 {
 772         struct obd_device *obd = container_of(kobj, struct obd_device,
 773                                               obd_kset.kobj);
 774         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 775
 776         return scnprintf(buf, PAGE_SIZE, "%u\n", mdt->mdt_enable_dir_restripe);
 777 }
 778
 779 static ssize_t enable_dir_restripe_store(struct kobject *kobj,
 780                                          struct attribute *attr,
 781                                          const char *buffer, size_t count)
 782 {
 783         struct obd_device *obd = container_of(kobj, struct obd_device,
 784                                               obd_kset.kobj);
 785         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 786         bool val;
 787         int rc;
 788
 789         rc = kstrtobool(buffer, &val);
 790         if (rc)
 791                 return rc;
 792
 793         mdt->mdt_enable_dir_restripe = val;
 794         return count;
 795 }
 796 LUSTRE_RW_ATTR(enable_dir_restripe);
 797
 798 static ssize_t enable_dir_auto_split_show(struct kobject *kobj,
 799                                           struct attribute *attr, char *buf)
 800 {
 801         struct obd_device *obd = container_of(kobj, struct obd_device,
 802                                               obd_kset.kobj);
 803         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 804
 805         return scnprintf(buf, PAGE_SIZE, "%u\n",
 806                          mdt->mdt_enable_dir_auto_split);
 807 }
 808
 809 static ssize_t enable_dir_auto_split_store(struct kobject *kobj,
 810                                            struct attribute *attr,
 811                                            const char *buffer, size_t count)
 812 {
 813         struct obd_device *obd = container_of(kobj, struct obd_device,
 814                                               obd_kset.kobj);
 815         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 816         bool val;
 817         int rc;
 818
 819         rc = kstrtobool(buffer, &val);
 820         if (rc)
 821                 return rc;
 822
 823         mdt->mdt_enable_dir_auto_split = val;
 824         return count;
 825 }
 826 LUSTRE_RW_ATTR(enable_dir_auto_split);
 827
 828 /**
 829  * Show MDT async commit count.
 830  *
 831  * @m           seq_file handle
 832  * @data        unused for single entry
 833  *
 834  * Return:      0 on success
 835  *              negative value on error
 836  */
 837 static ssize_t async_commit_count_show(struct kobject *kobj,
 838                                        struct attribute *attr, char *buf)
 839 {
 840         struct obd_device *obd = container_of(kobj, struct obd_device,
 841                                               obd_kset.kobj);
 842         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 843
 844         return scnprintf(buf, PAGE_SIZE, "%d\n",
 845                          atomic_read(&mdt->mdt_async_commit_count));
 846 }
 847
 848 static ssize_t async_commit_count_store(struct kobject *kobj,
 849                                         struct attribute *attr,
 850                                         const char *buffer, size_t count)
 851 {
 852         struct obd_device *obd = container_of(kobj, struct obd_device,
 853                                               obd_kset.kobj);
 854         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 855         int val;
 856         int rc;
 857
 858         rc = kstrtoint(buffer, 10, &val);
 859         if (rc)
 860                 return rc;
 861
 862         atomic_set(&mdt->mdt_async_commit_count, val);
 863
 864         return count;
 865 }
 866 LUSTRE_RW_ATTR(async_commit_count);
 867
 868 /**
 869  * Show MDT sync count.
 870  *
 871  * \param[in] m         seq_file handle
 872  * \param[in] data      unused for single entry
 873  *
 874  * \retval              0 on success
 875  * \retval              negative value on error
 876  */
 877 static ssize_t sync_count_show(struct kobject *kobj, struct attribute *attr,
 878                                char *buf)
 879 {
 880         struct obd_device *obd = container_of(kobj, struct obd_device,
 881                                               obd_kset.kobj);
 882         struct lu_target *tgt = obd->u.obt.obt_lut;
 883
 884         return scnprintf(buf, PAGE_SIZE, "%d\n",
 885                          atomic_read(&tgt->lut_sync_count));
 886 }
 887
 888 static ssize_t sync_count_store(struct kobject *kobj, struct attribute *attr,
 889                                 const char *buffer, size_t count)
 890 {
 891         struct obd_device *obd = container_of(kobj, struct obd_device,
 892                                               obd_kset.kobj);
 893         struct lu_target *tgt = obd->u.obt.obt_lut;
 894         int val;
 895         int rc;
 896
 897         rc = kstrtoint(buffer, 0, &val);
 898         if (rc)
 899                 return rc;
 900
 901         atomic_set(&tgt->lut_sync_count, val);
 902
 903         return count;
 904 }
 905 LUSTRE_RW_ATTR(sync_count);
 906
 907 static const char *dom_open_lock_modes[NUM_DOM_LOCK_ON_OPEN_MODES] = {
 908         [NO_DOM_LOCK_ON_OPEN] = "never",
 909         [TRYLOCK_DOM_ON_OPEN] = "trylock",
 910         [ALWAYS_DOM_LOCK_ON_OPEN] = "always",
 911 };
 912
 913 /* This must be longer than the longest string above */
 914 #define DOM_LOCK_MODES_MAXLEN 16
 915
 916 /**
 917  * Show MDT policy for data prefetch on open for DoM files..
 918  *
 919  * \param[in] m         seq_file handle
 920  * \param[in] data      unused
 921  *
 922  * \retval              0 on success
 923  * \retval              negative value on error
 924  */
 925 static ssize_t dom_lock_show(struct kobject *kobj, struct attribute *attr,
 926                              char *buf)
 927 {
 928         struct obd_device *obd = container_of(kobj, struct obd_device,
 929                                               obd_kset.kobj);
 930         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 931
 932         return scnprintf(buf, PAGE_SIZE, "%s\n",
 933                          dom_open_lock_modes[mdt->mdt_opts.mo_dom_lock]);
 934 }
 935
 936 /**
 937  * Change MDT policy for data prefetch on open for DoM files.
 938  *
 939  * This variable defines how DOM lock is taken at open enqueue.
 940  * There are three possible modes:
 941  * 1) never - never take DoM lock on open. DoM lock will be taken as separate
 942  *    IO lock with own enqueue.
 943  * 2) trylock - DoM lock will be taken only if non-blocked.
 944  * 3) always - DoM lock will be taken always even if it is blocking lock.
 945  *
 946  * If dom_read_open is enabled too then DoM lock is taken in PR mode and
 947  * is paired with LAYOUT lock when possible.
 948  *
 949  * \param[in] file      proc file
 950  * \param[in] buffer    string which represents policy
 951  * \param[in] count     \a buffer length
 952  * \param[in] off       unused for single entry
 953  *
 954  * \retval              \a count on success
 955  * \retval              negative number on error
 956  */
 957 static ssize_t dom_lock_store(struct kobject *kobj, struct attribute *attr,
 958                               const char *buffer, size_t count)
 959 {
 960         struct obd_device *obd = container_of(kobj, struct obd_device,
 961                                               obd_kset.kobj);
 962         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 963         int val = -1;
 964         int i, rc;
 965
 966         if (count == 0 || count >= DOM_LOCK_MODES_MAXLEN)
 967                 return -EINVAL;
 968
 969         for (i = 0 ; i < NUM_DOM_LOCK_ON_OPEN_MODES; i++) {
 970                 /* buffer might have '\n' but using strlen() avoids it */
 971                 if (strncmp(buffer, dom_open_lock_modes[i],
 972                             strlen(dom_open_lock_modes[i])) == 0) {
 973                         val = i;
 974                         break;
 975                 }
 976         }
 977
 978         /* Legacy numeric codes */
 979         if (val == -1) {
 980                 rc = kstrtoint(buffer, 0, &val);
 981                 if (rc)
 982                         return rc;
 983         }
 984
 985         if (val == ALWAYS_DOM_LOCK_ON_OPEN)
 986                 val = TRYLOCK_DOM_ON_OPEN;
 987
 988         if (val < 0 || val >= NUM_DOM_LOCK_ON_OPEN_MODES)
 989                 return -EINVAL;
 990
 991         mdt->mdt_opts.mo_dom_lock = val;
 992         return count;
 993 }
 994 LUSTRE_RW_ATTR(dom_lock);
 995
 996 /**
 997  * Show MDT policy for data prefetch on open for DoM files..
 998  *
 999  * \param[in] m         seq_file handle
1000  * \param[in] data      unused
1001  *
1002  * \retval              0 on success
1003  * \retval              negative value on error
1004  */
1005 static ssize_t dom_read_open_show(struct kobject *kobj,
1006                                   struct attribute *attr, char *buf)
1007 {
1008         struct obd_device *obd = container_of(kobj, struct obd_device,
1009                                               obd_kset.kobj);
1010         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1011
1012         return scnprintf(buf, PAGE_SIZE, "%u\n",
1013                          !!mdt->mdt_opts.mo_dom_read_open);
1014 }
1015
1016 /**
1017  * Modify MDT policy for data prefetch on open for DoM files.
1018  *
1019  * If enabled then Data-on-MDT file data may be read during open and
1020  * returned back in reply. It works only with mo_dom_lock enabled.
1021  *
1022  * \param[in] file      proc file
1023  * \param[in] buffer    string which represents policy
1024  * \param[in] count     \a buffer length
1025  * \param[in] off       unused for single entry
1026  *
1027  * \retval              \a count on success
1028  * \retval              negative number on error
1029  */
1030 static ssize_t dom_read_open_store(struct kobject *kobj,
1031                                    struct attribute *attr, const char *buffer,
1032                                    size_t count)
1033 {
1034         struct obd_device *obd = container_of(kobj, struct obd_device,
1035                                               obd_kset.kobj);
1036         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1037         bool val;
1038         int rc;
1039
1040         rc = kstrtobool(buffer, &val);
1041         if (rc)
1042                 return rc;
1043
1044         mdt->mdt_opts.mo_dom_read_open = !!val;
1045         return count;
1046 }
1047 LUSTRE_RW_ATTR(dom_read_open);
1048
1049 /**
1050  * Show policy for using strict SOM information for real size (stat size).
1051  *
1052  * \param[in] m         seq_file handle
1053  * \param[in] data      unused
1054  *
1055  * \retval              0 on success
1056  * \retval              negative value on error
1057  */
1058 static ssize_t enable_strict_som_show(struct kobject *kobj,
1059                                       struct attribute *attr, char *buf)
1060 {
1061         struct obd_device *obd = container_of(kobj, struct obd_device,
1062                                               obd_kset.kobj);
1063         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1064
1065         return scnprintf(buf, PAGE_SIZE, "%u\n",
1066                          !!mdt->mdt_opts.mo_enable_strict_som);
1067 }
1068
1069 /**
1070  * Modify policy for using strict SOM information for real size (stat size).
1071  *
1072  * If disabled, SOM is never used for stat.
1073  *
1074  * \param[in] file      proc file
1075  * \param[in] buffer    string which represents policy
1076  * \param[in] count     \a buffer length
1077  * \param[in] off       unused for single entry
1078  *
1079  * \retval              \a count on success
1080  * \retval              negative number on error
1081  */
1082 static ssize_t enable_strict_som_store(struct kobject *kobj,
1083                                        struct attribute *attr,
1084                                        const char *buffer, size_t count)
1085 {
1086         struct obd_device *obd = container_of(kobj, struct obd_device,
1087                                               obd_kset.kobj);
1088         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1089         bool val;
1090         int rc;
1091
1092         rc = kstrtobool(buffer, &val);
1093         if (rc)
1094                 return rc;
1095
1096         mdt->mdt_opts.mo_enable_strict_som = !!val;
1097         return count;
1098 }
1099 LUSTRE_RW_ATTR(enable_strict_som);
1100
1101 static ssize_t migrate_hsm_allowed_show(struct kobject *kobj,
1102                                         struct attribute *attr, char *buf)
1103 {
1104         struct obd_device *obd = container_of(kobj, struct obd_device,
1105                                               obd_kset.kobj);
1106         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1107
1108         return scnprintf(buf, PAGE_SIZE, "%u\n",
1109                          mdt->mdt_opts.mo_migrate_hsm_allowed);
1110 }
1111
1112 static ssize_t migrate_hsm_allowed_store(struct kobject *kobj,
1113                                          struct attribute *attr,
1114                                          const char *buffer, size_t count)
1115 {
1116         struct obd_device *obd = container_of(kobj, struct obd_device,
1117                                               obd_kset.kobj);
1118         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1119         bool val;
1120         int rc;
1121
1122         rc = kstrtobool(buffer, &val);
1123         if (rc)
1124                 return rc;
1125
1126         mdt->mdt_opts.mo_migrate_hsm_allowed = val;
1127         return count;
1128 }
1129 LUSTRE_RW_ATTR(migrate_hsm_allowed);
1130
1131 static ssize_t readonly_show(struct kobject *kobj, struct attribute *attr,
1132                              char *buf)
1133 {
1134         struct obd_device *obd = container_of(kobj, struct obd_device,
1135                                               obd_kset.kobj);
1136         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1137
1138         return scnprintf(buf, PAGE_SIZE, "%u\n", mdt->mdt_readonly);
1139 }
1140
1141 static ssize_t readonly_store(struct kobject *kobj, struct attribute *attr,
1142                               const char *buffer, size_t count)
1143 {
1144         struct obd_device *obd = container_of(kobj, struct obd_device,
1145                                               obd_kset.kobj);
1146         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1147         bool val;
1148         int rc;
1149
1150         rc = kstrtobool(buffer, &val);
1151         if (rc)
1152                 return rc;
1153
1154         mdt->mdt_readonly = val;
1155         return count;
1156 }
1157 LUSTRE_RW_ATTR(readonly);
1158
1159 static ssize_t enable_remote_rename_show(struct kobject *kobj,
1160                                          struct attribute *attr,
1161                                          char *buf)
1162 {
1163         struct obd_device *obd = container_of(kobj, struct obd_device,
1164                                               obd_kset.kobj);
1165         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1166
1167         return scnprintf(buf, PAGE_SIZE, "%u\n",
1168                          mdt->mdt_enable_remote_rename);
1169 }
1170
1171 static ssize_t enable_remote_rename_store(struct kobject *kobj,
1172                                           struct attribute *attr,
1173                                           const char *buffer, size_t count)
1174 {
1175         struct obd_device *obd = container_of(kobj, struct obd_device,
1176                                               obd_kset.kobj);
1177         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1178         bool val;
1179         int rc;
1180
1181         rc = kstrtobool(buffer, &val);
1182         if (rc)
1183                 return rc;
1184
1185         mdt->mdt_enable_remote_rename = val;
1186         return count;
1187 }
1188 LUSTRE_RW_ATTR(enable_remote_rename);
1189
1190 static ssize_t dir_split_count_show(struct kobject *kobj,
1191                                      struct attribute *attr,
1192                                      char *buf)
1193 {
1194         struct obd_device *obd = container_of(kobj, struct obd_device,
1195                                               obd_kset.kobj);
1196         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1197
1198         return scnprintf(buf, PAGE_SIZE, "%llu\n",
1199                          mdt->mdt_restriper.mdr_dir_split_count);
1200 }
1201
1202 static ssize_t dir_split_count_store(struct kobject *kobj,
1203                                       struct attribute *attr,
1204                                       const char *buffer, size_t count)
1205 {
1206         struct obd_device *obd = container_of(kobj, struct obd_device,
1207                                               obd_kset.kobj);
1208         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1209         s64 val;
1210         int rc;
1211
1212         rc = sysfs_memparse(buffer, count, &val, "B");
1213         if (rc < 0)
1214                 return rc;
1215
1216         if (val < 0)
1217                 return -ERANGE;
1218
1219         mdt->mdt_restriper.mdr_dir_split_count = val;
1220
1221         return count;
1222 }
1223 LUSTRE_RW_ATTR(dir_split_count);
1224
1225 static ssize_t dir_split_delta_show(struct kobject *kobj,
1226                                     struct attribute *attr,
1227                                     char *buf)
1228 {
1229         struct obd_device *obd = container_of(kobj, struct obd_device,
1230                                               obd_kset.kobj);
1231         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1232
1233         return scnprintf(buf, PAGE_SIZE, "%u\n",
1234                          mdt->mdt_restriper.mdr_dir_split_delta);
1235 }
1236
1237 static ssize_t dir_split_delta_store(struct kobject *kobj,
1238                                      struct attribute *attr,
1239                                      const char *buffer, size_t count)
1240 {
1241         struct obd_device *obd = container_of(kobj, struct obd_device,
1242                                               obd_kset.kobj);
1243         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1244         u32 val;
1245         int rc;
1246
1247         rc = kstrtouint(buffer, 0, &val);
1248         if (rc)
1249                 return rc;
1250
1251         mdt->mdt_restriper.mdr_dir_split_delta = val;
1252
1253         return count;
1254 }
1255 LUSTRE_RW_ATTR(dir_split_delta);
1256
1257 static ssize_t dir_restripe_nsonly_show(struct kobject *kobj,
1258                                         struct attribute *attr, char *buf)
1259 {
1260         struct obd_device *obd = container_of(kobj, struct obd_device,
1261                                               obd_kset.kobj);
1262         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1263
1264         return scnprintf(buf, PAGE_SIZE, "%u\n", mdt->mdt_dir_restripe_nsonly);
1265 }
1266
1267 static ssize_t dir_restripe_nsonly_store(struct kobject *kobj,
1268                                          struct attribute *attr,
1269                                          const char *buffer, size_t count)
1270 {
1271         struct obd_device *obd = container_of(kobj, struct obd_device,
1272                                               obd_kset.kobj);
1273         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1274         bool val;
1275         int rc;
1276
1277         rc = kstrtobool(buffer, &val);
1278         if (rc)
1279                 return rc;
1280
1281         mdt->mdt_dir_restripe_nsonly = val;
1282         return count;
1283 }
1284 LUSTRE_RW_ATTR(dir_restripe_nsonly);
1285
1286 static ssize_t enable_remote_subdir_mount_show(struct kobject *kobj,
1287                                                struct attribute *attr,
1288                                                char *buf)
1289 {
1290         struct obd_device *obd = container_of(kobj, struct obd_device,
1291                                               obd_kset.kobj);
1292         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1293
1294         return scnprintf(buf, PAGE_SIZE, "%u\n",
1295                          mdt->mdt_enable_remote_subdir_mount);
1296 }
1297
1298 static ssize_t enable_remote_subdir_mount_store(struct kobject *kobj,
1299                                                 struct attribute *attr,
1300                                                 const char *buffer,
1301                                                 size_t count)
1302 {
1303         struct obd_device *obd = container_of(kobj, struct obd_device,
1304                                               obd_kset.kobj);
1305         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
1306         bool val;
1307         int rc;
1308
1309         rc = kstrtobool(buffer, &val);
1310         if (rc)
1311                 return rc;
1312
1313         mdt->mdt_enable_remote_subdir_mount = val;
1314         return count;
1315 }
1316 LUSTRE_RW_ATTR(enable_remote_subdir_mount);
1317
1318 /**
1319  * Show if the OFD enforces T10PI checksum.
1320  *
1321  * \param[in] m         seq_file handle
1322  * \param[in] data      unused for single entry
1323  *
1324  * \retval              0 on success
1325  * \retval              negative value on error
1326  */
1327 static ssize_t checksum_t10pi_enforce_show(struct kobject *kobj,
1328                                            struct attribute *attr,
1329                                            char *buf)
1330 {
1331         struct obd_device *obd = container_of(kobj, struct obd_device,
1332                                               obd_kset.kobj);
1333         struct lu_target *lut = obd->u.obt.obt_lut;
1334
1335         return scnprintf(buf, PAGE_SIZE, "%u\n", lut->lut_cksum_t10pi_enforce);
1336 }
1337
1338 /**
1339  * Force specific T10PI checksum modes to be enabled
1340  *
1341  * If T10PI *is* supported in hardware, allow only the supported T10PI type
1342  * to be used. If T10PI is *not* supported by the OSD, setting the enforce
1343  * parameter forces all T10PI types to be enabled (even if slower) for
1344  * testing.
1345  *
1346  * The final determination of which algorithm to be used depends whether
1347  * the client supports T10PI or not, and is handled at client connect time.
1348  *
1349  * \param[in] file      proc file
1350  * \param[in] buffer    string which represents mode
1351  *                      1: set T10PI checksums enforced
1352  *                      0: unset T10PI checksums enforced
1353  * \param[in] count     \a buffer length
1354  * \param[in] off       unused for single entry
1355  *
1356  * \retval              \a count on success
1357  * \retval              negative number on error
1358  */
1359 static ssize_t checksum_t10pi_enforce_store(struct kobject *kobj,
1360                                             struct attribute *attr,
1361                                             const char *buffer, size_t count)
1362 {
1363         struct obd_device *obd = container_of(kobj, struct obd_device,
1364                                               obd_kset.kobj);
1365         struct lu_target *lut = obd->u.obt.obt_lut;
1366         bool enforce;
1367         int rc;
1368
1369         rc = kstrtobool(buffer, &enforce);
1370         if (rc)
1371                 return rc;
1372
1373         spin_lock(&lut->lut_flags_lock);
1374         lut->lut_cksum_t10pi_enforce = enforce;
1375         spin_unlock(&lut->lut_flags_lock);
1376         return count;
1377 }
1378 LUSTRE_RW_ATTR(checksum_t10pi_enforce);
1379
1380 /*
1381  * mdt_checksum_type(server) proc handling
1382  */
1383 DECLARE_CKSUM_NAME;
1384
1385 static int mdt_checksum_type_seq_show(struct seq_file *m, void *data)
1386 {
1387         struct obd_device *obd = m->private;
1388         struct lu_target *lut;
1389         enum cksum_types pref;
1390         int i;
1391
1392         if (!obd)
1393                 return 0;
1394
1395         lut = obd->u.obt.obt_lut;
1396
1397         /* select fastest checksum type on the server */
1398         pref = obd_cksum_type_select(obd->obd_name,
1399                                      lut->lut_cksum_types_supported, 0);
1400
1401         for (i = 0; i < ARRAY_SIZE(cksum_name); i++) {
1402                 if ((BIT(i) & lut->lut_cksum_types_supported) == 0)
1403                         continue;
1404
1405                 if (pref == BIT(i))
1406                         seq_printf(m, "[%s] ", cksum_name[i]);
1407                 else
1408                         seq_printf(m, "%s ", cksum_name[i]);
1409         }
1410         seq_puts(m, "\n");
1411
1412         return 0;
1413 }
1414
1415 LPROC_SEQ_FOPS_RO(mdt_checksum_type);
1416
1417 LPROC_SEQ_FOPS_RO_TYPE(mdt, hash);
1418 LPROC_SEQ_FOPS_WR_ONLY(mdt, mds_evict_client);
1419 LPROC_SEQ_FOPS_RW_TYPE(mdt, checksum_dump);
1420 LUSTRE_RW_ATTR(job_cleanup_interval);
1421 LPROC_SEQ_FOPS_RW_TYPE(mdt, nid_stats_clear);
1422 LUSTRE_RW_ATTR(hsm_control);
1423
1424 LPROC_SEQ_FOPS_RO_TYPE(mdt, recovery_status);
1425 LUSTRE_RW_ATTR(recovery_time_hard);
1426 LUSTRE_RW_ATTR(recovery_time_soft);
1427 LUSTRE_RW_ATTR(ir_factor);
1428
1429 LUSTRE_RO_ATTR(tot_dirty);
1430 LUSTRE_RO_ATTR(tot_granted);
1431 LUSTRE_RO_ATTR(tot_pending);
1432 LUSTRE_RW_ATTR(grant_compat_disable);
1433 LUSTRE_RO_ATTR(instance);
1434
1435 LUSTRE_RO_ATTR(num_exports);
1436 LUSTRE_RW_ATTR(grant_check_threshold);
1437
1438 static struct attribute *mdt_attrs[] = {
1439         &lustre_attr_tot_dirty.attr,
1440         &lustre_attr_tot_granted.attr,
1441         &lustre_attr_tot_pending.attr,
1442         &lustre_attr_grant_compat_disable.attr,
1443         &lustre_attr_instance.attr,
1444         &lustre_attr_recovery_time_hard.attr,
1445         &lustre_attr_recovery_time_soft.attr,
1446         &lustre_attr_ir_factor.attr,
1447         &lustre_attr_num_exports.attr,
1448         &lustre_attr_grant_check_threshold.attr,
1449         &lustre_attr_identity_expire.attr,
1450         &lustre_attr_identity_acquire_expire.attr,
1451         &lustre_attr_identity_upcall.attr,
1452         &lustre_attr_identity_flush.attr,
1453         &lustre_attr_evict_tgt_nids.attr,
1454         &lustre_attr_enable_remote_dir.attr,
1455         &lustre_attr_enable_remote_dir_gid.attr,
1456         &lustre_attr_enable_chprojid_gid.attr,
1457         &lustre_attr_enable_striped_dir.attr,
1458         &lustre_attr_enable_dir_migration.attr,
1459         &lustre_attr_enable_dir_restripe.attr,
1460         &lustre_attr_enable_dir_auto_split.attr,
1461         &lustre_attr_enable_remote_rename.attr,
1462         &lustre_attr_commit_on_sharing.attr,
1463         &lustre_attr_local_recovery.attr,
1464         &lustre_attr_async_commit_count.attr,
1465         &lustre_attr_sync_count.attr,
1466         &lustre_attr_dom_lock.attr,
1467         &lustre_attr_dom_read_open.attr,
1468         &lustre_attr_enable_strict_som.attr,
1469         &lustre_attr_migrate_hsm_allowed.attr,
1470         &lustre_attr_hsm_control.attr,
1471         &lustre_attr_job_cleanup_interval.attr,
1472         &lustre_attr_readonly.attr,
1473         &lustre_attr_dir_split_count.attr,
1474         &lustre_attr_dir_split_delta.attr,
1475         &lustre_attr_dir_restripe_nsonly.attr,
1476         &lustre_attr_checksum_t10pi_enforce.attr,
1477         &lustre_attr_enable_remote_subdir_mount.attr,
1478         NULL,
1479 };
1480
1481 static struct lprocfs_vars lprocfs_mdt_obd_vars[] = {
1482         { .name =       "recovery_status",
1483           .fops =       &mdt_recovery_status_fops               },
1484         { .name =       "identity_info",
1485           .fops =       &mdt_identity_info_fops                 },
1486         { .name =       "site_stats",
1487           .fops =       &mdt_site_stats_fops                    },
1488         { .name =       "evict_client",
1489           .fops =       &mdt_mds_evict_client_fops              },
1490         { .name =       "checksum_dump",
1491           .fops =       &mdt_checksum_dump_fops                 },
1492         { .name =       "hash_stats",
1493           .fops =       &mdt_hash_fops                          },
1494         { .name =       "root_squash",
1495           .fops =       &mdt_root_squash_fops                   },
1496         { .name =       "nosquash_nids",
1497           .fops =       &mdt_nosquash_nids_fops                 },
1498         { .name =       "checksum_type",
1499           .fops =       &mdt_checksum_type_fops         },
1500         { NULL }
1501 };
1502
1503 static int
1504 lprocfs_mdt_print_open_files(struct obd_export *exp, void *v)
1505 {
1506         struct seq_file         *seq = v;
1507
1508         if (exp->exp_lock_hash != NULL) {
1509                 struct mdt_export_data  *med = &exp->exp_mdt_data;
1510                 struct mdt_file_data    *mfd;
1511
1512                 spin_lock(&med->med_open_lock);
1513                 list_for_each_entry(mfd, &med->med_open_head, mfd_list) {
1514                         seq_printf(seq, DFID"\n",
1515                                    PFID(mdt_object_fid(mfd->mfd_object)));
1516                 }
1517                 spin_unlock(&med->med_open_lock);
1518         }
1519
1520         return 0;
1521 }
1522
1523 static int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v)
1524 {
1525         struct nid_stat *stats = seq->private;
1526
1527         return obd_nid_export_for_each(stats->nid_obd, &stats->nid,
1528                                        lprocfs_mdt_print_open_files, seq);
1529 }
1530
1531 int lprocfs_mdt_open_files_seq_open(struct inode *inode, struct file *file)
1532 {
1533         struct seq_file         *seq;
1534         int                     rc;
1535
1536         rc = single_open(file, &lprocfs_mdt_open_files_seq_show, NULL);
1537         if (rc != 0)
1538                 return rc;
1539
1540         seq = file->private_data;
1541         seq->private = PDE_DATA(inode);
1542
1543         return 0;
1544 }
1545
1546 void mdt_counter_incr(struct ptlrpc_request *req, int opcode, long amount)
1547 {
1548         struct obd_export *exp = req->rq_export;
1549
1550         if (exp->exp_obd && exp->exp_obd->obd_md_stats)
1551                 lprocfs_counter_add(exp->exp_obd->obd_md_stats,
1552                                     opcode + LPROC_MD_LAST_OPC, amount);
1553         if (exp->exp_nid_stats && exp->exp_nid_stats->nid_stats != NULL)
1554                 lprocfs_counter_add(exp->exp_nid_stats->nid_stats, opcode,
1555                                     amount);
1556         if (exp->exp_obd && exp->exp_obd->u.obt.obt_jobstats.ojs_hash &&
1557             (exp_connect_flags(exp) & OBD_CONNECT_JOBSTATS))
1558                 lprocfs_job_stats_log(exp->exp_obd,
1559                                       lustre_msg_get_jobid(req->rq_reqmsg),
1560                                       opcode, amount);
1561 }
1562
1563 static const char * const mdt_stats[] = {
1564         [LPROC_MDT_OPEN]                = "open",
1565         [LPROC_MDT_CLOSE]               = "close",
1566         [LPROC_MDT_MKNOD]               = "mknod",
1567         [LPROC_MDT_LINK]                = "link",
1568         [LPROC_MDT_UNLINK]              = "unlink",
1569         [LPROC_MDT_MKDIR]               = "mkdir",
1570         [LPROC_MDT_RMDIR]               = "rmdir",
1571         [LPROC_MDT_RENAME]              = "rename",
1572         [LPROC_MDT_GETATTR]             = "getattr",
1573         [LPROC_MDT_SETATTR]             = "setattr",
1574         [LPROC_MDT_GETXATTR]            = "getxattr",
1575         [LPROC_MDT_SETXATTR]            = "setxattr",
1576         [LPROC_MDT_STATFS]              = "statfs",
1577         [LPROC_MDT_SYNC]                = "sync",
1578         [LPROC_MDT_SAMEDIR_RENAME]      = "samedir_rename",
1579         [LPROC_MDT_CROSSDIR_RENAME]     = "crossdir_rename",
1580         [LPROC_MDT_IO_READ_BYTES]       = "read_bytes",
1581         [LPROC_MDT_IO_WRITE_BYTES]      = "write_bytes",
1582         [LPROC_MDT_IO_READ]             = "read",
1583         [LPROC_MDT_IO_WRITE]            = "write",
1584         [LPROC_MDT_IO_PUNCH]            = "punch",
1585         [LPROC_MDT_MIGRATE]             = "migrate",
1586         [LPROC_MDT_FALLOCATE]           = "fallocate",
1587 };
1588
1589 void mdt_stats_counter_init(struct lprocfs_stats *stats, unsigned int offset)
1590 {
1591         int array_size = ARRAY_SIZE(mdt_stats);
1592         int oidx; /* obd_md_stats index */
1593         int midx; /* mdt_stats index */
1594
1595         LASSERT(stats && stats->ls_num >= offset + array_size);
1596
1597         for (midx = 0; midx < array_size; midx++) {
1598                 oidx = midx + offset;
1599                 if (midx == LPROC_MDT_IO_READ_BYTES ||
1600                     midx == LPROC_MDT_IO_WRITE_BYTES)
1601                         lprocfs_counter_init(stats, oidx,
1602                                              LPROCFS_TYPE_BYTES_FULL,
1603                                              mdt_stats[midx], "bytes");
1604                 else
1605                         lprocfs_counter_init(stats, oidx,
1606                                              LPROCFS_TYPE_LATENCY,
1607                                              mdt_stats[midx], "usecs");
1608         }
1609 }
1610
1611 int mdt_tunables_init(struct mdt_device *mdt, const char *name)
1612 {
1613         struct obd_device *obd = mdt2obd_dev(mdt);
1614         int rc;
1615
1616         ENTRY;
1617         LASSERT(name != NULL);
1618
1619         obd->obd_ktype.default_attrs = mdt_attrs;
1620         obd->obd_vars = lprocfs_mdt_obd_vars;
1621         rc = lprocfs_obd_setup(obd, true);
1622         if (rc) {
1623                 CERROR("%s: cannot create proc entries: rc = %d\n",
1624                        mdt_obd_name(mdt), rc);
1625                 return rc;
1626         }
1627
1628         rc = tgt_tunables_init(&mdt->mdt_lut);
1629         if (rc) {
1630                 CERROR("%s: failed to init target tunables: rc = %d\n",
1631                        mdt_obd_name(mdt), rc);
1632                 return rc;
1633         }
1634
1635         rc = hsm_cdt_tunables_init(mdt);
1636         if (rc) {
1637                 CERROR("%s: cannot create hsm proc entries: rc = %d\n",
1638                        mdt_obd_name(mdt), rc);
1639                 return rc;
1640         }
1641
1642         obd->obd_proc_exports_entry = proc_mkdir("exports",
1643                                                  obd->obd_proc_entry);
1644         if (obd->obd_proc_exports_entry)
1645                 lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
1646                                    obd, &mdt_nid_stats_clear_fops);
1647
1648         rc = lprocfs_alloc_md_stats(obd, ARRAY_SIZE(mdt_stats));
1649         if (rc)
1650                 return rc;
1651
1652         /* add additional MDT md_stats after the default ones */
1653         mdt_stats_counter_init(obd->obd_md_stats, LPROC_MD_LAST_OPC);
1654         rc = lprocfs_job_stats_init(obd, ARRAY_SIZE(mdt_stats),
1655                                     mdt_stats_counter_init);
1656
1657         rc = lproc_mdt_attach_rename_seqstat(mdt);
1658         if (rc)
1659                 CERROR("%s: MDT can not create rename stats rc = %d\n",
1660                        mdt_obd_name(mdt), rc);
1661
1662         RETURN(rc);
1663 }
1664
1665 void mdt_tunables_fini(struct mdt_device *mdt)
1666 {
1667         struct obd_device *obd = mdt2obd_dev(mdt);
1668
1669         if (obd->obd_proc_exports_entry != NULL) {
1670                 lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
1671                 obd->obd_proc_exports_entry = NULL;
1672         }
1673
1674         lprocfs_free_per_client_stats(obd);
1675         /* hsm_cdt_tunables is disabled earlier than this to avoid
1676          * coordinator restart.
1677          */
1678         hsm_cdt_tunables_fini(mdt);
1679         tgt_tunables_fini(&mdt->mdt_lut);
1680         lprocfs_obd_cleanup(obd);
1681         lprocfs_free_md_stats(obd);
1682         lprocfs_free_obd_stats(obd);
1683         lprocfs_job_stats_fini(obd);
1684 }