lustre/osp/lproc_osp.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 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/osp/lproc_osp.c
  33  *
  34  * Lustre OST Proxy Device (OSP), procfs functions
  35  *
  36  * Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
  37  */
  38
  39 #define DEBUG_SUBSYSTEM S_CLASS
  40
  41 #include "osp_internal.h"
  42
  43 #ifdef CONFIG_PROC_FS
  44 /**
  45  * Show OSP active status
  46  *
  47  * \param[in] m         seq_file handle
  48  * \param[in] data      unused for single entry
  49  * \retval              0 on success
  50  * \retval              negative number on error
  51  */
  52 static int osp_active_seq_show(struct seq_file *m, void *data)
  53 {
  54         struct obd_device       *dev = m->private;
  55
  56         LPROCFS_CLIMP_CHECK(dev);
  57         seq_printf(m, "%d\n", !dev->u.cli.cl_import->imp_deactive);
  58         LPROCFS_CLIMP_EXIT(dev);
  59         return 0;
  60 }
  61
  62 /**
  63  * Activate/Deactivate OSP
  64  *
  65  * \param[in] file      proc file
  66  * \param[in] buffer    string, which is "1" or "0" to activate/deactivate OSP
  67  * \param[in] count     \a buffer length
  68  * \param[in] off       unused for single entry
  69  * \retval              \a count on success
  70  * \retval              negative number on error
  71  */
  72 static ssize_t
  73 osp_active_seq_write(struct file *file, const char __user *buffer,
  74                         size_t count, loff_t *off)
  75 {
  76         struct seq_file *m = file->private_data;
  77         struct obd_device *dev = m->private;
  78         int rc;
  79         __s64 val;
  80
  81         rc = lprocfs_str_to_s64(buffer, count, &val);
  82         if (rc)
  83                 return rc;
  84         if (val < 0 || val > 1)
  85                 return -ERANGE;
  86
  87         LPROCFS_CLIMP_CHECK(dev);
  88         /* opposite senses */
  89         if (dev->u.cli.cl_import->imp_deactive == val)
  90                 rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val);
  91         else
  92                 CDEBUG(D_CONFIG, "activate %lld: ignoring repeat request\n",
  93                        val);
  94
  95         LPROCFS_CLIMP_EXIT(dev);
  96         return count;
  97 }
  98 LPROC_SEQ_FOPS(osp_active);
  99
 100 /**
 101  * Show number of RPCs in flight
 102  *
 103  * \param[in] m         seq_file handle
 104  * \param[in] data      unused for single entry
 105  * \retval              0 on success
 106  * \retval              negative number on error
 107  */
 108 static int osp_sync_rpcs_in_flight_seq_show(struct seq_file *m, void *data)
 109 {
 110         struct obd_device       *dev = m->private;
 111         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 112
 113         if (osp == NULL)
 114                 return -EINVAL;
 115
 116         seq_printf(m, "%u\n", atomic_read(&osp->opd_sync_rpcs_in_flight));
 117         return 0;
 118 }
 119 LPROC_SEQ_FOPS_RO(osp_sync_rpcs_in_flight);
 120
 121 /**
 122  * Show number of RPCs in processing (including uncommitted by OST)
 123  *
 124  * \param[in] m         seq_file handle
 125  * \param[in] data      unused for single entry
 126  * \retval              0 on success
 127  * \retval              negative number on error
 128  */
 129 static int osp_sync_rpcs_in_progress_seq_show(struct seq_file *m, void *data)
 130 {
 131         struct obd_device       *dev = m->private;
 132         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 133
 134         if (osp == NULL)
 135                 return -EINVAL;
 136
 137         seq_printf(m, "%u\n", atomic_read(&osp->opd_sync_rpcs_in_progress));
 138         return 0;
 139 }
 140 LPROC_SEQ_FOPS_RO(osp_sync_rpcs_in_progress);
 141
 142 /**
 143  * Show number of changes to sync
 144  *
 145  * \param[in] m         seq_file handle
 146  * \param[in] data      unused for single entry
 147  * \retval              0 on success
 148  * \retval              negative number on error
 149  */
 150 static int osp_sync_changes_seq_show(struct seq_file *m, void *data)
 151 {
 152         struct obd_device       *dev = m->private;
 153         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 154
 155         if (osp == NULL)
 156                 return -EINVAL;
 157
 158         seq_printf(m, "%u\n", atomic_read(&osp->opd_sync_changes));
 159         return 0;
 160 }
 161
 162 /**
 163  * Sync changes
 164  *
 165  * \param[in] file      proc file
 166  * \param[in] buffer    unused because any input will do
 167  * \param[in] count     \a buffer length
 168  * \param[in] off       unused for single entry
 169  * \retval              \a count on success
 170  * \retval              negative number on error
 171  */
 172 static ssize_t osp_sync_changes_seq_write(struct file *file,
 173                                          const char __user *buffer,
 174                                          size_t count, loff_t *off)
 175 {
 176         struct seq_file         *m      = file->private_data;
 177         struct obd_device       *dev    = m->private;
 178         struct osp_device       *osp    = lu2osp_dev(dev->obd_lu_dev);
 179         struct lu_env            env;
 180         int                      rc;
 181
 182         rc = lu_env_init(&env, LCT_LOCAL);
 183         if (rc != 0)
 184                 return rc;
 185
 186         rc = dt_sync(&env, &osp->opd_dt_dev);
 187         lu_env_fini(&env);
 188
 189         return rc == 0 ? count : rc;
 190 }
 191 LPROC_SEQ_FOPS(osp_sync_changes);
 192
 193 /**
 194  * Show maximum number of RPCs in flight allowed
 195  *
 196  * \param[in] m         seq_file handle
 197  * \param[in] data      unused for single entry
 198  * \retval              0 on success
 199  * \retval              negative number on error
 200  */
 201 static int osp_max_rpcs_in_flight_seq_show(struct seq_file *m, void *data)
 202 {
 203         struct obd_device       *dev = m->private;
 204         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 205
 206         if (osp == NULL)
 207                 return -EINVAL;
 208
 209         seq_printf(m, "%u\n", osp->opd_sync_max_rpcs_in_flight);
 210         return 0;
 211 }
 212
 213 /**
 214  * Change maximum number of RPCs in flight allowed
 215  *
 216  * \param[in] file      proc file
 217  * \param[in] buffer    string which represents maximum number
 218  * \param[in] count     \a buffer length
 219  * \param[in] off       unused for single entry
 220  * \retval              \a count on success
 221  * \retval              negative number on error
 222  */
 223 static ssize_t
 224 osp_max_rpcs_in_flight_seq_write(struct file *file, const char __user *buffer,
 225                                 size_t count, loff_t *off)
 226 {
 227         struct seq_file *m = file->private_data;
 228         struct obd_device *dev = m->private;
 229         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
 230         int rc;
 231         __s64 val;
 232
 233         if (osp == NULL)
 234                 return -EINVAL;
 235
 236         rc = lprocfs_str_to_s64(buffer, count, &val);
 237         if (rc)
 238                 return rc;
 239
 240         if (val < 1 || val > INT_MAX)
 241                 return -ERANGE;
 242
 243         osp->opd_sync_max_rpcs_in_flight = val;
 244         return count;
 245 }
 246 LPROC_SEQ_FOPS(osp_max_rpcs_in_flight);
 247
 248 /**
 249  * Show maximum number of RPCs in processing allowed
 250  *
 251  * \param[in] m         seq_file handle
 252  * \param[in] data      unused
 253  * \retval              0 on success
 254  * \retval              negative number on error
 255  */
 256 static int osp_max_rpcs_in_progress_seq_show(struct seq_file *m, void *data)
 257 {
 258         struct obd_device       *dev = m->private;
 259         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 260
 261         if (osp == NULL)
 262                 return -EINVAL;
 263
 264         seq_printf(m, "%u\n", osp->opd_sync_max_rpcs_in_progress);
 265         return 0;
 266 }
 267
 268 /**
 269  * Change maximum number of RPCs in processing allowed
 270  *
 271  * \param[in] file      proc file
 272  * \param[in] buffer    string which represents maximum number
 273  * \param[in] count     \a buffer length
 274  * \param[in] off       unused for single entry
 275  * \retval              \a count on success
 276  * \retval              negative number on error
 277  */
 278 static ssize_t
 279 osp_max_rpcs_in_progress_seq_write(struct file *file, const char __user *buffer,
 280                                    size_t count, loff_t *off)
 281 {
 282         struct seq_file *m = file->private_data;
 283         struct obd_device *dev = m->private;
 284         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
 285         int rc;
 286         __s64 val;
 287
 288         if (osp == NULL)
 289                 return -EINVAL;
 290
 291         rc = lprocfs_str_to_s64(buffer, count, &val);
 292         if (rc)
 293                 return rc;
 294
 295         if (val < 1 || val > INT_MAX)
 296                 return -ERANGE;
 297
 298         osp->opd_sync_max_rpcs_in_progress = val;
 299
 300         return count;
 301 }
 302 LPROC_SEQ_FOPS(osp_max_rpcs_in_progress);
 303
 304 /**
 305  * Show number of objects to precreate next time
 306  *
 307  * \param[in] m         seq_file handle
 308  * \param[in] data      unused for single entry
 309  * \retval              0 on success
 310  * \retval              negative number on error
 311  */
 312 static int osp_create_count_seq_show(struct seq_file *m, void *data)
 313 {
 314         struct obd_device *obd = m->private;
 315         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 316
 317         if (osp == NULL || osp->opd_pre == NULL)
 318                 return 0;
 319
 320         seq_printf(m, "%d\n", osp->opd_pre_create_count);
 321         return 0;
 322 }
 323
 324 /**
 325  * Change number of objects to precreate next time
 326  *
 327  * \param[in] file      proc file
 328  * \param[in] buffer    string which represents number of objects to precreate
 329  * \param[in] count     \a buffer length
 330  * \param[in] off       unused for single entry
 331  * \retval              \a count on success
 332  * \retval              negative number on error
 333  */
 334 static ssize_t
 335 osp_create_count_seq_write(struct file *file, const char __user *buffer,
 336                                 size_t count, loff_t *off)
 337 {
 338         struct seq_file *m = file->private_data;
 339         struct obd_device *obd = m->private;
 340         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 341         int rc, i;
 342         __s64 val;
 343
 344         if (osp == NULL || osp->opd_pre == NULL)
 345                 return 0;
 346
 347         rc = lprocfs_str_to_s64(buffer, count, &val);
 348         if (rc)
 349                 return rc;
 350
 351         /* The MDT ALWAYS needs to limit the precreate count to
 352          * OST_MAX_PRECREATE, and the constant cannot be changed
 353          * because it is a value shared between the OSP and OST
 354          * that is the maximum possible number of objects that will
 355          * ever be handled by MDT->OST recovery processing.
 356          *
 357          * If the OST ever gets a request to delete more orphans,
 358          * this implies that something has gone badly on the MDT
 359          * and the OST will refuse to delete so much data from the
 360          * filesystem as a safety measure. */
 361         if (val < OST_MIN_PRECREATE || val > OST_MAX_PRECREATE)
 362                 return -ERANGE;
 363         if (val > osp->opd_pre_max_create_count)
 364                 return -ERANGE;
 365
 366         for (i = 1; (i << 1) <= val; i <<= 1)
 367                 ;
 368         osp->opd_pre_create_count = i;
 369
 370         return count;
 371 }
 372 LPROC_SEQ_FOPS(osp_create_count);
 373
 374 /**
 375  * Show maximum number of objects to precreate
 376  *
 377  * \param[in] m         seq_file handle
 378  * \param[in] data      unused for single entry
 379  * \retval              0 on success
 380  * \retval              negative number on error
 381  */
 382 static int osp_max_create_count_seq_show(struct seq_file *m, void *data)
 383 {
 384         struct obd_device *obd = m->private;
 385         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 386
 387         if (osp == NULL || osp->opd_pre == NULL)
 388                 return 0;
 389
 390         seq_printf(m, "%d\n", osp->opd_pre_max_create_count);
 391         return 0;
 392 }
 393
 394 /**
 395  * Change maximum number of objects to precreate
 396  *
 397  * \param[in] file      proc file
 398  * \param[in] buffer    string which represents maximum number
 399  * \param[in] count     \a buffer length
 400  * \param[in] off       unused for single entry
 401  * \retval              \a count on success
 402  * \retval              negative number on error
 403  */
 404 static ssize_t
 405 osp_max_create_count_seq_write(struct file *file, const char __user *buffer,
 406                                 size_t count, loff_t *off)
 407 {
 408         struct seq_file *m = file->private_data;
 409         struct obd_device *obd = m->private;
 410         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 411         int rc;
 412         __s64 val;
 413
 414         if (osp == NULL || osp->opd_pre == NULL)
 415                 return 0;
 416
 417         rc = lprocfs_str_to_s64(buffer, count, &val);
 418         if (rc)
 419                 return rc;
 420
 421         if (val < 0 || val > INT_MAX)
 422                 return -ERANGE;
 423         if (val > OST_MAX_PRECREATE)
 424                 return -ERANGE;
 425
 426         if (osp->opd_pre_create_count > val)
 427                 osp->opd_pre_create_count = val;
 428
 429         osp->opd_pre_max_create_count = val;
 430
 431         return count;
 432 }
 433 LPROC_SEQ_FOPS(osp_max_create_count);
 434
 435 /**
 436  * Show last id to assign in creation
 437  *
 438  * \param[in] m         seq_file handle
 439  * \param[in] data      unused for single entry
 440  * \retval              0 on success
 441  * \retval              negative number on error
 442  */
 443 static int osp_prealloc_next_id_seq_show(struct seq_file *m, void *data)
 444 {
 445         struct obd_device *obd = m->private;
 446         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 447         struct lu_fid *fid;
 448         __u64 id;
 449
 450         if (osp == NULL || osp->opd_pre == NULL)
 451                 return 0;
 452
 453         fid = &osp->opd_pre_used_fid;
 454         if (fid_is_idif(fid)) {
 455                 id = fid_idif_id(fid_seq(fid), fid_oid(fid), fid_ver(fid));
 456                 id++;
 457         } else {
 458                 id = unlikely(fid_oid(fid) == LUSTRE_DATA_SEQ_MAX_WIDTH) ?
 459                         1 : fid_oid(fid) + 1;
 460         }
 461
 462         seq_printf(m, "%llu\n", id);
 463         return 0;
 464 }
 465 LPROC_SEQ_FOPS_RO(osp_prealloc_next_id);
 466
 467 /**
 468  * Show last created id OST reported
 469  *
 470  * \param[in] m         seq_file handle
 471  * \param[in] data      unused for single entry
 472  * \retval              0 on success
 473  * \retval              negative number on error
 474  */
 475 static int osp_prealloc_last_id_seq_show(struct seq_file *m, void *data)
 476 {
 477         struct obd_device *obd = m->private;
 478         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 479         struct lu_fid *fid;
 480         __u64 id;
 481
 482         if (osp == NULL || osp->opd_pre == NULL)
 483                 return 0;
 484         fid = &osp->opd_pre_last_created_fid;
 485         id = fid_is_idif(fid) ?
 486                          fid_idif_id(fid_seq(fid), fid_oid(fid), fid_ver(fid)) :
 487                          fid_oid(fid);
 488
 489         seq_printf(m, "%llu\n", id);
 490         return 0;
 491 }
 492 LPROC_SEQ_FOPS_RO(osp_prealloc_last_id);
 493
 494 /**
 495  * Show next FID sequence to precreate
 496  *
 497  * \param[in] m         seq_file handle
 498  * \param[in] data      unused for single entry
 499  * \retval              0 on success
 500  * \retval              negative number on error
 501  */
 502 static int osp_prealloc_next_seq_seq_show(struct seq_file *m, void *data)
 503 {
 504         struct obd_device *obd = m->private;
 505         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 506         struct lu_fid *fid;
 507
 508         if (osp == NULL || osp->opd_pre == NULL)
 509                 return 0;
 510
 511         fid = &osp->opd_pre_used_fid;
 512         seq_printf(m, "%#llx\n", fid_is_idif(fid) ?
 513                    fid_seq(fid) & (~0xffff) : fid_seq(fid));
 514
 515         return 0;
 516 }
 517 LPROC_SEQ_FOPS_RO(osp_prealloc_next_seq);
 518
 519 /**
 520  * Show last created FID sequence OST reported
 521  *
 522  * \param[in] m         seq_file handle
 523  * \param[in] data      unused for single entry
 524  * \retval              0 on success
 525  * \retval              negative number on error
 526  */
 527 static int osp_prealloc_last_seq_seq_show(struct seq_file *m, void *data)
 528 {
 529         struct obd_device *obd = m->private;
 530         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 531         struct lu_fid *fid;
 532
 533         if (osp == NULL || osp->opd_pre == NULL)
 534                 return 0;
 535
 536         fid = &osp->opd_pre_last_created_fid;
 537         seq_printf(m, "%#llx\n", fid_is_idif(fid) ?
 538                    fid_seq(fid) & (~0xffff) : fid_seq(fid));
 539
 540         return 0;
 541 }
 542 LPROC_SEQ_FOPS_RO(osp_prealloc_last_seq);
 543
 544 /**
 545  * Show the number of ids reserved by declare
 546  *
 547  * \param[in] m         seq_file handle
 548  * \param[in] data      unused for single entry
 549  * \retval              0 on success
 550  * \retval              negative number on error
 551  */
 552 static int osp_prealloc_reserved_seq_show(struct seq_file *m, void *data)
 553 {
 554         struct obd_device *obd = m->private;
 555         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
 556
 557         if (osp == NULL || osp->opd_pre == NULL)
 558                 return 0;
 559
 560         seq_printf(m, "%llu\n", osp->opd_pre_reserved);
 561         return 0;
 562 }
 563 LPROC_SEQ_FOPS_RO(osp_prealloc_reserved);
 564
 565 /**
 566  * Show interval (in seconds) to update statfs data
 567  *
 568  * \param[in] m         seq_file handle
 569  * \param[in] data      unused for single entry
 570  * \retval              0 on success
 571  * \retval              negative number on error
 572  */
 573 static int osp_maxage_seq_show(struct seq_file *m, void *data)
 574 {
 575         struct obd_device       *dev = m->private;
 576         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 577
 578         if (osp == NULL)
 579                 return -EINVAL;
 580
 581         seq_printf(m, "%lld\n", osp->opd_statfs_maxage);
 582         return 0;
 583 }
 584
 585 /**
 586  * Change interval to update statfs data
 587  *
 588  * \param[in] file      proc file
 589  * \param[in] buffer    string which represents statfs interval (in seconds)
 590  * \param[in] count     \a buffer length
 591  * \param[in] off       unused for single entry
 592  * \retval              \a count on success
 593  * \retval              negative number on error
 594  */
 595 static ssize_t
 596 osp_maxage_seq_write(struct file *file, const char __user *buffer,
 597                         size_t count, loff_t *off)
 598 {
 599         struct seq_file *m = file->private_data;
 600         struct obd_device *dev = m->private;
 601         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
 602         int rc;
 603         __s64 val;
 604
 605         if (osp == NULL)
 606                 return -EINVAL;
 607
 608         rc = lprocfs_str_to_s64(buffer, count, &val);
 609         if (rc)
 610                 return rc;
 611
 612         if (val < 1 || val > INT_MAX)
 613                 return -ERANGE;
 614
 615         osp->opd_statfs_maxage = val;
 616
 617         return count;
 618 }
 619 LPROC_SEQ_FOPS(osp_maxage);
 620
 621 /**
 622  * Show current precreation status: output 0 means success, otherwise negative
 623  * number is printed
 624  *
 625  * \param[in] m         seq_file handle
 626  * \param[in] data      unused for single entry
 627  * \retval              0 on success
 628  * \retval              negative number on error
 629  */
 630 static int osp_pre_status_seq_show(struct seq_file *m, void *data)
 631 {
 632         struct obd_device       *dev = m->private;
 633         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 634
 635         if (osp == NULL || osp->opd_pre == NULL)
 636                 return -EINVAL;
 637
 638         seq_printf(m, "%d\n", osp->opd_pre_status);
 639         return 0;
 640 }
 641 LPROC_SEQ_FOPS_RO(osp_pre_status);
 642
 643 /**
 644  * Show the number of RPCs in processing (including uncommitted by OST) plus
 645  * changes to sync, i.e. this is the total number of changes OST needs to apply
 646  * and commit.
 647  *
 648  * This counter is used to determine if OST has space returned. A zero value
 649  * indicates that OST storage space consumed by destroyed objects has been freed
 650  * on disk, the associated llog records have been cleared, and no synchronous
 651  * RPC are being processed.
 652  *
 653  * \param[in] m         seq_file handle
 654  * \param[in] data      unused for single entry
 655  * \retval              0 on success
 656  * \retval              negative number on error
 657  */
 658 static int osp_destroys_in_flight_seq_show(struct seq_file *m, void *data)
 659 {
 660         struct obd_device *dev = m->private;
 661         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
 662
 663         if (osp == NULL)
 664                 return -EINVAL;
 665
 666         seq_printf(m, "%u\n",
 667                    atomic_read(&osp->opd_sync_rpcs_in_progress) +
 668                    atomic_read(&osp->opd_sync_changes));
 669         return 0;
 670 }
 671 LPROC_SEQ_FOPS_RO(osp_destroys_in_flight);
 672
 673 /**
 674  * Show changes synced from previous mount
 675  *
 676  * \param[in] m         seq_file handle
 677  * \param[in] data      unused for single entry
 678  * \retval              0 on success
 679  * \retval              negative number on error
 680  */
 681 static int osp_old_sync_processed_seq_show(struct seq_file *m, void *data)
 682 {
 683         struct obd_device       *dev = m->private;
 684         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 685
 686         if (osp == NULL)
 687                 return -EINVAL;
 688
 689         seq_printf(m, "%d\n", osp->opd_sync_prev_done);
 690         return 0;
 691 }
 692 LPROC_SEQ_FOPS_RO(osp_old_sync_processed);
 693
 694 /**
 695  * Show maximum number of RPCs in flight
 696  *
 697  * \param[in] m         seq_file handle
 698  * \param[in] data      unused for single entry
 699  * \retval              0 on success
 700  * \retval              negative number on error
 701  */
 702 static int
 703 osp_lfsck_max_rpcs_in_flight_seq_show(struct seq_file *m, void *data)
 704 {
 705         struct obd_device *dev = m->private;
 706         __u32 max;
 707
 708         max = obd_get_max_rpcs_in_flight(&dev->u.cli);
 709         seq_printf(m, "%u\n", max);
 710         return 0;
 711 }
 712
 713 /**
 714  * Change maximum number of RPCs in flight
 715  *
 716  * \param[in] file      proc file
 717  * \param[in] buffer    string which represents maximum number of RPCs in flight
 718  * \param[in] count     \a buffer length
 719  * \param[in] off       unused for single entry
 720  * \retval              \a count on success
 721  * \retval              negative number on error
 722  */
 723 static ssize_t
 724 osp_lfsck_max_rpcs_in_flight_seq_write(struct file *file,
 725                                        const char __user *buffer,
 726                                        size_t count, loff_t *off)
 727 {
 728         struct seq_file   *m = file->private_data;
 729         struct obd_device *dev = m->private;
 730         __s64 val;
 731         int rc;
 732
 733         rc = lprocfs_str_to_s64(buffer, count, &val);
 734         if (rc == 0) {
 735                 if (val < 0)
 736                         return -ERANGE;
 737
 738                 rc = obd_set_max_rpcs_in_flight(&dev->u.cli, val);
 739         } else {
 740                 count = rc;
 741         }
 742
 743         return count;
 744 }
 745 LPROC_SEQ_FOPS(osp_lfsck_max_rpcs_in_flight);
 746
 747 LPROC_SEQ_FOPS_WR_ONLY(osp, ping);
 748 LPROC_SEQ_FOPS_RO_TYPE(osp, connect_flags);
 749 LPROC_SEQ_FOPS_RO_TYPE(osp, server_uuid);
 750 LPROC_SEQ_FOPS_RO_TYPE(osp, conn_uuid);
 751
 752 LPROC_SEQ_FOPS_RO_TYPE(osp, timeouts);
 753
 754 LPROC_SEQ_FOPS_RW_TYPE(osp, import);
 755 LPROC_SEQ_FOPS_RO_TYPE(osp, state);
 756
 757 /**
 758  * Show high watermark (in megabytes). If available free space at OST is grater
 759  * than high watermark and object allocation for OST is disabled, enable it.
 760  *
 761  * \param[in] m         seq_file handle
 762  * \param[in] data      unused for single entry
 763  * \retval              0 on success
 764  * \retval              negative number on error
 765  */
 766 static int osp_reserved_mb_high_seq_show(struct seq_file *m, void *data)
 767 {
 768         struct obd_device       *dev = m->private;
 769         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 770
 771         if (osp == NULL)
 772                 return -EINVAL;
 773
 774         seq_printf(m, "%u\n", osp->opd_reserved_mb_high);
 775         return 0;
 776 }
 777
 778 /**
 779  * Change high watermark
 780  *
 781  * \param[in] file      proc file
 782  * \param[in] buffer    string which represents new value (in megabytes)
 783  * \param[in] count     \a buffer length
 784  * \param[in] off       unused for single entry
 785  * \retval              \a count on success
 786  * \retval              negative number on error
 787  */
 788 static ssize_t
 789 osp_reserved_mb_high_seq_write(struct file *file, const char __user *buffer,
 790                         size_t count, loff_t *off)
 791 {
 792         struct seq_file         *m = file->private_data;
 793         struct obd_device       *dev = m->private;
 794         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 795         __s64                   val;
 796         int                     rc;
 797
 798         if (osp == NULL)
 799                 return -EINVAL;
 800
 801         rc = lprocfs_str_with_units_to_s64(buffer, count, &val, 'M');
 802         if (rc)
 803                 return rc;
 804         val >>= 20;
 805         if (val < 1)
 806                 return -ERANGE;
 807
 808         spin_lock(&osp->opd_pre_lock);
 809         osp->opd_reserved_mb_high = val;
 810         if (val <= osp->opd_reserved_mb_low)
 811                 osp->opd_reserved_mb_low = val - 1;
 812         spin_unlock(&osp->opd_pre_lock);
 813
 814         return count;
 815 }
 816 LPROC_SEQ_FOPS(osp_reserved_mb_high);
 817
 818 /**
 819  * Show low watermark (in megabytes). If available free space at OST is less
 820  * than low watermark, object allocation for OST is disabled.
 821  *
 822  * \param[in] m         seq_file handle
 823  * \param[in] data      unused for single entry
 824  * \retval              0 on success
 825  * \retval              negative number on error
 826  */
 827 static int osp_reserved_mb_low_seq_show(struct seq_file *m, void *data)
 828 {
 829         struct obd_device       *dev = m->private;
 830         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 831
 832         if (osp == NULL)
 833                 return -EINVAL;
 834
 835         seq_printf(m, "%u\n", osp->opd_reserved_mb_low);
 836         return 0;
 837 }
 838
 839 /**
 840  * Change low watermark
 841  *
 842  * \param[in] file      proc file
 843  * \param[in] buffer    string which represents new value (in megabytes)
 844  * \param[in] count     \a buffer length
 845  * \param[in] off       unused for single entry
 846  * \retval              \a count on success
 847  * \retval              negative number on error
 848  */
 849 static ssize_t
 850 osp_reserved_mb_low_seq_write(struct file *file, const char __user *buffer,
 851                         size_t count, loff_t *off)
 852 {
 853         struct seq_file         *m = file->private_data;
 854         struct obd_device       *dev = m->private;
 855         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
 856         __s64                   val;
 857         int                     rc;
 858
 859         if (osp == NULL)
 860                 return -EINVAL;
 861
 862         rc = lprocfs_str_with_units_to_s64(buffer, count, &val, 'M');
 863         if (rc)
 864                 return rc;
 865         val >>= 20;
 866
 867         spin_lock(&osp->opd_pre_lock);
 868         osp->opd_reserved_mb_low = val;
 869         if (val >= osp->opd_reserved_mb_high)
 870                 osp->opd_reserved_mb_high = val + 1;
 871         spin_unlock(&osp->opd_pre_lock);
 872
 873         return count;
 874 }
 875 LPROC_SEQ_FOPS(osp_reserved_mb_low);
 876
 877 static ssize_t
 878 lprocfs_force_sync_seq_write(struct file *file, const char __user *buffer,
 879                              size_t count, loff_t *off)
 880 {
 881         struct seq_file   *m = file->private_data;
 882         struct obd_device *dev = m->private;
 883         struct dt_device  *dt = lu2dt_dev(dev->obd_lu_dev);
 884         struct lu_env      env;
 885         int                rc;
 886
 887         rc = lu_env_init(&env, LCT_LOCAL);
 888         if (rc)
 889                 return rc;
 890         rc = dt_sync(&env, dt);
 891         lu_env_fini(&env);
 892
 893         return rc == 0 ? count : rc;
 894 }
 895 LPROC_SEQ_FOPS_WR_ONLY(osp, force_sync);
 896
 897 static struct lprocfs_vars lprocfs_osp_obd_vars[] = {
 898         { .name =       "ping",
 899           .fops =       &osp_ping_fops,
 900           .proc_mode =  0222                            },
 901         { .name =       "connect_flags",
 902           .fops =       &osp_connect_flags_fops         },
 903         { .name =       "ost_server_uuid",
 904           .fops =       &osp_server_uuid_fops           },
 905         { .name =       "ost_conn_uuid",
 906           .fops =       &osp_conn_uuid_fops             },
 907         { .name =       "active",
 908           .fops =       &osp_active_fops                },
 909         { .name =       "max_rpcs_in_flight",
 910           .fops =       &osp_max_rpcs_in_flight_fops    },
 911         { .name =       "max_rpcs_in_progress",
 912           .fops =       &osp_max_rpcs_in_progress_fops  },
 913         { .name =       "create_count",
 914           .fops =       &osp_create_count_fops          },
 915         { .name =       "max_create_count",
 916           .fops =       &osp_max_create_count_fops      },
 917         { .name =       "prealloc_next_id",
 918           .fops =       &osp_prealloc_next_id_fops      },
 919         { .name =       "prealloc_next_seq",
 920           .fops =       &osp_prealloc_next_seq_fops     },
 921         { .name =       "prealloc_last_id",
 922           .fops =       &osp_prealloc_last_id_fops      },
 923         { .name =       "prealloc_last_seq",
 924           .fops =       &osp_prealloc_last_seq_fops     },
 925         { .name =       "prealloc_reserved",
 926           .fops =       &osp_prealloc_reserved_fops     },
 927         { .name =       "timeouts",
 928           .fops =       &osp_timeouts_fops              },
 929         { .name =       "import",
 930           .fops =       &osp_import_fops                },
 931         { .name =       "state",
 932           .fops =       &osp_state_fops                 },
 933         { .name =       "maxage",
 934           .fops =       &osp_maxage_fops                },
 935         { .name =       "prealloc_status",
 936           .fops =       &osp_pre_status_fops            },
 937         { .name =       "sync_changes",
 938           .fops =       &osp_sync_changes_fops          },
 939         { .name =       "sync_in_flight",
 940           .fops =       &osp_sync_rpcs_in_flight_fops   },
 941         { .name =       "sync_in_progress",
 942           .fops =       &osp_sync_rpcs_in_progress_fops },
 943         { .name =       "old_sync_processed",
 944           .fops =       &osp_old_sync_processed_fops    },
 945         { .name =       "reserved_mb_high",
 946           .fops =       &osp_reserved_mb_high_fops      },
 947         { .name =       "reserved_mb_low",
 948           .fops =       &osp_reserved_mb_low_fops       },
 949         { .name =       "force_sync",
 950           .fops =       &osp_force_sync_fops    },
 951
 952         /* for compatibility reasons */
 953         { .name =       "destroys_in_flight",
 954           .fops =       &osp_destroys_in_flight_fops            },
 955         { .name =       "lfsck_max_rpcs_in_flight",
 956           .fops =       &osp_lfsck_max_rpcs_in_flight_fops      },
 957         { NULL }
 958 };
 959
 960 static struct lprocfs_vars lprocfs_osp_md_vars[] = {
 961         { .name =       "ping",
 962           .fops =       &osp_ping_fops,
 963           .proc_mode =  0222                            },
 964         { .name =       "connect_flags",
 965           .fops =       &osp_connect_flags_fops         },
 966         { .name =       "mdt_server_uuid",
 967           .fops =       &osp_server_uuid_fops           },
 968         { .name =       "mdt_conn_uuid",
 969           .fops =       &osp_conn_uuid_fops             },
 970         { .name =       "active",
 971           .fops =       &osp_active_fops                },
 972         { .name =       "max_rpcs_in_flight",
 973           .fops =       &osp_max_rpcs_in_flight_fops    },
 974         { .name =       "max_rpcs_in_progress",
 975           .fops =       &osp_max_rpcs_in_progress_fops  },
 976         { .name =       "timeouts",
 977           .fops =       &osp_timeouts_fops              },
 978         { .name =       "import",
 979           .fops =       &osp_import_fops                },
 980         { .name =       "state",
 981           .fops =       &osp_state_fops                 },
 982         { .name =       "maxage",
 983           .fops =       &osp_maxage_fops                },
 984         { .name =       "prealloc_status",
 985           .fops =       &osp_pre_status_fops            },
 986
 987         /* for compatibility reasons */
 988         { .name =       "destroys_in_flight",
 989           .fops =       &osp_destroys_in_flight_fops            },
 990         { .name =       "lfsck_max_rpcs_in_flight",
 991           .fops =       &osp_lfsck_max_rpcs_in_flight_fops      },
 992         { NULL }
 993 };
 994
 995 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_blksize);
 996 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_kbytestotal);
 997 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_kbytesfree);
 998 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_kbytesavail);
 999 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_filestotal);
