lustre/ofd/lproc_ofd.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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2012, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  *
  31  * lustre/ofd/lproc_ofd.c
  32  *
  33  * This file provides functions of procfs interface for OBD Filter Device (OFD).
  34  *
  35  * Author: Andreas Dilger <andreas.dilger@intel.com>
  36  * Author: Mikhail Pershin <mike.pershin@intel.com>
  37  * Author: Johann Lombardi <johann.lombardi@intel.com>
  38  * Author: Fan Yong <fan.yong@intel.com>
  39  */
  40
  41 #define DEBUG_SUBSYSTEM S_CLASS
  42
  43 #include <obd.h>
  44 #include <lprocfs_status.h>
  45 #include <linux/seq_file.h>
  46 #include <lustre_lfsck.h>
  47 #include <uapi/linux/lustre/lustre_access_log.h>
  48 #include <obd_cksum.h>
  49
  50 #include "ofd_internal.h"
  51
  52 #ifdef CONFIG_PROC_FS
  53
  54 /**
  55  * Show number of FID allocation sequences.
  56  *
  57  * \param[in] m         seq_file handle
  58  * \param[in] data      unused for single entry
  59  *
  60  * \retval              0 on success
  61  * \retval              negative value on error
  62  */
  63 static ssize_t seqs_allocated_show(struct kobject *kobj, struct attribute *attr,
  64                                    char *buf)
  65 {
  66         struct obd_device *obd = container_of(kobj, struct obd_device,
  67                                               obd_kset.kobj);
  68         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
  69
  70         return sprintf(buf, "%u\n", ofd->ofd_seq_count);
  71 }
  72 LUSTRE_RO_ATTR(seqs_allocated);
  73
  74 /**
  75  * Show total number of grants for precreate.
  76  *
  77  * \param[in] m         seq_file handle
  78  * \param[in] data      unused for single entry
  79  *
  80  * \retval              0 on success
  81  * \retval              negative value on error
  82  */
  83 static ssize_t grant_precreate_show(struct kobject *kobj,
  84                                     struct attribute *attr,
  85                                     char *buf)
  86 {
  87         struct obd_device *obd = container_of(kobj, struct obd_device,
  88                                               obd_kset.kobj);
  89
  90         return sprintf(buf, "%ld\n",
  91                        obd->obd_self_export->exp_target_data.ted_grant);
  92 }
  93 LUSTRE_RO_ATTR(grant_precreate);
  94
  95 /**
  96  * Show number of precreates allowed in a single transaction.
  97  *
  98  * \param[in] m         seq_file handle
  99  * \param[in] data      unused for single entry
 100  *
 101  * \retval              0 on success
 102  * \retval              negative value on error
 103  */
 104 static ssize_t precreate_batch_show(struct kobject *kobj,
 105                                     struct attribute *attr,
 106                                     char *buf)
 107 {
 108         struct obd_device *obd = container_of(kobj, struct obd_device,
 109                                               obd_kset.kobj);
 110         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 111
 112         return sprintf(buf, "%d\n", ofd->ofd_precreate_batch);
 113 }
 114
 115 /**
 116  * Change number of precreates allowed in a single transaction.
 117  *
 118  * \param[in] file      proc file
 119  * \param[in] buffer    string which represents maximum number
 120  * \param[in] count     \a buffer length
 121  * \param[in] off       unused for single entry
 122  *
 123  * \retval              \a count on success
 124  * \retval              negative number on error
 125  */
 126 static ssize_t precreate_batch_store(struct kobject *kobj,
 127                                      struct attribute *attr,
 128                                      const char *buffer, size_t count)
 129 {
 130         struct obd_device *obd = container_of(kobj, struct obd_device,
 131                                               obd_kset.kobj);
 132         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 133         unsigned int val;
 134         int rc;
 135
 136         rc = kstrtouint(buffer, 0, &val);
 137         if (rc)
 138                 return rc;
 139
 140         if (val < 1 || val > 65536)
 141                 return -EINVAL;
 142
 143         spin_lock(&ofd->ofd_batch_lock);
 144         ofd->ofd_precreate_batch = val;
 145         spin_unlock(&ofd->ofd_batch_lock);
 146         return count;
 147 }
 148 LUSTRE_RW_ATTR(precreate_batch);
 149
 150 /**
 151  * Show number of seconds to delay atime
 152  *
 153  * \param[in] m         seq_file handle
 154  * \param[in] data      unused for single entry
 155  *
 156  * \retval              0 on success
 157  * \retval              negative value on error
 158  */
 159 static ssize_t atime_diff_show(struct kobject *kobj, struct attribute *attr,
 160                                char *buf)
 161 {
 162         struct obd_device *obd = container_of(kobj, struct obd_device,
 163                                               obd_kset.kobj);
 164         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 165
 166         return scnprintf(buf, PAGE_SIZE, "%lld\n", ofd->ofd_atime_diff);
 167 }
 168
 169 /**
 170  * Change number of seconds to delay atime
 171  *
 172  * \param[in] file      proc file
 173  * \param[in] buffer    string which represents maximum number
 174  * \param[in] count     \a buffer length
 175  * \param[in] off       unused for single entry
 176  *
 177  * \retval              \a count on success
 178  * \retval              negative number on error
 179  */
 180 static ssize_t atime_diff_store(struct kobject *kobj, struct attribute *attr,
 181                                 const char *buffer, size_t count)
 182 {
 183         struct obd_device *obd = container_of(kobj, struct obd_device,
 184                                               obd_kset.kobj);
 185         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 186         unsigned int val;
 187         int rc;
 188
 189         rc = kstrtouint(buffer, 0, &val);
 190         if (rc)
 191                 return rc;
 192
 193         if (val > 86400)
 194                 return -EINVAL;
 195
 196         ofd->ofd_atime_diff = val;
 197         return count;
 198 }
 199 LUSTRE_RW_ATTR(atime_diff);
 200
 201 /**
 202  * Show the last used ID for each FID sequence used by OFD.
 203  *
 204  * \param[in] m         seq_file handle
 205  * \param[in] data      unused for single entry
 206  *
 207  * \retval              0 on success
 208  * \retval              negative value on error
 209  */
 210 static int ofd_last_id_seq_show(struct seq_file *m, void *data)
 211 {
 212         struct obd_device       *obd = m->private;
 213         struct ofd_device       *ofd;
 214         struct ofd_seq          *oseq = NULL;
 215
 216         if (obd == NULL)
 217                 return 0;
 218
 219         ofd = ofd_dev(obd->obd_lu_dev);
 220
 221         read_lock(&ofd->ofd_seq_list_lock);
 222         list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
 223                 __u64 seq;
 224
 225                 seq = ostid_seq(&oseq->os_oi) == 0 ?
 226                       fid_idif_seq(ostid_id(&oseq->os_oi),
 227                                 ofd->ofd_lut.lut_lsd.lsd_osd_index) & ~0xFFFF :
 228                                 ostid_seq(&oseq->os_oi);
 229                 seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
 230         }
 231         read_unlock(&ofd->ofd_seq_list_lock);
 232         return 0;
 233 }
 234
 235 LPROC_SEQ_FOPS_RO(ofd_last_id);
 236
 237 /**
 238  * Show if the OFD is in degraded mode.
 239  *
 240  * Degraded means OFD has a failed drive or is undergoing RAID rebuild.
 241  * The MDS will try to avoid using this OST for new object allocations
 242  * to reduce the impact to global IO performance when clients writing to
 243  * this OST are slowed down.  It also reduces the contention on the OST
 244  * RAID device, allowing it to rebuild more quickly.
 245  *
 246  * \retval              count of bytes written
 247  */
 248 static ssize_t degraded_show(struct kobject *kobj, struct attribute *attr,
 249                              char *buf)
 250 {
 251         struct obd_device *obd = container_of(kobj, struct obd_device,
 252                                               obd_kset.kobj);
 253         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 254
 255         return sprintf(buf, "%u\n", ofd->ofd_raid_degraded);
 256 }
 257
 258 /**
 259  * Set OFD to degraded mode.
 260  *
 261  * This is used to interface to userspace administrative tools for
 262  * the underlying RAID storage, so that they can mark an OST
 263  * as having degraded performance.
 264  *
 265  * \param[in] count     \a buffer length
 266  * \param[in] off       unused for single entry
 267  *
 268  * \retval              \a count on success
 269  * \retval              negative number on error
 270  */
 271 static ssize_t degraded_store(struct kobject *kobj, struct attribute *attr,
 272                               const char *buffer, size_t count)
 273 {
 274         struct obd_device *obd = container_of(kobj, struct obd_device,
 275                                               obd_kset.kobj);
 276         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 277         bool val;
 278         int rc;
 279
 280         rc = kstrtobool(buffer, &val);
 281         if (rc)
 282                 return rc;
 283
 284         spin_lock(&ofd->ofd_flags_lock);
 285         ofd->ofd_raid_degraded = val;
 286         spin_unlock(&ofd->ofd_flags_lock);
 287         return count;
 288 }
 289 LUSTRE_RW_ATTR(degraded);
 290
 291 /**
 292  * Show if the OFD is in no precreate mode.
 293  *
 294  * This means OFD has been adminstratively disabled at the OST to prevent
 295  * the MDS from creating any new files on the OST, though existing files
 296  * can still be read, written, and unlinked.
 297  *
 298  * \retval              number of bytes written
 299  */
 300 static ssize_t no_precreate_show(struct kobject *kobj, struct attribute *attr,
 301                                  char *buf)
 302 {
 303         struct obd_device *obd = container_of(kobj, struct obd_device,
 304                                               obd_kset.kobj);
 305         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 306
 307         return scnprintf(buf, PAGE_SIZE, "%u\n", ofd->ofd_no_precreate);
 308 }
 309
 310 /**
 311  * Set OFD to no precreate mode.
 312  *
 313  * This is used to interface to userspace administrative tools to
 314  * disable new object creation on the OST.
 315  *
 316  * \param[in] count     \a buffer length
 317  *
 318  * \retval              \a count on success
 319  * \retval              negative number on error
 320  */
 321 static ssize_t no_precreate_store(struct kobject *kobj, struct attribute *attr,
 322                                   const char *buffer, size_t count)
 323 {
 324         struct obd_device *obd = container_of(kobj, struct obd_device,
 325                                               obd_kset.kobj);
 326         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 327         bool val;
 328         int rc;
 329
 330         rc = kstrtobool(buffer, &val);
 331         if (rc)
 332                 return rc;
 333
 334         spin_lock(&ofd->ofd_flags_lock);
 335         ofd->ofd_no_precreate = val;
 336         spin_unlock(&ofd->ofd_flags_lock);
 337
 338         return count;
 339 }
 340 LUSTRE_RW_ATTR(no_precreate);
 341
 342 /**
 343  * Show OFD filesystem type.
 344  *
 345  * \param[in] m         seq_file handle
 346  * \param[in] data      unused for single entry
 347  *
 348  * \retval              0 on success
 349  * \retval              negative value on error
 350  */
 351 static ssize_t fstype_show(struct kobject *kobj, struct attribute *attr,
 352                            char *buf)
 353 {
 354         struct obd_device *obd = container_of(kobj, struct obd_device,
 355                                               obd_kset.kobj);
 356         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 357         struct lu_device  *d;
 358
 359         LASSERT(ofd->ofd_osd);
 360         d = &ofd->ofd_osd->dd_lu_dev;
 361         LASSERT(d->ld_type);
 362         return sprintf(buf, "%s\n", d->ld_type->ldt_name);
 363 }
 364 LUSTRE_RO_ATTR(fstype);
 365
 366 /**
 367  * Show journal handling mode: synchronous or asynchronous.
 368  *
 369  * When running in asynchronous mode the journal transactions are not
 370  * committed to disk before the RPC is replied back to the client.
 371  * This will typically improve client performance when only a small number
 372  * of clients are writing, since the client(s) can have more write RPCs
 373  * in flight. However, it also means that the client has to handle recovery
 374  * on bulk RPCs, and will have to keep more dirty pages in cache before they
 375  * are committed on the OST.
 376  *
 377  * \param[in] m         seq_file handle
 378  * \param[in] data      unused for single entry
 379  *
 380  * \retval              0 on success
 381  * \retval              negative value on error
 382  */
 383 static ssize_t sync_journal_show(struct kobject *kobj, struct attribute *attr,
 384                                 char *buf)
 385 {
 386         struct obd_device *obd = container_of(kobj, struct obd_device,
 387                                               obd_kset.kobj);
 388         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 389
 390         return sprintf(buf, "%u\n", ofd->ofd_sync_journal);
 391 }
 392
 393 /**
 394  * Set journal mode to synchronous or asynchronous.
 395  *
 396  * \param[in] file      proc file
 397  * \param[in] buffer    string which represents mode
 398  *                      1: synchronous mode
 399  *                      0: asynchronous mode
 400  * \param[in] count     \a buffer length
 401  * \param[in] off       unused for single entry
 402  *
 403  * \retval              \a count on success
 404  * \retval              negative number on error
 405  */
 406 static ssize_t sync_journal_store(struct kobject *kobj, struct attribute *attr,
 407                                  const char *buffer, size_t count)
 408 {
 409         struct obd_device *obd = container_of(kobj, struct obd_device,
 410                                               obd_kset.kobj);
 411         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 412         bool val;
 413         int rc;
 414
 415         rc = kstrtobool(buffer, &val);
 416         if (rc)
 417                 return rc;
 418
 419         spin_lock(&ofd->ofd_flags_lock);
 420         ofd->ofd_sync_journal = val;
 421         ofd_slc_set(ofd);
 422         spin_unlock(&ofd->ofd_flags_lock);
 423
 424         return count;
 425 }
 426 LUSTRE_RW_ATTR(sync_journal);
 427
 428 static int ofd_brw_size_seq_show(struct seq_file *m, void *data)
 429 {
 430         struct obd_device       *obd = m->private;
 431         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 432
 433         seq_printf(m, "%u\n", ofd->ofd_brw_size / ONE_MB_BRW_SIZE);
 434         return 0;
 435 }
 436
 437 static ssize_t
 438 ofd_brw_size_seq_write(struct file *file, const char __user *buffer,
 439                        size_t count, loff_t *off)
 440 {
 441         struct seq_file *m = file->private_data;
 442         struct obd_device *obd = m->private;
 443         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 444         char kernbuf[22] = "";
 445         u64 val;
 446         int rc;
 447
 448         if (count >= sizeof(kernbuf))
 449                 return -EINVAL;
 450
 451         if (copy_from_user(kernbuf, buffer, count))
 452                 return -EFAULT;
 453         kernbuf[count] = 0;
 454
 455         rc = sysfs_memparse(kernbuf, count, &val, "MiB");
 456         if (rc < 0)
 457                 return rc;
 458
 459         if (val == 0)
 460                 return -EINVAL;
 461
 462         if (val > DT_MAX_BRW_SIZE ||
 463             val < (1 << ofd->ofd_lut.lut_tgd.tgd_blockbits))
 464                 return -ERANGE;
 465
 466         spin_lock(&ofd->ofd_flags_lock);
 467         ofd->ofd_brw_size = val;
 468         spin_unlock(&ofd->ofd_flags_lock);
 469
 470         return count;
 471 }
 472 LPROC_SEQ_FOPS(ofd_brw_size);
 473
 474 /*
 475  * ofd_checksum_type(server) proc handling
 476  */
 477 DECLARE_CKSUM_NAME;
 478
 479 static int ofd_checksum_type_seq_show(struct seq_file *m, void *data)
 480 {
 481         struct obd_device *obd = m->private;
 482         struct lu_target *lut;
 483         enum cksum_types pref;
 484         int i;
 485
 486         if (!obd)
 487                 return 0;
 488
 489         lut = obd2obt(obd)->obt_lut;
 490         /* select fastest checksum type on the server */
 491         pref = obd_cksum_type_select(obd->obd_name,
 492                                      lut->lut_cksum_types_supported, 0);
 493
 494         for (i = 0; i < ARRAY_SIZE(cksum_name); i++) {
 495                 if ((BIT(i) & lut->lut_cksum_types_supported) == 0)
 496                         continue;
 497
 498                 if (pref == BIT(i))
 499                         seq_printf(m, "[%s] ", cksum_name[i]);
 500                 else
 501                         seq_printf(m, "%s ", cksum_name[i]);
 502         }
 503         seq_puts(m, "\n");
 504
 505         return 0;
 506 }
 507
 508 LPROC_SEQ_FOPS_RO(ofd_checksum_type);
 509
 510
 511 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 16, 53, 0)
 512 static ssize_t sync_on_lock_cancel_show(struct kobject *kobj,
 513                                         struct attribute *attr, char *buf)
 514 {
 515         return sync_lock_cancel_show(kobj, attr, buf);
 516 }
 517
 518 static ssize_t sync_on_lock_cancel_store(struct kobject *kobj,
 519                                          struct attribute *attr,
 520                                          const char *buffer, size_t count)
 521 {
 522         static bool sync_on_lock_cancel_warned;
 523
 524         if (!sync_on_lock_cancel_warned) {
 525                 sync_on_lock_cancel_warned = true;
 526                 pr_info("ofd: 'obdfilter.*.sync_on_lock_cancel' is deprecated, use 'obdfilter.*.sync_lock_cancel' instead\n");
 527         }
 528         return sync_lock_cancel_store(kobj, attr, buffer, count);
 529 }
 530 LUSTRE_RW_ATTR(sync_on_lock_cancel);
 531 #endif
 532
 533 /**
 534  * Show the limit of soft sync RPCs.
 535  *
 536  * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
 537  * are allowed before sync update will be triggered.
 538  *
 539  * \param[in] m         seq_file handle
 540  * \param[in] data      unused for single entry
 541  *
 542  * \retval              0 on success
 543  * \retval              negative value on error
 544  */
 545 static ssize_t soft_sync_limit_show(struct kobject *kobj,
 546                                     struct attribute *attr, char *buf)
 547 {
 548         struct obd_device *obd = container_of(kobj, struct obd_device,
 549                                               obd_kset.kobj);
 550         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 551
 552         return sprintf(buf, "%u\n", ofd->ofd_soft_sync_limit);
 553 }
 554
 555 /**
 556  * Change the limit of soft sync RPCs.
 557  *
 558  * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
 559  * allowed before sync update will be done.
 560  *
 561  * This limit is global across all exports.
 562  *
 563  * \param[in] file      proc file
 564  * \param[in] buffer    string which represents limit
 565  * \param[in] count     \a buffer length
 566  * \param[in] off       unused for single entry
 567  *
 568  * \retval              \a count on success
 569  * \retval              negative number on error
 570  */
 571 static ssize_t soft_sync_limit_store(struct kobject *kobj,
 572                                      struct attribute *attr,
 573                                      const char *buffer, size_t count)
 574 {
 575         struct obd_device *obd = container_of(kobj, struct obd_device,
 576                                               obd_kset.kobj);
 577         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 578         unsigned int val;
 579         int rc;
 580
 581         rc = kstrtouint(buffer, 0, &val);
 582         if (rc < 0)
 583                 return rc;
 584
 585         ofd->ofd_soft_sync_limit = val;
 586         return 0;
 587 }
 588 LUSTRE_RW_ATTR(soft_sync_limit);
 589
 590 /**
 591  * Show the LFSCK speed limit.
 592  *
 593  * The maximum number of items scanned per second.
 594  *
 595  * \param[in] m         seq_file handle
 596  * \param[in] data      unused for single entry
 597  *
 598  * \retval              0 on success
 599  * \retval              negative value on error
 600  */
 601 static ssize_t lfsck_speed_limit_show(struct kobject *kobj,
 602                                       struct attribute *attr, char *buf)
 603 {
 604         struct obd_device *obd = container_of(kobj, struct obd_device,
 605                                               obd_kset.kobj);
 606         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 607
 608         return lfsck_get_speed(buf, ofd->ofd_osd);
 609 }
 610
 611 /**
 612  * Change the LFSCK speed limit.
 613  *
 614  * Limit number of items that may be scanned per second.
 615  *
 616  * \param[in] file      proc file
 617  * \param[in] buffer    string which represents limit
 618  * \param[in] count     \a buffer length
 619  * \param[in] off       unused for single entry
 620  *
 621  * \retval              \a count on success
 622  * \retval              negative number on error
 623  */
 624 static ssize_t lfsck_speed_limit_store(struct kobject *kobj,
 625                                        struct attribute *attr,
 626                                        const char *buffer, size_t count)
 627 {
 628         struct obd_device *obd = container_of(kobj, struct obd_device,
 629                                               obd_kset.kobj);
 630         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 631         unsigned int val;
 632         int rc;
 633
 634         rc = kstrtouint(buffer, 0, &val);
 635         if (rc != 0)
 636                 return rc;
 637
 638         rc = lfsck_set_speed(ofd->ofd_osd, val);
 639
 640         return rc != 0 ? rc : count;
 641 }
 642 LUSTRE_RW_ATTR(lfsck_speed_limit);
 643
 644 /**
 645  * Show LFSCK layout verification stats from the most recent LFSCK run.
 646  *
 647  * \param[in] m         seq_file handle
 648  * \param[in] data      unused for single entry
 649  *
 650  * \retval              0 on success
 651  * \retval              negative value on error
 652  */
 653 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
 654 {
 655         struct obd_device *obd = m->private;
 656         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 657
 658         return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
 659 }
 660
 661 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
 662
 663 /**
 664  * Show if LFSCK performed parent FID verification.
 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 ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
 673 {
 674         struct obd_device *obd = m->private;
 675         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 676
 677         seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
 678                    ofd->ofd_lfsck_verify_pfid ? "on" : "off",
 679                    ofd->ofd_inconsistency_self_detected,
 680                    ofd->ofd_inconsistency_self_repaired);
 681         return 0;
 682 }
 683
 684 /**
 685  * Set the LFSCK behavior to verify parent FID correctness.
 686  *
 687  * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
 688  * verification during read/write operations.
 689  *
 690  * \param[in] file      proc file
 691  * \param[in] buffer    string which represents behavior
 692  *                      1: verify parent FID
 693  *                      0: don't verify parent FID
 694  * \param[in] count     \a buffer length
 695  * \param[in] off       unused for single entry
 696  *
 697  * \retval              \a count on success
 698  * \retval              negative number on error
 699  */
 700 static ssize_t
 701 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
 702                                 size_t count, loff_t *off)
 703 {
 704         struct seq_file *m = file->private_data;
 705         struct obd_device *obd = m->private;
 706         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 707         bool val;
 708         int rc;
 709
 710         rc = kstrtobool_from_user(buffer, count, &val);
 711         if (rc)
 712                 return rc;
 713
 714         ofd->ofd_lfsck_verify_pfid = val;
 715         if (!ofd->ofd_lfsck_verify_pfid) {
 716                 ofd->ofd_inconsistency_self_detected = 0;
 717                 ofd->ofd_inconsistency_self_repaired = 0;
 718         }
 719
 720         return count;
 721 }
 722
 723 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
 724
 725 static ssize_t access_log_mask_show(struct kobject *kobj,
 726                         struct attribute *attr, char *buf)
 727 {
 728         struct obd_device *obd = container_of(kobj, struct obd_device,
 729                                               obd_kset.kobj);
 730         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 731
 732         return scnprintf(buf, PAGE_SIZE, "%s%s%s\n",
 733                 (ofd->ofd_access_log_mask == 0) ? "0" : "",
 734                 (ofd->ofd_access_log_mask & OFD_ACCESS_READ) ? "r" : "",
 735                 (ofd->ofd_access_log_mask & OFD_ACCESS_WRITE) ? "w" : "");
 736 }
 737
 738 static ssize_t access_log_mask_store(struct kobject *kobj,
 739                                      struct attribute *attr,
 740                                      const char *buffer, size_t count)
 741 {
 742         struct obd_device *obd = container_of(kobj, struct obd_device,
 743                                               obd_kset.kobj);
 744         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 745         unsigned int mask = 0;
 746         size_t i;
 747
 748         for (i = 0; i < count; i++) {
 749                 switch (tolower(buffer[i])) {
 750                 case '0':
 751                         break;
 752                 case 'r':
 753                         mask |= OFD_ACCESS_READ;
 754                         break;
 755                 case 'w':
 756                         mask |= OFD_ACCESS_WRITE;
 757                         break;
 758                 default:
 759                         return -EINVAL;
 760                 }
 761         }
 762
 763         ofd->ofd_access_log_mask = mask;
 764
 765         return count;
 766 }
 767 LUSTRE_RW_ATTR(access_log_mask);
 768
 769 static ssize_t access_log_size_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 ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 775
 776         return scnprintf(buf, PAGE_SIZE, "%u\n", ofd->ofd_access_log_size);
 777 }
 778
 779 static ssize_t access_log_size_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 ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 786         struct ofd_access_log *oal;
 787         unsigned int size;
 788         ssize_t rc;
 789
 790         rc = kstrtouint(buffer, 0, &size);
 791         if (rc < 0)
 792                 return rc;
 793
 794         if (!ofd_access_log_size_is_valid(size))
 795                 return -EINVAL;
 796
 797         /* The size of the ofd_access_log cannot be changed after it
 798          * has been created.
 799          */
 800         if (ofd->ofd_access_log_size == size)
 801                 return count;
 802
 803         oal = ofd_access_log_create(obd->obd_name, size);
 804         if (IS_ERR(oal))
 805                 return PTR_ERR(oal);
 806
 807         spin_lock(&ofd->ofd_flags_lock);
 808         if (ofd->ofd_access_log != NULL) {
 809                 rc = -EBUSY;
 810         } else {
 811                 ofd->ofd_access_log = oal;
 812                 ofd->ofd_access_log_size = size;
 813                 oal = NULL;
 814                 rc = count;
 815         }
 816         spin_unlock(&ofd->ofd_flags_lock);
 817
 818         ofd_access_log_delete(oal);
 819
 820         return rc;
 821 }
 822 LUSTRE_RW_ATTR(access_log_size);
 823
 824 static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
 825 {
 826         struct obd_device *obd = m->private;
 827
 828         return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
 829 }
 830
 831 LPROC_SEQ_FOPS_RO(ofd_site_stats);
 832
 833 /**
 834  * Show if the OFD enforces T10PI checksum.
 835  *
 836  * \param[in] m         seq_file handle
 837  * \param[in] data      unused for single entry
 838  *
 839  * \retval              0 on success
 840  * \retval              negative value on error
 841  */
 842 static ssize_t checksum_t10pi_enforce_show(struct kobject *kobj,
 843                                            struct attribute *attr,
 844                                            char *buf)
 845 {
 846         struct obd_device *obd = container_of(kobj, struct obd_device,
 847                                               obd_kset.kobj);
 848         struct lu_target *lut = obd2obt(obd)->obt_lut;
 849
 850         return scnprintf(buf, PAGE_SIZE, "%u\n", lut->lut_cksum_t10pi_enforce);
 851 }
 852
 853 /**
 854  * Force specific T10PI checksum modes to be enabled
 855  *
 856  * If T10PI *is* supported in hardware, allow only the supported T10PI type
 857  * to be used. If T10PI is *not* supported by the OSD, setting the enforce
 858  * parameter forces all T10PI types to be enabled (even if slower) for
 859  * testing.
 860  *
 861  * The final determination of which algorithm to be used depends whether
 862  * the client supports T10PI or not, and is handled at client connect time.
 863  *
 864  * \param[in] file      proc file
 865  * \param[in] buffer    string which represents mode
 866  *                      1: set T10PI checksums enforced
 867  *                      0: unset T10PI checksums enforced
 868  * \param[in] count     \a buffer length
 869  * \param[in] off       unused for single entry
 870  *
 871  * \retval              \a count on success
 872  * \retval              negative number on error
 873  */
 874 static ssize_t checksum_t10pi_enforce_store(struct kobject *kobj,
 875                                             struct attribute *attr,
 876                                             const char *buffer, size_t count)
 877 {
 878         struct obd_device *obd = container_of(kobj, struct obd_device,
 879                                               obd_kset.kobj);
 880         struct lu_target *lut = obd2obt(obd)->obt_lut;
 881         bool enforce;
 882         int rc;
 883
 884         rc = kstrtobool(buffer, &enforce);
 885         if (rc)
 886                 return rc;
 887
 888         spin_lock(&lut->lut_flags_lock);
 889         lut->lut_cksum_t10pi_enforce = enforce;
 890         spin_unlock(&lut->lut_flags_lock);
 891         return count;
 892 }
 893 LUSTRE_RW_ATTR(checksum_t10pi_enforce);
 894
 895 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 15, 53, 0)
 896 static ssize_t read_cache_enable_show(struct kobject *kobj,
 897                                       struct attribute *attr,
 898                                       char *buf)
 899 {
 900         struct obd_device *obd = container_of(kobj, struct obd_device,
 901                                               obd_kset.kobj);
 902         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 903
 904         if (!ofd->ofd_read_cache_enable)
 905                 return -EOPNOTSUPP;
 906
 907         return lustre_attr_show(&ofd->ofd_osd->dd_kobj,
 908                                 ofd->ofd_read_cache_enable, buf);
 909 }
 910
 911 static ssize_t read_cache_enable_store(struct kobject *kobj,
 912                                        struct attribute *attr,
 913                                        const char *buffer, size_t count)
 914 {
 915         struct obd_device *obd = container_of(kobj, struct obd_device,
 916                                               obd_kset.kobj);
 917         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 918         static bool rd_cache_warned;
 919
 920         if (!rd_cache_warned) {
 921                 rd_cache_warned = true;
 922                 pr_info("ofd: 'obdfilter.*.read_cache_enable' is deprecated, use 'osd-*.*.read_cache_enable' instead\n");
 923         }
 924
 925         if (!ofd->ofd_read_cache_enable)
 926                 return -EOPNOTSUPP;
 927
 928         return lustre_attr_store(&ofd->ofd_osd->dd_kobj,
 929                                  ofd->ofd_read_cache_enable, buffer, count);
 930 }
 931 LUSTRE_RW_ATTR(read_cache_enable);
 932
 933 static ssize_t readcache_max_filesize_show(struct kobject *kobj,
 934                                            struct attribute *attr,
 935                                            char *buf)
 936 {
 937         struct obd_device *obd = container_of(kobj, struct obd_device,
 938                                               obd_kset.kobj);
 939         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 940
 941         if (!ofd->ofd_read_cache_max_filesize)
 942                 return -EOPNOTSUPP;
 943
 944         return lustre_attr_show(&ofd->ofd_osd->dd_kobj,
 945                                 ofd->ofd_read_cache_max_filesize, buf);
 946 }
 947
 948 static ssize_t readcache_max_filesize_store(struct kobject *kobj,
 949                                             struct attribute *attr,
 950                                             const char *buffer, size_t count)
 951 {
 952         struct obd_device *obd = container_of(kobj, struct obd_device,
 953                                               obd_kset.kobj);
 954         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 955         static bool max_file_warned;
 956
 957         if (!max_file_warned) {
 958                 max_file_warned = true;
 959                 pr_info("ofd: 'obdfilter.*.readcache_max_filesize' is deprecated, use 'osd-*.*.readcache_max_filesize' instead\n");
 960         }
 961
 962         if (!ofd->ofd_read_cache_max_filesize)
 963                 return -EOPNOTSUPP;
 964
 965         return lustre_attr_store(&ofd->ofd_osd->dd_kobj,
 966                                  ofd->ofd_read_cache_max_filesize,
 967                                  buffer, count);
 968 }
 969 LUSTRE_RW_ATTR(readcache_max_filesize);
 970
 971 static ssize_t writethrough_cache_enable_show(struct kobject *kobj,
 972                                               struct attribute *attr,
 973                                               char *buf)
 974 {
 975         struct obd_device *obd = container_of(kobj, struct obd_device,
 976                                               obd_kset.kobj);
 977         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 978
 979         if (!ofd->ofd_write_cache_enable)
 980                 return -EOPNOTSUPP;
 981
 982         return lustre_attr_show(&ofd->ofd_osd->dd_kobj,
 983                                 ofd->ofd_write_cache_enable, buf);
 984 }
 985
 986 static ssize_t writethrough_cache_enable_store(struct kobject *kobj,
 987                                                struct attribute *attr,
 988                                                const char *buffer, size_t count)
 989 {
 990         struct obd_device *obd = container_of(kobj, struct obd_device,
 991                                               obd_kset.kobj);
 992         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 993         static bool wr_cache_warned;
 994
 995         if (!wr_cache_warned) {
 996                 wr_cache_warned = true;
 997                 pr_info("ofd: 'obdfilter.*.writethrough_cache_enable' is deprecated, use 'osd-*.*.writethrough_cache_enable' instead\n");
 998         }
 999
1000         if (!ofd->ofd_write_cache_enable)
1001                 return -EOPNOTSUPP;
1002
1003         return lustre_attr_store(&ofd->ofd_osd->dd_kobj,
1004                                  ofd->ofd_write_cache_enable,
1005                                  buffer, count);
1006 }
1007 LUSTRE_RW_ATTR(writethrough_cache_enable);
1008 #endif
1009
1010 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
1011 LUSTRE_RW_ATTR(recovery_time_hard);
1012 LUSTRE_RW_ATTR(recovery_time_soft);
1013 LUSTRE_RW_ATTR(ir_factor);
1014
1015 LPROC_SEQ_FOPS_WR_ONLY(ofd, evict_client);
1016 LPROC_SEQ_FOPS_RW_TYPE(ofd, checksum_dump);
1017 LUSTRE_RW_ATTR(job_cleanup_interval);
1018
1019 LUSTRE_RO_ATTR(tot_dirty);
1020 LUSTRE_RO_ATTR(tot_granted);
1021 LUSTRE_RO_ATTR(tot_pending);
1022 LUSTRE_RW_ATTR(grant_compat_disable);
1023 LUSTRE_RO_ATTR(instance);
1024
1025 LUSTRE_RO_ATTR(num_exports);
1026 LUSTRE_RW_ATTR(grant_check_threshold);
1027
1028 struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
1029         { .name =       "last_id",
1030           .fops =       &ofd_last_id_fops               },
1031         { .name =       "recovery_status",
1032           .fops =       &ofd_recovery_status_fops       },
1033         { .name =       "evict_client",
1034           .fops =       &ofd_evict_client_fops          },
1035         { .name =       "brw_size",
1036           .fops =       &ofd_brw_size_fops              },
1037         { .name =       "checksum_dump",
1038           .fops =       &ofd_checksum_dump_fops         },
1039         { .name =       "lfsck_layout",
1040           .fops =       &ofd_lfsck_layout_fops          },
1041         { .name =       "lfsck_verify_pfid",
1042           .fops =       &ofd_lfsck_verify_pfid_fops     },
1043         { .name =       "site_stats",
1044           .fops =       &ofd_site_stats_fops            },
1045         { .name =       "checksum_type",
1046           .fops =       &ofd_checksum_type_fops         },
1047         { NULL }
1048 };
1049
1050 /**
1051  * Initialize OFD statistics counters
1052  *
1053  * param[in] stats      statistics counters
1054  */
1055 void ofd_stats_counter_init(struct lprocfs_stats *stats, unsigned int offset,
1056                             enum lprocfs_counter_config cntr_umask)
1057 {
1058         LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
1059
1060         lprocfs_counter_init(stats, LPROC_OFD_STATS_READ_BYTES,
1061                              LPROCFS_TYPE_BYTES_FULL_HISTOGRAM & (~cntr_umask),
1062                              "read_bytes");
1063         lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE_BYTES,
1064                              LPROCFS_TYPE_BYTES_FULL_HISTOGRAM & (~cntr_umask),
1065                              "write_bytes");
1066         lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
1067                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "read");
1068         lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
1069                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "write");
1070         lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
1071                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "getattr");
1072         lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
1073                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "setattr");
1074         lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
1075                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "punch");
1076         lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
1077                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "sync");
1078         lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
1079                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "destroy");
1080         lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
1081                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "create");
1082         lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
1083                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "statfs");
1084         lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
1085                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "get_info");
1086         lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
1087                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "set_info");
1088         lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
1089                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "quotactl");
1090         lprocfs_counter_init(stats, LPROC_OFD_STATS_PREALLOC,
1091                              LPROCFS_TYPE_LATENCY & (~cntr_umask), "prealloc");
1092 }
1093
1094 LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);
1095
1096 static struct attribute *ofd_attrs[] = {
1097         &lustre_attr_tot_dirty.attr,
1098         &lustre_attr_tot_granted.attr,
1099         &lustre_attr_tot_pending.attr,
1100         &lustre_attr_grant_compat_disable.attr,
1101         &lustre_attr_instance.attr,
1102         &lustre_attr_recovery_time_hard.attr,
1103         &lustre_attr_recovery_time_soft.attr,
1104         &lustre_attr_ir_factor.attr,
1105         &lustre_attr_num_exports.attr,
1106         &lustre_attr_grant_check_threshold.attr,
1107         &lustre_attr_seqs_allocated.attr,
1108         &lustre_attr_grant_precreate.attr,
1109         &lustre_attr_precreate_batch.attr,
1110         &lustre_attr_atime_diff.attr,
1111         &lustre_attr_degraded.attr,
1112         &lustre_attr_fstype.attr,
1113         &lustre_attr_no_precreate.attr,
1114         &lustre_attr_sync_journal.attr,
1115 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 16, 53, 0)
1116         &lustre_attr_sync_on_lock_cancel.attr,
1117 #endif
1118         &lustre_attr_soft_sync_limit.attr,
1119         &lustre_attr_lfsck_speed_limit.attr,
1120         &lustre_attr_access_log_mask.attr,
1121         &lustre_attr_access_log_size.attr,
1122         &lustre_attr_job_cleanup_interval.attr,
1123         &lustre_attr_checksum_t10pi_enforce.attr,
1124 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 15, 53, 0)
1125         &lustre_attr_read_cache_enable.attr,
1126         &lustre_attr_readcache_max_filesize.attr,
1127         &lustre_attr_writethrough_cache_enable.attr,
1128 #endif
1129         NULL,
1130 };
1131
1132 /**
1133  * Initialize all needed procfs entries for OFD device.
1134  *
1135  * \param[in] ofd       OFD device
1136  *
1137  * \retval              0 if successful
1138  * \retval              negative value on error
1139  */
1140 int ofd_tunables_init(struct ofd_device *ofd)
1141 {
1142         struct obd_device *obd = ofd_obd(ofd);
1143         struct proc_dir_entry *entry;
1144         int rc = 0;
1145
1146         ENTRY;
1147         /* lprocfs must be setup before the ofd so state can be safely added
1148          * to /proc incrementally as the ofd is setup
1149          */
1150         obd->obd_ktype.default_attrs = ofd_attrs;
1151         obd->obd_vars = lprocfs_ofd_obd_vars;
1152         rc = lprocfs_obd_setup(obd, false);
1153         if (rc) {
1154                 CERROR("%s: lprocfs_obd_setup failed: %d.\n",
1155                        obd->obd_name, rc);
1156                 RETURN(rc);
1157         }
1158
1159         rc = tgt_tunables_init(&ofd->ofd_lut);
1160         if (rc) {
1161                 CERROR("%s: tgt_tunables_init failed: rc = %d\n",
1162                        obd->obd_name, rc);
1163                 GOTO(obd_cleanup, rc);
1164         }
1165
1166         rc = lprocfs_alloc_obd_stats(obd, LPROC_OFD_STATS_LAST);
1167         if (rc) {
1168                 CERROR("%s: lprocfs_alloc_obd_stats failed: %d.\n",
1169                        obd->obd_name, rc);
1170                 GOTO(tgt_cleanup, rc);
1171         }
1172
1173         entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL);
1174         if (IS_ERR(entry)) {
1175                 rc = PTR_ERR(entry);
1176                 CERROR("%s: error %d setting up lprocfs for %s\n",
1177                        obd->obd_name, rc, "exports");
1178                 GOTO(obd_free_stats, rc);
1179         }
1180         obd->obd_proc_exports_entry = entry;
1181
1182         entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
1183                                    obd, &lprocfs_nid_stats_clear_fops);
1184         if (IS_ERR(entry)) {
1185                 rc = PTR_ERR(entry);
1186                 CERROR("%s: add proc entry 'clear' failed: %d.\n",
1187                        obd->obd_name, rc);
1188                 GOTO(obd_free_stats, rc);
1189         }
1190
1191         ofd_stats_counter_init(obd->obd_stats, 0, LPROCFS_CNTR_HISTOGRAM);
1192
1193         rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST,
1194                                     ofd_stats_counter_init);
1195         if (rc)
1196                 GOTO(obd_free_stats, rc);
1197
1198         RETURN(0);
1199
1200 obd_free_stats:
1201         lprocfs_free_obd_stats(obd);
1202 tgt_cleanup:
1203         tgt_tunables_fini(&ofd->ofd_lut);
1204 obd_cleanup:
1205         lprocfs_obd_cleanup(obd);
1206
1207         return rc;
1208 }
1209 #endif /* CONFIG_PROC_FS */