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