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, 2016, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/mdt/mdt_lproc.c
  33  *
  34  * Author: Lai Siyao <lsy@clusterfs.com>
  35  * Author: Fan Yong <fanyong@clusterfs.com>
  36  */
  37
  38 #define DEBUG_SUBSYSTEM S_MDS
  39
  40 #include <linux/version.h>
  41 #include <asm/statfs.h>
  42
  43 #include <linux/module.h>
  44 #include <lnet/nidstr.h>
  45 /* LUSTRE_VERSION_CODE */
  46 #include <lustre_ver.h>
  47 /*
  48  * struct OBD_{ALLOC,FREE}*()
  49  * MDT_FAIL_CHECK
  50  */
  51 #include <obd_support.h>
  52 /* struct obd_export */
  53 #include <lustre_export.h>
  54 /* struct obd_device */
  55 #include <obd.h>
  56 #include <obd_class.h>
  57 #include <lustre_mds.h>
  58 #include <lprocfs_status.h>
  59 #include "mdt_internal.h"
  60
  61 /**
  62  * The rename stats output would be YAML formats, like
  63  * rename_stats:
  64  * - snapshot_time: 1234567890.123456
  65  * - same_dir:
  66  *     4kB: { samples: 1230, pct: 33, cum_pct: 45 }
  67  *     8kB: { samples: 1242, pct: 33, cum_pct: 78 }
  68  *     16kB: { samples: 132, pct: 3, cum_pct: 81 }
  69  * - crossdir_src:
  70  *     4kB: { samples: 123, pct: 33, cum_pct: 45 }
  71  *     8kB: { samples: 124, pct: 33, cum_pct: 78 }
  72  *     16kB: { samples: 12, pct: 3, cum_pct: 81 }
  73  * - crossdir_tgt:
  74  *     4kB: { samples: 123, pct: 33, cum_pct: 45 }
  75  *     8kB: { samples: 124, pct: 33, cum_pct: 78 }
  76  *     16kB: { samples: 12, pct: 3, cum_pct: 81 }
  77  **/
  78
  79 #define pct(a, b) (b ? a * 100 / b : 0)
  80
  81 static void display_rename_stats(struct seq_file *seq, char *name,
  82                                  struct obd_histogram *hist)
  83 {
  84         unsigned long tot, t, cum = 0;
  85         int i;
  86
  87         tot = lprocfs_oh_sum(hist);
  88         if (tot > 0)
  89                 seq_printf(seq, "- %-15s\n", name);
  90         /* dir size start from 4K, start i from 10(2^10) here */
  91         for (i = 0; i < OBD_HIST_MAX; i++) {
  92                 t = 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: %3lu, cum_pct: %3lu }\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         struct timeval now;
 116
 117         /* this sampling races with updates */
 118         do_gettimeofday(&now);
 119         seq_printf(seq, "rename_stats:\n");
 120         seq_printf(seq, "- %-15s %lu.%lu\n", "snapshot_time:",
 121                    now.tv_sec, now.tv_usec);
 122
 123         display_rename_stats(seq, "same_dir",
 124                              &rename_stats->hist[RENAME_SAMEDIR_SIZE]);
 125         display_rename_stats(seq, "crossdir_src",
 126                              &rename_stats->hist[RENAME_CROSSDIR_SRC_SIZE]);
 127         display_rename_stats(seq, "crossdir_tgt",
 128                              &rename_stats->hist[RENAME_CROSSDIR_TGT_SIZE]);
 129 }
 130
 131 #undef pct
 132
 133 static int mdt_rename_stats_seq_show(struct seq_file *seq, void *v)
 134 {
 135         struct mdt_device *mdt = seq->private;
 136
 137         rename_stats_show(seq, &mdt->mdt_rename_stats);
 138
 139         return 0;
 140 }
 141
 142 static ssize_t
 143 mdt_rename_stats_seq_write(struct file *file, const char __user *buf,
 144                            size_t len, loff_t *off)
 145 {
 146         struct seq_file *seq = file->private_data;
 147         struct mdt_device *mdt = seq->private;
 148         int i;
 149
 150         for (i = 0; i < RENAME_LAST; i++)
 151                 lprocfs_oh_clear(&mdt->mdt_rename_stats.hist[i]);
 152
 153         return len;
 154 }
 155 LPROC_SEQ_FOPS(mdt_rename_stats);
 156
 157 static int lproc_mdt_attach_rename_seqstat(struct mdt_device *mdt)
 158 {
 159         int i;
 160
 161         for (i = 0; i < RENAME_LAST; i++)
 162                 spin_lock_init(&mdt->mdt_rename_stats.hist[i].oh_lock);
 163
 164         return lprocfs_obd_seq_create(mdt2obd_dev(mdt), "rename_stats", 0644,
 165                                       &mdt_rename_stats_fops, mdt);
 166 }
 167
 168 void mdt_rename_counter_tally(struct mdt_thread_info *info,
 169                               struct mdt_device *mdt,
 170                               struct ptlrpc_request *req,
 171                               struct mdt_object *src,
 172                               struct mdt_object *tgt)
 173 {
 174         struct md_attr *ma = &info->mti_attr;
 175         struct rename_stats *rstats = &mdt->mdt_rename_stats;
 176         int rc;
 177
 178         ma->ma_need = MA_INODE;
 179         ma->ma_valid = 0;
 180         rc = mo_attr_get(info->mti_env, mdt_object_child(src), ma);
 181         if (rc) {
 182                 CERROR("%s: "DFID" attr_get, rc = %d\n",
 183                        mdt_obd_name(mdt), PFID(mdt_object_fid(src)), rc);
 184                 return;
 185         }
 186
 187         if (src == tgt) {
 188                 mdt_counter_incr(req, LPROC_MDT_SAMEDIR_RENAME);
 189                 lprocfs_oh_tally_log2(&rstats->hist[RENAME_SAMEDIR_SIZE],
 190                                       (unsigned int)ma->ma_attr.la_size);
 191                 return;
 192         }
 193
 194         mdt_counter_incr(req, LPROC_MDT_CROSSDIR_RENAME);
 195         lprocfs_oh_tally_log2(&rstats->hist[RENAME_CROSSDIR_SRC_SIZE],
 196                               (unsigned int)ma->ma_attr.la_size);
 197
 198         ma->ma_need = MA_INODE;
 199         ma->ma_valid = 0;
 200         rc = mo_attr_get(info->mti_env, mdt_object_child(tgt), ma);
 201         if (rc) {
 202                 CERROR("%s: "DFID" attr_get, rc = %d\n",
 203                        mdt_obd_name(mdt), PFID(mdt_object_fid(tgt)), rc);
 204                 return;
 205         }
 206
 207         lprocfs_oh_tally_log2(&rstats->hist[RENAME_CROSSDIR_TGT_SIZE],
 208                               (unsigned int)ma->ma_attr.la_size);
 209 }
 210
 211 static int mdt_identity_expire_seq_show(struct seq_file *m, void *data)
 212 {
 213         struct obd_device *obd = m->private;
 214         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 215
 216         seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire);
 217         return 0;
 218 }
 219
 220 static ssize_t
 221 mdt_identity_expire_seq_write(struct file *file, const char __user *buffer,
 222                               size_t count, loff_t *off)
 223 {
 224         struct seq_file   *m = file->private_data;
 225         struct obd_device *obd = m->private;
 226         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 227         int rc;
 228         __s64 val;
 229
 230         rc = lprocfs_str_to_s64(buffer, count, &val);
 231         if (rc)
 232                 return rc;
 233         if (val < 0 || val > INT_MAX)
 234                 return -ERANGE;
 235
 236         mdt->mdt_identity_cache->uc_entry_expire = val;
 237
 238         return count;
 239 }
 240 LPROC_SEQ_FOPS(mdt_identity_expire);
 241
 242 static int mdt_identity_acquire_expire_seq_show(struct seq_file *m, void *data)
 243 {
 244         struct obd_device *obd = m->private;
 245         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 246
 247         seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire);
 248         return 0;
 249 }
 250
 251 static ssize_t
 252 mdt_identity_acquire_expire_seq_write(struct file *file,
 253                                       const char __user *buffer,
 254                                       size_t count, loff_t *off)
 255 {
 256         struct seq_file   *m = file->private_data;
 257         struct obd_device *obd = m->private;
 258         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 259         int rc;
 260         __s64 val;
 261
 262         rc = lprocfs_str_to_s64(buffer, count, &val);
 263         if (rc)
 264                 return rc;
 265         if (val < 0 || val > INT_MAX)
 266                 return -ERANGE;
 267
 268         mdt->mdt_identity_cache->uc_acquire_expire = val;
 269
 270         return count;
 271 }
 272 LPROC_SEQ_FOPS(mdt_identity_acquire_expire);
 273
 274 static int mdt_identity_upcall_seq_show(struct seq_file *m, void *data)
 275 {
 276         struct obd_device *obd = m->private;
 277         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 278         struct upcall_cache *hash = mdt->mdt_identity_cache;
 279
 280         down_read(&hash->uc_upcall_rwsem);
 281         seq_printf(m, "%s\n", hash->uc_upcall);
 282         up_read(&hash->uc_upcall_rwsem);
 283         return 0;
 284 }
 285
 286 static ssize_t
 287 mdt_identity_upcall_seq_write(struct file *file, const char __user *buffer,
 288                               size_t count, loff_t *off)
 289 {
 290         struct seq_file         *m = file->private_data;
 291         struct obd_device       *obd = m->private;
 292         struct mdt_device       *mdt = mdt_dev(obd->obd_lu_dev);
 293         struct upcall_cache     *hash = mdt->mdt_identity_cache;
 294         int                      rc;
 295         char                    *kernbuf;
 296
 297         if (count >= UC_CACHE_UPCALL_MAXPATH) {
 298                 CERROR("%s: identity upcall too long\n", mdt_obd_name(mdt));
 299                 return -EINVAL;
 300         }
 301         OBD_ALLOC(kernbuf, count + 1);
 302         if (kernbuf == NULL)
 303                 GOTO(failed, rc = -ENOMEM);
 304         if (copy_from_user(kernbuf, buffer, count))
 305                 GOTO(failed, rc = -EFAULT);
 306
 307         /* Remove any extraneous bits from the upcall (e.g. linefeeds) */
 308         down_write(&hash->uc_upcall_rwsem);
 309         sscanf(kernbuf, "%s", hash->uc_upcall);
 310         up_write(&hash->uc_upcall_rwsem);
 311
 312         if (strcmp(hash->uc_name, mdt_obd_name(mdt)) != 0)
 313                 CWARN("%s: write to upcall name %s\n",
 314                       mdt_obd_name(mdt), hash->uc_upcall);
 315
 316         if (strcmp(hash->uc_upcall, "NONE") == 0 && mdt->mdt_opts.mo_acl)
 317                 CWARN("%s: disable \"identity_upcall\" with ACL enabled maybe "
 318                       "cause unexpected \"EACCESS\"\n", mdt_obd_name(mdt));
 319
 320         CDEBUG(D_CONFIG, "%s: identity upcall set to %s\n", mdt_obd_name(mdt),
 321                hash->uc_upcall);
 322         OBD_FREE(kernbuf, count + 1);
 323         RETURN(count);
 324
 325  failed:
 326         if (kernbuf)
 327                 OBD_FREE(kernbuf, count + 1);
 328         RETURN(rc);
 329 }
 330 LPROC_SEQ_FOPS(mdt_identity_upcall);
 331
 332 static ssize_t
 333 lprocfs_identity_flush_seq_write(struct file *file, const char __user *buffer,
 334                                  size_t count, void *data)
 335 {
 336         struct seq_file   *m = file->private_data;
 337         struct obd_device *obd = m->private;
 338         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 339         int rc;
 340         __s64 uid;
 341
 342         rc = lprocfs_str_to_s64(buffer, count, &uid);
 343         if (rc)
 344                 return rc;
 345         if (uid < INT_MIN || uid > INT_MAX)
 346                 return -ERANGE;
 347
 348         mdt_flush_identity(mdt->mdt_identity_cache, uid);
 349         return count;
 350 }
 351 LPROC_SEQ_FOPS_WO_TYPE(mdt, identity_flush);
 352
 353 static ssize_t
 354 lprocfs_identity_info_seq_write(struct file *file, const char __user *buffer,
 355                                 size_t count, void *data)
 356 {
 357         struct seq_file   *m = file->private_data;
 358         struct obd_device *obd = m->private;
 359         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 360         struct identity_downcall_data *param;
 361         int size = sizeof(*param), rc, checked = 0;
 362
 363 again:
 364         if (count < size) {
 365                 CERROR("%s: invalid data count = %lu, size = %d\n",
 366                        mdt_obd_name(mdt), (unsigned long) count, size);
 367                 return -EINVAL;
 368         }
 369
 370         OBD_ALLOC(param, size);
 371         if (param == NULL)
 372                 return -ENOMEM;
 373
 374         if (copy_from_user(param, buffer, size)) {
 375                 CERROR("%s: bad identity data\n", mdt_obd_name(mdt));
 376                 GOTO(out, rc = -EFAULT);
 377         }
 378
 379         if (checked == 0) {
 380                 checked = 1;
 381                 if (param->idd_magic != IDENTITY_DOWNCALL_MAGIC) {
 382                         CERROR("%s: MDS identity downcall bad params\n",
 383                                mdt_obd_name(mdt));
 384                         GOTO(out, rc = -EINVAL);
 385                 }
 386
 387                 if (param->idd_nperms > N_PERMS_MAX) {
 388                         CERROR("%s: perm count %d more than maximum %d\n",
 389                                mdt_obd_name(mdt), param->idd_nperms,
 390                                N_PERMS_MAX);
 391                         GOTO(out, rc = -EINVAL);
 392                 }
 393
 394                 if (param->idd_ngroups > NGROUPS_MAX) {
 395                         CERROR("%s: group count %d more than maximum %d\n",
 396                                mdt_obd_name(mdt), param->idd_ngroups,
 397                                NGROUPS_MAX);
 398                         GOTO(out, rc = -EINVAL);
 399                 }
 400
 401                 if (param->idd_ngroups) {
 402                         rc = param->idd_ngroups; /* save idd_ngroups */
 403                         OBD_FREE(param, size);
 404                         size = offsetof(struct identity_downcall_data,
 405                                         idd_groups[rc]);
 406                         goto again;
 407                 }
 408         }
 409
 410         rc = upcall_cache_downcall(mdt->mdt_identity_cache, param->idd_err,
 411                                    param->idd_uid, param);
 412
 413 out:
 414         if (param != NULL)
 415                 OBD_FREE(param, size);
 416
 417         return rc ? rc : count;
 418 }
 419 LPROC_SEQ_FOPS_WO_TYPE(mdt, identity_info);
 420
 421 static int mdt_site_stats_seq_show(struct seq_file *m, void *data)
 422 {
 423         struct obd_device *obd = m->private;
 424         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 425
 426         return lu_site_stats_seq_print(mdt_lu_site(mdt), m);
 427 }
 428 LPROC_SEQ_FOPS_RO(mdt_site_stats);
 429
 430 #define BUFLEN (UUID_MAX + 4)
 431
 432 static ssize_t
 433 lprocfs_mds_evict_client_seq_write(struct file *file, const char __user *buf,
 434                                    size_t count, loff_t *off)
 435 {
 436         struct seq_file   *m = file->private_data;
 437         struct obd_device *obd = m->private;
 438         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 439         char *kbuf;
 440         char *tmpbuf;
 441         int rc = 0;
 442
 443         OBD_ALLOC(kbuf, BUFLEN);
 444         if (kbuf == NULL)
 445                 return -ENOMEM;
 446
 447         /*
 448          * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1
 449          * bytes into kbuf, to ensure that the string is NUL-terminated.
 450          * UUID_MAX should include a trailing NUL already.
 451          */
 452         if (copy_from_user(kbuf, buf, min_t(unsigned long, BUFLEN - 1, count)))
 453                 GOTO(out, rc = -EFAULT);
 454         tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count));
 455
 456         if (strncmp(tmpbuf, "nid:", 4) != 0) {
 457                 count = lprocfs_evict_client_seq_write(file, buf, count, off);
 458                 goto out;
 459         }
 460
 461         if (mdt->mdt_opts.mo_evict_tgt_nids) {
 462                 rc = obd_set_info_async(NULL, mdt->mdt_child_exp,
 463                                         sizeof(KEY_EVICT_BY_NID),
 464                                         KEY_EVICT_BY_NID,
 465                                         strlen(tmpbuf + 4) + 1,
 466                                         tmpbuf + 4, NULL);
 467                 if (rc)
 468                         CERROR("Failed to evict nid %s from OSTs: rc %d\n",
 469                                tmpbuf + 4, rc);
 470         }
 471
 472         /* See the comments in function lprocfs_wr_evict_client()
 473          * in ptlrpc/lproc_ptlrpc.c for details. - jay */
 474         class_incref(obd, __func__, current);
 475         obd_export_evict_by_nid(obd, tmpbuf + 4);
 476         class_decref(obd, __func__, current);
 477
 478
 479 out:
 480         OBD_FREE(kbuf, BUFLEN);
 481         return rc < 0 ? rc : count;
 482 }
 483
 484 #undef BUFLEN
 485
 486 static int mdt_evict_tgt_nids_seq_show(struct seq_file *m, void *data)
 487 {
 488         struct obd_device *obd = m->private;
 489         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 490
 491         seq_printf(m, "%u\n", mdt->mdt_opts.mo_evict_tgt_nids);
 492         return 0;
 493 }
 494
 495 static ssize_t
 496 mdt_evict_tgt_nids_seq_write(struct file *file, const char __user *buffer,
 497                                size_t count, loff_t *off)
 498 {
 499         struct seq_file   *m = file->private_data;
 500         struct obd_device *obd = m->private;
 501         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 502         __s64 val;
 503         int rc;
 504
 505         rc = lprocfs_str_to_s64(buffer, count, &val);
 506         if (rc)
 507                 return rc;
 508         mdt->mdt_opts.mo_evict_tgt_nids = !!val;
 509         return count;
 510 }
 511 LPROC_SEQ_FOPS(mdt_evict_tgt_nids);
 512
 513 static int mdt_cos_seq_show(struct seq_file *m, void *data)
 514 {
 515         struct obd_device *obd = m->private;
 516         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 517
 518         seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt));
 519         return 0;
 520 }
 521
 522 static ssize_t
 523 mdt_cos_seq_write(struct file *file, const char __user *buffer,
 524                   size_t count, loff_t *off)
 525 {
 526         struct seq_file   *m = file->private_data;
 527         struct obd_device *obd = m->private;
 528         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 529         int rc;
 530         __s64 val;
 531
 532         rc = lprocfs_str_to_s64(buffer, count, &val);
 533         if (rc)
 534                 return rc;
 535         if (val < INT_MIN || val > INT_MAX)
 536                 return -ERANGE;
 537
 538         mdt_enable_cos(mdt, val);
 539         return count;
 540 }
 541 LPROC_SEQ_FOPS(mdt_cos);
 542
 543 static int mdt_root_squash_seq_show(struct seq_file *m, void *data)
 544 {
 545         struct obd_device *obd = m->private;
 546         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 547         struct root_squash_info *squash = &mdt->mdt_squash;
 548
 549         seq_printf(m, "%u:%u\n", squash->rsi_uid,
 550                    squash->rsi_gid);
 551         return 0;
 552 }
 553
 554 static ssize_t
 555 mdt_root_squash_seq_write(struct file *file, const char __user *buffer,
 556                           size_t count, loff_t *off)
 557 {
 558         struct seq_file   *m = file->private_data;
 559         struct obd_device *obd = m->private;
 560         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 561         struct root_squash_info *squash = &mdt->mdt_squash;
 562
 563         return lprocfs_wr_root_squash(buffer, count, squash,
 564                                       mdt_obd_name(mdt));
 565 }
 566 LPROC_SEQ_FOPS(mdt_root_squash);
 567
 568 static int mdt_nosquash_nids_seq_show(struct seq_file *m, void *data)
 569 {
 570         struct obd_device *obd = m->private;
 571         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 572         struct root_squash_info *squash = &mdt->mdt_squash;
 573         int len = 0;
 574
 575         down_read(&squash->rsi_sem);
 576         if (!list_empty(&squash->rsi_nosquash_nids)) {
 577                 len = cfs_print_nidlist(m->buf + m->count, m->size - m->count,
 578                                         &squash->rsi_nosquash_nids);
 579                 m->count += len;
 580                 seq_putc(m, '\n');
 581         } else
 582                 seq_puts(m, "NONE\n");
 583         up_read(&squash->rsi_sem);
 584
 585         return 0;
 586 }
 587
 588 static ssize_t
 589 mdt_nosquash_nids_seq_write(struct file *file, const char __user *buffer,
 590                             size_t count, loff_t *off)
 591 {
 592         struct seq_file   *m = file->private_data;
 593         struct obd_device *obd = m->private;
 594         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 595         struct root_squash_info *squash = &mdt->mdt_squash;
 596
 597         return lprocfs_wr_nosquash_nids(buffer, count, squash,
 598                                         mdt_obd_name(mdt));
 599 }
 600 LPROC_SEQ_FOPS(mdt_nosquash_nids);
 601
 602 static int mdt_enable_remote_dir_seq_show(struct seq_file *m, void *data)
 603 {
 604         struct obd_device *obd = m->private;
 605         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 606
 607         seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir);
 608         return 0;
 609 }
 610
 611 static ssize_t
 612 mdt_enable_remote_dir_seq_write(struct file *file, const char __user *buffer,
 613                                 size_t count, loff_t *off)
 614 {
 615         struct seq_file   *m = file->private_data;
 616         struct obd_device *obd = m->private;
 617         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 618         __s64 val;
 619         int rc;
 620
 621         rc = lprocfs_str_to_s64(buffer, count, &val);
 622         if (rc)
 623                 return rc;
 624
 625         if (val > 1 || val < 0)
 626                 return -ERANGE;
 627
 628         mdt->mdt_enable_remote_dir = val;
 629         return count;
 630 }
 631 LPROC_SEQ_FOPS(mdt_enable_remote_dir);
 632
 633 static int mdt_enable_remote_dir_gid_seq_show(struct seq_file *m, void *data)
 634 {
 635         struct obd_device *obd = m->private;
 636         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 637
 638         seq_printf(m, "%d\n",
 639                   (int)mdt->mdt_enable_remote_dir_gid);
 640         return 0;
 641 }
 642
 643 static ssize_t
 644 mdt_enable_remote_dir_gid_seq_write(struct file *file,
 645                                     const char __user *buffer,
 646                                     size_t count, loff_t *off)
 647 {
 648         struct seq_file   *m = file->private_data;
 649         struct obd_device *obd = m->private;
 650         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 651         __s64 val;
 652         int rc;
 653
 654         rc = lprocfs_str_to_s64(buffer, count, &val);
 655         if (rc)
 656                 return rc;
 657
 658         mdt->mdt_enable_remote_dir_gid = val;
 659         return count;
 660 }
 661 LPROC_SEQ_FOPS(mdt_enable_remote_dir_gid);
 662
 663 /**
 664  * Show MDT policy for handling dirty metadata under a lock being cancelled.
 665  *
 666  * \param[in] m         seq_file handle
 667  * \param[in] data      unused for single entry
 668  *
 669  * \retval              0 on success
 670  * \retval              negative value on error
 671  */
 672 static int mdt_slc_seq_show(struct seq_file *m, void *data)
 673 {
 674         struct obd_device *obd = m->private;
 675         struct lu_target *tgt = obd->u.obt.obt_lut;
 676         char *slc_states[] = {"never", "blocking", "always" };
 677
 678         seq_printf(m, "%s\n", slc_states[tgt->lut_sync_lock_cancel]);
 679         return 0;
 680 }
 681 LPROC_SEQ_FOPS_RO(mdt_slc);
 682
 683 /**
 684  * Show MDT async commit count.
 685  *
 686  * \param[in] m         seq_file handle
 687  * \param[in] data      unused for single entry
 688  *
 689  * \retval              0 on success
 690  * \retval              negative value on error
 691  */
 692 static int mdt_async_commit_count_seq_show(struct seq_file *m, void *data)
 693 {
 694         struct obd_device *obd = m->private;
 695         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 696
 697         seq_printf(m, "%d\n", atomic_read(&mdt->mdt_async_commit_count));
 698         return 0;
 699 }
 700
 701 static ssize_t
 702 mdt_async_commit_count_seq_write(struct file *file, const char __user *buffer,
 703                                  size_t count, loff_t *off)
 704 {
 705         struct seq_file *m = file->private_data;
 706         struct obd_device *obd = m->private;
 707         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 708         __s64 val;
 709         int rc;
 710
 711         rc = lprocfs_str_to_s64(buffer, count, &val);
 712         if (rc)
 713                 return rc;
 714
 715         if (val < INT_MIN || val > INT_MAX)
 716                 return -ERANGE;
 717
 718         atomic_set(&mdt->mdt_async_commit_count, val);
 719
 720         return count;
 721 }
 722 LPROC_SEQ_FOPS(mdt_async_commit_count);
 723
 724 /**
 725  * Show MDT sync count.
 726  *
 727  * \param[in] m         seq_file handle
 728  * \param[in] data      unused for single entry
 729  *
 730  * \retval              0 on success
 731  * \retval              negative value on error
 732  */
 733 static int mdt_sync_count_seq_show(struct seq_file *m, void *data)
 734 {
 735         struct obd_device *obd = m->private;
 736         struct lu_target *tgt = obd->u.obt.obt_lut;
 737
 738         seq_printf(m, "%d\n", atomic_read(&tgt->lut_sync_count));
 739         return 0;
 740 }
 741
 742 static ssize_t
 743 mdt_sync_count_seq_write(struct file *file, const char __user *buffer,
 744                          size_t count, loff_t *off)
 745 {
 746         struct seq_file *m = file->private_data;
 747         struct obd_device *obd = m->private;
 748         struct lu_target *tgt = obd->u.obt.obt_lut;
 749         __s64 val;
 750         int rc;
 751
 752         rc = lprocfs_str_to_s64(buffer, count, &val);
 753         if (rc)
 754                 return rc;
 755
 756         if (val < INT_MIN || val > INT_MAX)
 757                 return -ERANGE;
 758
 759         atomic_set(&tgt->lut_sync_count, val);
 760
 761         return count;
 762 }
 763 LPROC_SEQ_FOPS(mdt_sync_count);
 764
 765
 766 LPROC_SEQ_FOPS_RO_TYPE(mdt, uuid);
 767 LPROC_SEQ_FOPS_RO_TYPE(mdt, recovery_status);
 768 LPROC_SEQ_FOPS_RO_TYPE(mdt, num_exports);
 769 LPROC_SEQ_FOPS_RO_TYPE(mdt, target_instance);
 770 LPROC_SEQ_FOPS_RO_TYPE(mdt, hash);
 771 LPROC_SEQ_FOPS_WO_TYPE(mdt, mds_evict_client);
 772 LPROC_SEQ_FOPS_RW_TYPE(mdt, job_interval);
 773 LPROC_SEQ_FOPS_RW_TYPE(mdt, ir_factor);
 774 LPROC_SEQ_FOPS_RW_TYPE(mdt, nid_stats_clear);
 775 LPROC_SEQ_FOPS(mdt_hsm_cdt_control);
 776
 777 LPROC_SEQ_FOPS_RW_TYPE(mdt, recovery_time_hard);
 778 LPROC_SEQ_FOPS_RW_TYPE(mdt, recovery_time_soft);
 779
 780 static struct lprocfs_vars lprocfs_mdt_obd_vars[] = {
 781         { .name =       "uuid",
 782           .fops =       &mdt_uuid_fops                          },
 783         { .name =       "recovery_status",
 784           .fops =       &mdt_recovery_status_fops               },
 785         { .name =       "num_exports",
 786           .fops =       &mdt_num_exports_fops                   },
 787         { .name =       "identity_expire",
 788           .fops =       &mdt_identity_expire_fops               },
 789         { .name =       "identity_acquire_expire",
 790           .fops =       &mdt_identity_acquire_expire_fops       },
 791         { .name =       "identity_upcall",
 792           .fops =       &mdt_identity_upcall_fops               },
 793         { .name =       "identity_flush",
 794           .fops =       &mdt_identity_flush_fops                },
 795         { .name =       "identity_info",
 796           .fops =       &mdt_identity_info_fops                 },
 797         { .name =       "site_stats",
 798           .fops =       &mdt_site_stats_fops                    },
 799         { .name =       "evict_client",
 800           .fops =       &mdt_mds_evict_client_fops              },
 801         { .name =       "evict_tgt_nids",
 802           .fops =       &mdt_evict_tgt_nids_fops                },
 803         { .name =       "hash_stats",
 804           .fops =       &mdt_hash_fops                          },
 805         { .name =       "commit_on_sharing",
 806           .fops =       &mdt_cos_fops                           },
 807         { .name =       "root_squash",
 808           .fops =       &mdt_root_squash_fops                   },
 809         { .name =       "nosquash_nids",
 810           .fops =       &mdt_nosquash_nids_fops                 },
 811         { .name =       "instance",
 812           .fops =       &mdt_target_instance_fops               },
 813         { .name =       "ir_factor",
 814           .fops =       &mdt_ir_factor_fops                     },
 815         { .name =       "job_cleanup_interval",
 816           .fops =       &mdt_job_interval_fops                  },
 817         { .name =       "enable_remote_dir",
 818           .fops =       &mdt_enable_remote_dir_fops             },
 819         { .name =       "enable_remote_dir_gid",
 820           .fops =       &mdt_enable_remote_dir_gid_fops         },
 821         { .name =       "hsm_control",
 822           .fops =       &mdt_hsm_cdt_control_fops               },
 823         { .name =       "recovery_time_hard",
 824           .fops =       &mdt_recovery_time_hard_fops    },
 825         { .name =       "recovery_time_soft",
 826           .fops =       &mdt_recovery_time_soft_fops    },
 827         { .name =       "sync_lock_cancel",
 828           .fops =       &mdt_slc_fops                           },
 829         { .name =       "async_commit_count",
 830           .fops =       &mdt_async_commit_count_fops            },
 831         { .name =       "sync_count",
 832           .fops =       &mdt_sync_count_fops                    },
 833         { NULL }
 834 };
 835
 836 static int
 837 lprocfs_mdt_print_open_files(struct cfs_hash *hs, struct cfs_hash_bd *bd,
 838                              struct hlist_node *hnode, void *v)
 839 {
 840         struct obd_export       *exp = cfs_hash_object(hs, hnode);
 841         struct seq_file         *seq = v;
 842
 843         if (exp->exp_lock_hash != NULL) {
 844                 struct mdt_export_data  *med = &exp->exp_mdt_data;
 845                 struct mdt_file_data    *mfd;
 846
 847                 spin_lock(&med->med_open_lock);
 848                 list_for_each_entry(mfd, &med->med_open_head, mfd_list) {
 849                         seq_printf(seq, DFID"\n",
 850                                    PFID(mdt_object_fid(mfd->mfd_object)));
 851                 }
 852                 spin_unlock(&med->med_open_lock);
 853         }
 854
 855         return 0;
 856 }
 857
 858 static int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v)
 859 {
 860         struct nid_stat *stats = seq->private;
 861         struct obd_device *obd = stats->nid_obd;
 862
 863         cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
 864                               lprocfs_mdt_print_open_files, seq);
 865
 866         return 0;
 867 }
 868
 869 int lprocfs_mdt_open_files_seq_open(struct inode *inode, struct file *file)
 870 {
 871         struct seq_file         *seq;
 872         int                     rc;
 873
 874         rc = single_open(file, &lprocfs_mdt_open_files_seq_show, NULL);
 875         if (rc != 0)
 876                 return rc;
 877
 878         seq = file->private_data;
 879         seq->private = PDE_DATA(inode);
 880
 881         return 0;
 882 }
 883
 884 void mdt_counter_incr(struct ptlrpc_request *req, int opcode)
 885 {
 886         struct obd_export *exp = req->rq_export;
 887
 888         if (exp->exp_obd && exp->exp_obd->obd_md_stats)
 889                 lprocfs_counter_incr(exp->exp_obd->obd_md_stats, opcode);
 890         if (exp->exp_nid_stats && exp->exp_nid_stats->nid_stats != NULL)
 891                 lprocfs_counter_incr(exp->exp_nid_stats->nid_stats, opcode);
 892         if (exp->exp_obd && exp->exp_obd->u.obt.obt_jobstats.ojs_hash &&
 893             (exp_connect_flags(exp) & OBD_CONNECT_JOBSTATS))
 894                 lprocfs_job_stats_log(exp->exp_obd,
 895                                       lustre_msg_get_jobid(req->rq_reqmsg),
 896                                       opcode, 1);
 897 }
 898
 899 void mdt_stats_counter_init(struct lprocfs_stats *stats)
 900 {
 901         lprocfs_counter_init(stats, LPROC_MDT_OPEN, 0, "open", "reqs");
 902         lprocfs_counter_init(stats, LPROC_MDT_CLOSE, 0, "close", "reqs");
 903         lprocfs_counter_init(stats, LPROC_MDT_MKNOD, 0, "mknod", "reqs");
 904         lprocfs_counter_init(stats, LPROC_MDT_LINK, 0, "link", "reqs");
 905         lprocfs_counter_init(stats, LPROC_MDT_UNLINK, 0, "unlink", "reqs");
 906         lprocfs_counter_init(stats, LPROC_MDT_MKDIR, 0, "mkdir", "reqs");
 907         lprocfs_counter_init(stats, LPROC_MDT_RMDIR, 0, "rmdir", "reqs");
 908         lprocfs_counter_init(stats, LPROC_MDT_RENAME, 0, "rename", "reqs");
 909         lprocfs_counter_init(stats, LPROC_MDT_GETATTR, 0, "getattr", "reqs");
 910         lprocfs_counter_init(stats, LPROC_MDT_SETATTR, 0, "setattr", "reqs");
 911         lprocfs_counter_init(stats, LPROC_MDT_GETXATTR, 0, "getxattr", "reqs");
 912         lprocfs_counter_init(stats, LPROC_MDT_SETXATTR, 0, "setxattr", "reqs");
 913         lprocfs_counter_init(stats, LPROC_MDT_STATFS, 0, "statfs", "reqs");
 914         lprocfs_counter_init(stats, LPROC_MDT_SYNC, 0, "sync", "reqs");
 915         lprocfs_counter_init(stats, LPROC_MDT_SAMEDIR_RENAME, 0,
 916                              "samedir_rename", "reqs");
 917         lprocfs_counter_init(stats, LPROC_MDT_CROSSDIR_RENAME, 0,
 918                              "crossdir_rename", "reqs");
 919 }
 920
 921 int mdt_procfs_init(struct mdt_device *mdt, const char *name)
 922 {
 923         struct obd_device               *obd = mdt2obd_dev(mdt);
 924         int                              rc;
 925         ENTRY;
 926
 927         LASSERT(name != NULL);
 928
 929         obd->obd_vars = lprocfs_mdt_obd_vars;
 930         rc = lprocfs_obd_setup(obd);
 931         if (rc) {
 932                 CERROR("%s: cannot create proc entries: rc = %d\n",
 933                        mdt_obd_name(mdt), rc);
 934                 return rc;
 935         }
 936
 937         rc = hsm_cdt_procfs_init(mdt);
 938         if (rc) {
 939                 CERROR("%s: cannot create hsm proc entries: rc = %d\n",
 940                        mdt_obd_name(mdt), rc);
 941                 return rc;
 942         }
 943
 944         obd->obd_proc_exports_entry = proc_mkdir("exports",
 945                                                  obd->obd_proc_entry);
 946         if (obd->obd_proc_exports_entry)
 947                 lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
 948                                    obd, &mdt_nid_stats_clear_fops);
 949         rc = lprocfs_alloc_md_stats(obd, LPROC_MDT_LAST);
 950         if (rc)
 951                 return rc;
 952         mdt_stats_counter_init(obd->obd_md_stats);
 953
 954         rc = lprocfs_job_stats_init(obd, LPROC_MDT_LAST,
 955                                     mdt_stats_counter_init);
 956
 957         rc = lproc_mdt_attach_rename_seqstat(mdt);
 958         if (rc)
 959                 CERROR("%s: MDT can not create rename stats rc = %d\n",
 960                        mdt_obd_name(mdt), rc);
 961
 962         RETURN(rc);
 963 }
 964
 965 void mdt_procfs_fini(struct mdt_device *mdt)
 966 {
 967         struct obd_device *obd = mdt2obd_dev(mdt);
 968
 969         if (obd->obd_proc_exports_entry != NULL) {
 970                 lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
 971                 obd->obd_proc_exports_entry = NULL;
 972         }
 973
 974         lprocfs_free_per_client_stats(obd);
 975         hsm_cdt_procfs_fini(mdt);
 976         lprocfs_obd_cleanup(obd);
 977         lprocfs_free_md_stats(obd);
 978         lprocfs_free_obd_stats(obd);
 979         lprocfs_job_stats_fini(obd);
 980 }