lustre/lod/lproc_lod.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  2008 Sun Microsystems, Inc. All rights reserved
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2012, 2016, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  */
  32 #define DEBUG_SUBSYSTEM S_CLASS
  33
  34 #include <lprocfs_status.h>
  35 #include <obd_class.h>
  36 #include <linux/seq_file.h>
  37 #include "lod_internal.h"
  38 #include <uapi/linux/lustre/lustre_param.h>
  39
  40 /*
  41  * Notice, all the functions below (except for lod_procfs_init() and
  42  * lod_procfs_fini()) are not supposed to be used directly. They are
  43  * called by Linux kernel's procfs.
  44  */
  45
  46 #ifdef CONFIG_PROC_FS
  47
  48 /**
  49  * Show default stripe size.
  50  *
  51  * \param[in] m         seq file
  52  * \param[in] v         unused for single entry
  53  *
  54  * \retval 0            on success
  55  * \retval negative     error code if failed
  56  */
  57 static int lod_stripesize_seq_show(struct seq_file *m, void *v)
  58 {
  59         struct obd_device *dev = m->private;
  60         struct lod_device *lod;
  61
  62         LASSERT(dev != NULL);
  63         lod  = lu2lod_dev(dev->obd_lu_dev);
  64         seq_printf(m, "%llu\n",
  65                    lod->lod_desc.ld_default_stripe_size);
  66         return 0;
  67 }
  68
  69 /**
  70  * Set default stripe size.
  71  *
  72  * \param[in] file      proc file
  73  * \param[in] buffer    string containing the maximum number of bytes stored in
  74  *                      each object before moving to the next object in the
  75  *                      layout (if any)
  76  * \param[in] count     @buffer length
  77  * \param[in] off       unused for single entry
  78  *
  79  * \retval @count       on success
  80  * \retval negative     error code if failed
  81  */
  82 static ssize_t
  83 lod_stripesize_seq_write(struct file *file, const char __user *buffer,
  84                          size_t count, loff_t *off)
  85 {
  86         struct seq_file *m = file->private_data;
  87         struct obd_device *dev = m->private;
  88         struct lod_device *lod;
  89         __s64 val;
  90         int rc;
  91
  92         LASSERT(dev != NULL);
  93         lod  = lu2lod_dev(dev->obd_lu_dev);
  94         rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1');
  95         if (rc)
  96                 return rc;
  97         if (val < 0)
  98                 return -ERANGE;
  99
 100         lod_fix_desc_stripe_size(&val);
 101         lod->lod_desc.ld_default_stripe_size = val;
 102
 103         return count;
 104 }
 105 LPROC_SEQ_FOPS(lod_stripesize);
 106
 107 /**
 108  * Show default stripe offset.
 109  *
 110  * \param[in] m         seq file
 111  * \param[in] v         unused for single entry
 112  *
 113  * \retval 0            on success
 114  * \retval negative     error code if failed
 115  */
 116 static int lod_stripeoffset_seq_show(struct seq_file *m, void *v)
 117 {
 118         struct obd_device *dev = m->private;
 119         struct lod_device *lod;
 120
 121         LASSERT(dev != NULL);
 122         lod  = lu2lod_dev(dev->obd_lu_dev);
 123         seq_printf(m, "%llu\n",
 124                    lod->lod_desc.ld_default_stripe_offset);
 125         return 0;
 126 }
 127
 128 /**
 129  * Set default stripe offset.
 130  *
 131  * Usually contains -1 allowing Lustre to balance objects among OST
 132  * otherwise may cause severe OST imbalance.
 133  *
 134  * \param[in] file      proc file
 135  * \param[in] buffer    string describing starting OST index for new files
 136  * \param[in] count     @buffer length
 137  * \param[in] off       unused for single entry
 138  *
 139  * \retval @count       on success
 140  * \retval negative     error code if failed
 141  */
 142 static ssize_t
 143 lod_stripeoffset_seq_write(struct file *file, const char __user *buffer,
 144                            size_t count, loff_t *off)
 145 {
 146         struct seq_file *m = file->private_data;
 147         struct obd_device *dev = m->private;
 148         struct lod_device *lod;
 149         __s64 val;
 150         int rc;
 151
 152         LASSERT(dev != NULL);
 153         lod  = lu2lod_dev(dev->obd_lu_dev);
 154         rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1');
 155         if (rc)
 156                 return rc;
 157         if (val < -1)
 158                 return -ERANGE;
 159
 160         lod->lod_desc.ld_default_stripe_offset = val;
 161
 162         return count;
 163 }
 164 LPROC_SEQ_FOPS(lod_stripeoffset);
 165
 166 /**
 167  * Show default striping pattern (LOV_PATTERN_*).
 168  *
 169  * \param[in] m         seq file
 170  * \param[in] v         unused for single entry
 171  *
 172  * \retval 0            on success
 173  * \retval negative     error code if failed
 174  */
 175 static int lod_stripetype_seq_show(struct seq_file *m, void *v)
 176 {
 177         struct obd_device *dev = m->private;
 178         struct lod_device *lod;
 179
 180         LASSERT(dev != NULL);
 181         lod  = lu2lod_dev(dev->obd_lu_dev);
 182         seq_printf(m, "%u\n", lod->lod_desc.ld_pattern);
 183         return 0;
 184 }
 185
 186 /**
 187  * Set default striping pattern (a number, not a human-readable string).
 188  *
 189  * \param[in] file      proc file
 190  * \param[in] buffer    string containing the default striping pattern for new
 191  *                      files. This is an integer LOV_PATTERN_* value
 192  * \param[in] count     @buffer length
 193  * \param[in] off       unused for single entry
 194  *
 195  * \retval @count       on success
 196  * \retval negative     error code if failed
 197  */
 198 static ssize_t
 199 lod_stripetype_seq_write(struct file *file, const char __user *buffer,
 200                          size_t count, loff_t *off)
 201 {
 202         struct seq_file *m = file->private_data;
 203         struct obd_device *dev = m->private;
 204         struct lod_device *lod;
 205         int rc;
 206         __u32 pattern;
 207         __s64 val;
 208
 209         LASSERT(dev != NULL);
 210         lod  = lu2lod_dev(dev->obd_lu_dev);
 211         rc = lprocfs_str_to_s64(buffer, count, &val);
 212         if (rc)
 213                 return rc;
 214         if (val < 0)
 215                 return -ERANGE;
 216
 217         pattern = val;
 218         lod_fix_desc_pattern(&pattern);
 219         lod->lod_desc.ld_pattern = pattern;
 220
 221         return count;
 222 }
 223 LPROC_SEQ_FOPS(lod_stripetype);
 224
 225 /**
 226  * Show default number of stripes.
 227  *
 228  * \param[in] m         seq file
 229  * \param[in] v         unused for single entry
 230  *
 231  * \retval 0            on success,
 232  * \retval negative     error code if failed
 233  */
 234 static int lod_stripecount_seq_show(struct seq_file *m, void *v)
 235 {
 236         struct obd_device *dev = m->private;
 237         struct lod_device *lod;
 238
 239         LASSERT(dev != NULL);
 240         lod  = lu2lod_dev(dev->obd_lu_dev);
 241         seq_printf(m, "%d\n",
 242                    (__s16)(lod->lod_desc.ld_default_stripe_count + 1) - 1);
 243         return 0;
 244 }
 245
 246 /**
 247  * Set default number of stripes.
 248  *
 249  * \param[in] file      proc file
 250  * \param[in] buffer    string containing the default number of stripes
 251  *                      for new files
 252  * \param[in] count     @buffer length
 253  * \param[in] off       unused for single entry
 254  *
 255  * \retval @count       on success
 256  * \retval negative     error code otherwise
 257  */
 258 static ssize_t
 259 lod_stripecount_seq_write(struct file *file, const char __user *buffer,
 260                           size_t count, loff_t *off)
 261 {
 262         struct seq_file *m = file->private_data;
 263         struct obd_device *dev = m->private;
 264         struct lod_device *lod;
 265         int rc;
 266         __s64 val;
 267         __u32 stripe_count;
 268
 269         LASSERT(dev != NULL);
 270         lod  = lu2lod_dev(dev->obd_lu_dev);
 271         rc = lprocfs_str_to_s64(buffer, count, &val);
 272         if (rc)
 273                 return rc;
 274         if (val < -1)
 275                 return -ERANGE;
 276
 277         stripe_count = val;
 278         lod_fix_desc_stripe_count(&stripe_count);
 279         lod->lod_desc.ld_default_stripe_count = stripe_count;
 280
 281         return count;
 282 }
 283 LPROC_SEQ_FOPS(lod_stripecount);
 284
 285 /**
 286  * Show number of targets.
 287  *
 288  * \param[in] m         seq file
 289  * \param[in] v         unused for single entry
 290  *
 291  * \retval 0            on success
 292  * \retval negative     error code if failed
 293  */
 294 static int lod_numobd_seq_show(struct seq_file *m, void *v)
 295 {
 296         struct obd_device *dev = m->private;
 297         struct lod_device *lod;
 298
 299         LASSERT(dev != NULL);
 300         lod  = lu2lod_dev(dev->obd_lu_dev);
 301         seq_printf(m, "%u\n", lod->lod_desc.ld_tgt_count);
 302         return 0;
 303 }
 304 LPROC_SEQ_FOPS_RO(lod_numobd);
 305
 306 /**
 307  * Show number of active targets.
 308  *
 309  * \param[in] m         seq file
 310  * \param[in] v         unused for single entry
 311  *
 312  * \retval 0            on success
 313  * \retval negative     error code if failed
 314  */
 315 static int lod_activeobd_seq_show(struct seq_file *m, void *v)
 316 {
 317         struct obd_device *dev = m->private;
 318         struct lod_device *lod;
 319
 320         LASSERT(dev != NULL);
 321         lod  = lu2lod_dev(dev->obd_lu_dev);
 322         seq_printf(m, "%u\n", lod->lod_desc.ld_active_tgt_count);
 323         return 0;
 324 }
 325 LPROC_SEQ_FOPS_RO(lod_activeobd);
 326
 327 /**
 328  * Show UUID of LOD device.
 329  *
 330  * \param[in] m         seq file
 331  * \param[in] v         unused for single entry
 332  *
 333  * \retval 0            on success
 334  * \retval negative     error code if failed
 335  */
 336 static int lod_desc_uuid_seq_show(struct seq_file *m, void *v)
 337 {
 338         struct obd_device *dev = m->private;
 339         struct lod_device *lod;
 340
 341         LASSERT(dev != NULL);
 342         lod  = lu2lod_dev(dev->obd_lu_dev);
 343         seq_printf(m, "%s\n", lod->lod_desc.ld_uuid.uuid);
 344         return 0;
 345 }
 346 LPROC_SEQ_FOPS_RO(lod_desc_uuid);
 347
 348 /**
 349  * Show QoS priority parameter.
 350  *
 351  * The printed value is a percentage value (0-100%) indicating the priority
 352  * of free space compared to performance. 0% means select OSTs equally
 353  * regardless of their free space, 100% means select OSTs only by their free
 354  * space even if it results in very imbalanced load on the OSTs.
 355  *
 356  * \param[in] m         seq file
 357  * \param[in] v         unused for single entry
 358  *
 359  * \retval 0            on success
 360  * \retval negative     error code if failed
 361  */
 362 static int lod_qos_priofree_seq_show(struct seq_file *m, void *v)
 363 {
 364         struct obd_device *dev = m->private;
 365         struct lod_device *lod = lu2lod_dev(dev->obd_lu_dev);
 366
 367         LASSERT(lod != NULL);
 368         seq_printf(m, "%d%%\n",
 369                    (lod->lod_qos.lq_prio_free * 100 + 255) >> 8);
 370         return 0;
 371 }
 372
 373 /**
 374  * Set QoS free space priority parameter.
 375  *
 376  * Set the relative priority of free OST space compared to OST load when OSTs
 377  * are space imbalanced.  See lod_qos_priofree_seq_show() for description of
 378  * this parameter.  See lod_qos_thresholdrr_seq_write() and lq_threshold_rr to
 379  * determine what constitutes "space imbalanced" OSTs.
 380  *
 381  * \param[in] file      proc file
 382  * \param[in] buffer    string which contains the free space priority (0-100)
 383  * \param[in] count     @buffer length
 384  * \param[in] off       unused for single entry
 385  *
 386  * \retval @count       on success
 387  * \retval negative     error code if failed
 388  */
 389 static ssize_t
 390 lod_qos_priofree_seq_write(struct file *file, const char __user *buffer,
 391                            size_t count, loff_t *off)
 392 {
 393         struct seq_file *m = file->private_data;
 394         struct obd_device *dev = m->private;
 395         struct lod_device *lod;
 396         int rc;
 397         __s64 val;
 398
 399         LASSERT(dev != NULL);
 400         lod = lu2lod_dev(dev->obd_lu_dev);
 401
 402         rc = lprocfs_str_to_s64(buffer, count, &val);
 403         if (rc)
 404                 return rc;
 405
 406         if (val < 0 || val > 100)
 407                 return -EINVAL;
 408         lod->lod_qos.lq_prio_free = (val << 8) / 100;
 409         lod->lod_qos.lq_dirty = 1;
 410         lod->lod_qos.lq_reset = 1;
 411
 412         return count;
 413 }
 414 LPROC_SEQ_FOPS(lod_qos_priofree);
 415
 416 /**
 417  * Show threshold for "same space on all OSTs" rule.
 418  *
 419  * \param[in] m         seq file
 420  * \param[in] v         unused for single entry
 421  *
 422  * \retval 0            on success
 423  * \retval negative     error code if failed
 424  */
 425 static int lod_qos_thresholdrr_seq_show(struct seq_file *m, void *v)
 426 {
 427         struct obd_device *dev = m->private;
 428         struct lod_device *lod;
 429
 430         LASSERT(dev != NULL);
 431         lod = lu2lod_dev(dev->obd_lu_dev);
 432         seq_printf(m, "%d%%\n",
 433                    (lod->lod_qos.lq_threshold_rr * 100 + 255) >> 8);
 434         return 0;
 435 }
 436
 437 /**
 438  * Set threshold for "same space on all OSTs" rule.
 439  *
 440  * This sets the maximum percentage difference of free space between the most
 441  * full and most empty OST in the currently available OSTs. If this percentage
 442  * is exceeded, use the QoS allocator to select OSTs based on their available
 443  * space so that more full OSTs are chosen less often, otherwise use the
 444  * round-robin allocator for efficiency and performance.
 445
 446  * \param[in] file      proc file
 447  * \param[in] buffer    string containing percentage difference of free space
 448  * \param[in] count     @buffer length
 449  * \param[in] off       unused for single entry
 450  *
 451  * \retval @count       on success
 452  * \retval negative     error code if failed
 453  */
 454 static ssize_t
 455 lod_qos_thresholdrr_seq_write(struct file *file, const char __user *buffer,
 456                               size_t count, loff_t *off)
 457 {
 458         struct seq_file *m = file->private_data;
 459         struct obd_device *dev = m->private;
 460         struct lod_device *lod;
 461         int rc;
 462         __s64 val;
 463
 464         LASSERT(dev != NULL);
 465         lod = lu2lod_dev(dev->obd_lu_dev);
 466
 467         rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '%');
 468         if (rc)
 469                 return rc;
 470
 471         if (val > 100 || val < 0)
 472                 return -EINVAL;
 473
 474         lod->lod_qos.lq_threshold_rr = (val << 8) / 100;
 475         lod->lod_qos.lq_dirty = 1;
 476
 477         return count;
 478 }
 479 LPROC_SEQ_FOPS(lod_qos_thresholdrr);
 480
 481 /**
 482  * Show expiration period used to refresh cached statfs data, which
 483  * is used to implement QoS/RR striping allocation algorithm.
 484  *
 485  * \param[in] m         seq file
 486  * \param[in] v         unused for single entry
 487  *
 488  * \retval 0            on success
 489  * \retval negative     error code if failed
 490  */
 491 static int lod_qos_maxage_seq_show(struct seq_file *m, void *v)
 492 {
 493         struct obd_device *dev = m->private;
 494         struct lod_device *lod;
 495
 496         LASSERT(dev != NULL);
 497         lod = lu2lod_dev(dev->obd_lu_dev);
 498         seq_printf(m, "%u Sec\n", lod->lod_desc.ld_qos_maxage);
 499         return 0;
 500 }
 501
 502 /**
 503  * Set expiration period used to refresh cached statfs data.
 504  *
 505  * \param[in] file      proc file
 506  * \param[in] buffer    string contains maximum age of statfs data in seconds
 507  * \param[in] count     @buffer length
 508  * \param[in] off       unused for single entry
 509  *
 510  * \retval @count       on success
 511  * \retval negative     error code if failed
 512  */
 513 static ssize_t
 514 lod_qos_maxage_seq_write(struct file *file, const char __user *buffer,
 515                          size_t count, loff_t *off)
 516 {
 517         struct seq_file *m = file->private_data;
 518         struct obd_device *dev = m->private;
 519         struct lustre_cfg_bufs bufs;
 520         struct lod_device *lod;
 521         struct lu_device *next;
 522         struct lustre_cfg *lcfg;
 523         char str[32];
 524         unsigned int i;
 525         int rc;
 526         __s64 val;
 527
 528         LASSERT(dev != NULL);
 529         lod = lu2lod_dev(dev->obd_lu_dev);
 530
 531         rc = lprocfs_str_to_s64(buffer, count, &val);
 532         if (rc)
 533                 return rc;
 534
 535         if (val <= 0)
 536                 return -EINVAL;
 537         lod->lod_desc.ld_qos_maxage = val;
 538
 539         /*
 540          * propogate the value down to OSPs
 541          */
 542         lustre_cfg_bufs_reset(&bufs, NULL);
 543         snprintf(str, 32, "%smaxage=%u", PARAM_OSP, (__u32)val);
 544         lustre_cfg_bufs_set_string(&bufs, 1, str);
 545         OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
 546         if (lcfg == NULL)
 547                 return -ENOMEM;
 548         lustre_cfg_init(lcfg, LCFG_PARAM, &bufs);
 549
 550         lod_getref(&lod->lod_ost_descs);
 551         lod_foreach_ost(lod, i) {
 552                 next = &OST_TGT(lod,i)->ltd_ost->dd_lu_dev;
 553                 rc = next->ld_ops->ldo_process_config(NULL, next, lcfg);
 554                 if (rc)
 555                         CERROR("can't set maxage on #%d: %d\n", i, rc);
 556         }
 557         lod_putref(lod, &lod->lod_ost_descs);
 558         OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens));
 559
 560         return count;
 561 }
 562 LPROC_SEQ_FOPS(lod_qos_maxage);
 563
 564 static void *lod_osts_seq_start(struct seq_file *p, loff_t *pos)
 565 {
 566         struct obd_device *dev = p->private;
 567         struct lod_device *lod;
 568
 569         LASSERT(dev != NULL);
 570         lod = lu2lod_dev(dev->obd_lu_dev);
 571
 572         lod_getref(&lod->lod_ost_descs); /* released in lod_osts_seq_stop */
 573         if (*pos >= lod->lod_ost_bitmap->size)
 574                 return NULL;
 575
 576         *pos = find_next_bit(lod->lod_ost_bitmap->data,
 577                                  lod->lod_ost_bitmap->size, *pos);
 578         if (*pos < lod->lod_ost_bitmap->size)
 579                 return OST_TGT(lod,*pos);
 580         else
 581                 return NULL;
 582 }
 583
 584 static void lod_osts_seq_stop(struct seq_file *p, void *v)
 585 {
 586         struct obd_device *dev = p->private;
 587         struct lod_device *lod;
 588
 589         LASSERT(dev != NULL);
 590         lod = lu2lod_dev(dev->obd_lu_dev);
 591         lod_putref(lod, &lod->lod_ost_descs);
 592 }
 593
 594 static void *lod_osts_seq_next(struct seq_file *p, void *v, loff_t *pos)
 595 {
 596         struct obd_device *dev = p->private;
 597         struct lod_device *lod = lu2lod_dev(dev->obd_lu_dev);
 598
 599         if (*pos >= lod->lod_ost_bitmap->size - 1)
 600                 return NULL;
 601
 602         *pos = find_next_bit(lod->lod_ost_bitmap->data,
 603                                  lod->lod_ost_bitmap->size, *pos + 1);
 604         if (*pos < lod->lod_ost_bitmap->size)
 605                 return OST_TGT(lod,*pos);
 606         else
 607                 return NULL;
 608 }
 609
 610 /**
 611  * Show active/inactive status for OST found by lod_osts_seq_next().
 612  *
 613  * \param[in] m         seq file
 614  * \param[in] v         unused for single entry
 615  *
 616  * \retval 0            on success
 617  * \retval negative     error code if failed
 618  */
 619 static int lod_osts_seq_show(struct seq_file *p, void *v)
 620 {
 621         struct obd_device   *obd = p->private;
 622         struct lod_ost_desc *ost_desc = v;
 623         struct lod_device   *lod;
 624         int                  idx, rc, active;
 625         struct dt_device    *next;
 626         struct obd_statfs    sfs;
 627
 628         LASSERT(obd->obd_lu_dev);
 629         lod = lu2lod_dev(obd->obd_lu_dev);
 630
 631         idx = ost_desc->ltd_index;
 632         next = OST_TGT(lod,idx)->ltd_ost;
 633         if (next == NULL)
 634                 return -EINVAL;
 635
 636         /* XXX: should be non-NULL env, but it's very expensive */
 637         active = 1;
 638         rc = dt_statfs(NULL, next, &sfs);
 639         if (rc == -ENOTCONN) {
 640                 active = 0;
 641                 rc = 0;
 642         } else if (rc)
 643                 return rc;
 644
 645         seq_printf(p, "%d: %s %sACTIVE\n", idx,
 646                    obd_uuid2str(&ost_desc->ltd_uuid),
 647                    active ? "" : "IN");
 648         return 0;
 649 }
 650
 651 static const struct seq_operations lod_osts_sops = {
 652         .start  = lod_osts_seq_start,
 653         .stop   = lod_osts_seq_stop,
 654         .next   = lod_osts_seq_next,
 655         .show   = lod_osts_seq_show,
 656 };
 657
 658 static int lod_osts_seq_open(struct inode *inode, struct file *file)
 659 {
 660         struct seq_file *seq;
 661         int rc;
 662
 663         rc = seq_open(file, &lod_osts_sops);
 664         if (rc)
 665                 return rc;
 666
 667         seq = file->private_data;
 668         seq->private = PDE_DATA(inode);
 669         return 0;
 670 }
 671
 672 LPROC_SEQ_FOPS_RO_TYPE(lod, dt_blksize);
 673 LPROC_SEQ_FOPS_RO_TYPE(lod, dt_kbytestotal);
 674 LPROC_SEQ_FOPS_RO_TYPE(lod, dt_kbytesfree);
 675 LPROC_SEQ_FOPS_RO_TYPE(lod, dt_kbytesavail);
 676 LPROC_SEQ_FOPS_RO_TYPE(lod, dt_filestotal);
 677 LPROC_SEQ_FOPS_RO_TYPE(lod, dt_filesfree);
 678
 679 /**
 680  * Show whether special failout mode for testing is enabled or not.
 681  *
 682  * \param[in] m         seq file
 683  * \param[in] v         unused for single entry
 684  *
 685  * \retval 0            on success
 686  * \retval negative     error code if failed
 687  */
 688 static int lod_lmv_failout_seq_show(struct seq_file *m, void *v)
 689 {
 690         struct obd_device *dev = m->private;
 691         struct lod_device *lod;
 692
 693         LASSERT(dev != NULL);
 694         lod = lu2lod_dev(dev->obd_lu_dev);
 695
 696         seq_printf(m, "%d\n", lod->lod_lmv_failout ? 1 : 0);
 697         return 0;
 698 }
 699
 700 /**
 701  * Enable/disable a special failout mode for testing.
 702  *
 703  * This determines whether the LMV will try to continue processing a striped
 704  * directory even if it has a (partly) corrupted entry in the master directory,
 705  * or if it will abort upon finding a corrupted slave directory entry.
 706  *
 707  * \param[in] file      proc file
 708  * \param[in] buffer    string: 0 or non-zero to disable or enable LMV failout
 709  * \param[in] count     @buffer length
 710  * \param[in] off       unused for single entry
 711  *
 712  * \retval @count       on success
 713  * \retval negative     error code if failed
 714  */
 715 static ssize_t
 716 lod_lmv_failout_seq_write(struct file *file, const char __user *buffer,
 717                           size_t count, loff_t *off)
 718 {
 719         struct seq_file *m = file->private_data;
 720         struct obd_device *dev = m->private;
 721         struct lod_device *lod;
 722         __s64 val = 0;
 723         int rc;
 724
 725         LASSERT(dev != NULL);
 726         lod = lu2lod_dev(dev->obd_lu_dev);
 727
 728         rc = lprocfs_str_to_s64(buffer, count, &val);
 729         if (rc)
 730                 return rc;
 731
 732         lod->lod_lmv_failout = !!val;
 733
 734         return count;
 735 }
 736 LPROC_SEQ_FOPS(lod_lmv_failout);
 737
 738 static struct lprocfs_vars lprocfs_lod_obd_vars[] = {
 739         { .name =       "stripesize",
 740           .fops =       &lod_stripesize_fops    },
 741         { .name =       "stripeoffset",
 742           .fops =       &lod_stripeoffset_fops  },
 743         { .name =       "stripecount",
 744           .fops =       &lod_stripecount_fops   },
 745         { .name =       "stripetype",
 746           .fops =       &lod_stripetype_fops    },
 747         { .name =       "numobd",
 748           .fops =       &lod_numobd_fops        },
 749         { .name =       "activeobd",
 750           .fops =       &lod_activeobd_fops     },
 751         { .name =       "desc_uuid",
 752           .fops =       &lod_desc_uuid_fops     },
 753         { .name =       "qos_prio_free",
 754           .fops =       &lod_qos_priofree_fops  },
 755         { .name =       "qos_threshold_rr",
 756           .fops =       &lod_qos_thresholdrr_fops },
 757         { .name =       "qos_maxage",
 758           .fops =       &lod_qos_maxage_fops    },
 759         { .name =       "lmv_failout",
 760           .fops =       &lod_lmv_failout_fops   },
 761         { NULL }
 762 };
 763
 764 static struct lprocfs_vars lprocfs_lod_osd_vars[] = {
 765         { .name = "blocksize",   .fops = &lod_dt_blksize_fops },
 766         { .name = "kbytestotal", .fops = &lod_dt_kbytestotal_fops },
 767         { .name = "kbytesfree",  .fops = &lod_dt_kbytesfree_fops },
 768         { .name = "kbytesavail", .fops = &lod_dt_kbytesavail_fops },
 769         { .name = "filestotal",  .fops = &lod_dt_filestotal_fops },
 770         { .name = "filesfree",   .fops = &lod_dt_filesfree_fops },
 771         { .name = NULL }
 772 };
 773
 774 static const struct file_operations lod_proc_target_fops = {
 775         .owner   = THIS_MODULE,
 776         .open    = lod_osts_seq_open,
 777         .read    = seq_read,
 778         .llseek  = seq_lseek,
 779         .release = lprocfs_seq_release,
 780 };
 781
 782 /**
 783  * Initialize procfs entries for LOD.
 784  *
 785  * \param[in] lod       LOD device
 786  *
 787  * \retval 0            on success
 788  * \retval negative     error code if failed
 789  */
 790 int lod_procfs_init(struct lod_device *lod)
 791 {
 792         struct obd_device       *obd = lod2obd(lod);
 793         struct proc_dir_entry   *lov_proc_dir = NULL;
 794         struct obd_type         *type;
 795         int                      rc;
 796
 797         obd->obd_vars = lprocfs_lod_obd_vars;
 798         rc = lprocfs_obd_setup(obd, true);
 799         if (rc) {
 800                 CERROR("%s: cannot setup procfs entry: %d\n",
 801                        obd->obd_name, rc);
 802                 RETURN(rc);
 803         }
 804
 805         rc = lprocfs_add_vars(obd->obd_proc_entry, lprocfs_lod_osd_vars,
 806                               &lod->lod_dt_dev);
 807         if (rc) {
 808                 CERROR("%s: cannot setup procfs entry: %d\n",
 809                        obd->obd_name, rc);
 810                 GOTO(out, rc);
 811         }
 812
 813         rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd",
 814                                 0444, &lod_proc_target_fops, obd);
 815         if (rc) {
 816                 CWARN("%s: Error adding the target_obd file %d\n",
 817                       obd->obd_name, rc);
 818                 GOTO(out, rc);
 819         }
 820
 821         lod->lod_pool_proc_entry = lprocfs_register("pools",
 822                                                     obd->obd_proc_entry,
 823                                                     NULL, NULL);
 824         if (IS_ERR(lod->lod_pool_proc_entry)) {
 825                 rc = PTR_ERR(lod->lod_pool_proc_entry);
 826                 lod->lod_pool_proc_entry = NULL;
 827                 CWARN("%s: Failed to create pool proc file: %d\n",
 828                       obd->obd_name, rc);
 829                 GOTO(out, rc);
 830         }
 831
 832         /* If the real LOV is present which is the case for setups
 833          * with both server and clients on the same node then use
 834          * the LOV's proc root */
 835         type = class_search_type(LUSTRE_LOV_NAME);
 836         if (type != NULL && type->typ_procroot != NULL)
 837                 lov_proc_dir = type->typ_procroot;
 838         else
 839                 lov_proc_dir = obd->obd_type->typ_procsym;
 840
 841         if (lov_proc_dir == NULL)
 842                 RETURN(0);
 843
 844         /* for compatibility we link old procfs's LOV entries to lod ones */
 845         lod->lod_symlink = lprocfs_add_symlink(obd->obd_name, lov_proc_dir,
 846                                                "../lod/%s", obd->obd_name);
 847         if (lod->lod_symlink == NULL)
 848                 CERROR("cannot create LOV symlink for /proc/fs/lustre/lod/%s\n",
 849                        obd->obd_name);
 850         RETURN(0);
 851
 852 out:
 853         lprocfs_obd_cleanup(obd);
 854
 855         return rc;
 856 }
 857
 858 /**
 859  * Cleanup procfs entries registred for LOD.
 860  *
 861  * \param[in] lod       LOD device
 862  */
 863 void lod_procfs_fini(struct lod_device *lod)
 864 {
 865         struct obd_device *obd = lod2obd(lod);
 866
 867         if (lod->lod_symlink != NULL) {
 868                 lprocfs_remove(&lod->lod_symlink);
 869                 lod->lod_symlink = NULL;
 870         }
 871
 872         if (lod->lod_pool_proc_entry != NULL) {
 873                 lprocfs_remove(&lod->lod_pool_proc_entry);
 874                 lod->lod_pool_proc_entry = NULL;
 875         }
 876
 877         lprocfs_obd_cleanup(obd);
 878 }
 879
 880 #endif /* CONFIG_PROC_FS */
 881