1000 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_filesfree);
1001
1002 static struct lprocfs_vars lprocfs_osp_osd_vars[] = {
1003         { .name =       "blocksize",
1004           .fops =       &osp_dt_blksize_fops            },
1005         { .name =       "kbytestotal",
1006           .fops =       &osp_dt_kbytestotal_fops        },
1007         { .name =       "kbytesfree",
1008           .fops =       &osp_dt_kbytesfree_fops         },
1009         { .name =       "kbytesavail",
1010           .fops =       &osp_dt_kbytesavail_fops        },
1011         { .name =       "filestotal",
1012           .fops =       &osp_dt_filestotal_fops         },
1013         { .name =       "filesfree",
1014           .fops =       &osp_dt_filesfree_fops          },
1015         { NULL }
1016 };
1017
1018 /**
1019  * Initialize OSP lprocfs
1020  *
1021  * param[in] osp        OSP device
1022  */
1023 void osp_lprocfs_init(struct osp_device *osp)
1024 {
1025         struct obd_device       *obd = osp->opd_obd;
1026         struct proc_dir_entry   *osc_proc_dir = NULL;
1027         struct obd_type         *type;
1028         int                      rc;
1029
1030         if (osp->opd_connect_mdt)
1031                 obd->obd_vars = lprocfs_osp_md_vars;
1032         else
1033                 obd->obd_vars = lprocfs_osp_obd_vars;
1034         if (lprocfs_obd_setup(obd, true) != 0)
1035                 return;
1036
1037         rc = lprocfs_add_vars(obd->obd_proc_entry, lprocfs_osp_osd_vars,
1038                               &osp->opd_dt_dev);
1039         if (rc) {
1040                 CERROR("%s: can't register in lprocfs, rc %d\n",
1041                        obd->obd_name, rc);
1042                 return;
1043         }
1044
1045         sptlrpc_lprocfs_cliobd_attach(obd);
1046         ptlrpc_lprocfs_register_obd(obd);
1047
1048         if (osp->opd_connect_mdt || !strstr(obd->obd_name, "osc"))
1049                 return;
1050
1051         /* If the real OSC is present which is the case for setups
1052          * with both server and clients on the same node then use
1053          * the OSC's proc root */
1054         type = class_search_type(LUSTRE_OSC_NAME);
1055         if (type != NULL && type->typ_procroot != NULL)
1056                 osc_proc_dir = type->typ_procroot;
1057         else
1058                 osc_proc_dir = obd->obd_type->typ_procsym;
1059
1060         if (osc_proc_dir == NULL)
1061                 return;
1062
1063         /* for compatibility we link old procfs's OSC entries to osp ones */
1064         osp->opd_symlink = lprocfs_add_symlink(obd->obd_name, osc_proc_dir,
1065                                                "../osp/%s", obd->obd_name);
1066         if (osp->opd_symlink == NULL)
1067                 CERROR("cannot create OSC symlink for /proc/fs/lustre/osp/%s\n",
1068                        obd->obd_name);
1069 }
1070
1071 #endif /* CONFIG_PROC_FS */
1072