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