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.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2012, Intel Corporation.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/ofd/lproc_ofd.c
  37  */
  38
  39 #define DEBUG_SUBSYSTEM S_CLASS
  40
  41 #include <obd.h>
  42 #include <lprocfs_status.h>
  43 #include <linux/seq_file.h>
  44
  45 #include "ofd_internal.h"
  46
  47 #ifdef LPROCFS
  48
  49 static int lprocfs_ofd_rd_seqs(char *page, char **start, off_t off,
  50                                 int count, int *eof, void *data)
  51 {
  52         struct obd_device *obd = (struct obd_device *)data;
  53         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
  54
  55         *eof = 1;
  56         return snprintf(page, count, "%u\n", ofd->ofd_seq_count);
  57 }
  58
  59 static int lprocfs_ofd_rd_tot_dirty(char *page, char **start, off_t off,
  60                                     int count, int *eof, void *data)
  61 {
  62         struct obd_device *obd = (struct obd_device *)data;
  63         struct ofd_device *ofd;
  64
  65         LASSERT(obd != NULL);
  66         ofd = ofd_dev(obd->obd_lu_dev);
  67         *eof = 1;
  68         return snprintf(page, count, LPU64"\n", ofd->ofd_tot_dirty);
  69 }
  70
  71 static int lprocfs_ofd_rd_tot_granted(char *page, char **start, off_t off,
  72                                       int count, int *eof, void *data)
  73 {
  74         struct obd_device *obd = (struct obd_device *)data;
  75         struct ofd_device *ofd;
  76
  77         LASSERT(obd != NULL);
  78         ofd = ofd_dev(obd->obd_lu_dev);
  79         *eof = 1;
  80         return snprintf(page, count, LPU64"\n", ofd->ofd_tot_granted);
  81 }
  82
  83 static int lprocfs_ofd_rd_tot_pending(char *page, char **start, off_t off,
  84                                       int count, int *eof, void *data)
  85 {
  86         struct obd_device *obd = (struct obd_device *)data;
  87         struct ofd_device *ofd;
  88
  89         LASSERT(obd != NULL);
  90         ofd = ofd_dev(obd->obd_lu_dev);
  91         *eof = 1;
  92         return snprintf(page, count, LPU64"\n", ofd->ofd_tot_pending);
  93 }
  94
  95 static int lprocfs_ofd_rd_grant_precreate(char *page, char **start, off_t off,
  96                                           int count, int *eof, void *data)
  97 {
  98         struct obd_device *obd = (struct obd_device *)data;
  99
 100         LASSERT(obd != NULL);
 101         *eof = 1;
 102         return snprintf(page, count, "%ld\n",
 103                         obd->obd_self_export->exp_filter_data.fed_grant);
 104 }
 105
 106 static int lprocfs_ofd_rd_grant_ratio(char *page, char **start, off_t off,
 107                                       int count, int *eof, void *data)
 108 {
 109         struct obd_device *obd = (struct obd_device *)data;
 110         struct ofd_device *ofd;
 111
 112         LASSERT(obd != NULL);
 113         ofd = ofd_dev(obd->obd_lu_dev);
 114         *eof = 1;
 115         return snprintf(page, count, "%d%%\n",
 116                         (int) ofd_grant_reserved(ofd, 100));
 117 }
 118
 119 static int lprocfs_ofd_wr_grant_ratio(struct file *file, const char *buffer,
 120                                       unsigned long count, void *data)
 121 {
 122         struct obd_device       *obd = (struct obd_device *)data;
 123         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 124         int                      val;
 125         int                      rc;
 126
 127         rc = lprocfs_write_helper(buffer, count, &val);
 128         if (rc)
 129                 return rc;
 130
 131         if (val > 100 || val < 0)
 132                 return -EINVAL;
 133
 134         if (val == 0)
 135                 CWARN("%s: disabling grant error margin\n", obd->obd_name);
 136         if (val > 50)
 137                 CWARN("%s: setting grant error margin >50%%, be warned that "
 138                       "a huge part of the free space is now reserved for "
 139                       "grants\n", obd->obd_name);
 140
 141         spin_lock(&ofd->ofd_grant_lock);
 142         ofd->ofd_grant_ratio = ofd_grant_ratio_conv(val);
 143         spin_unlock(&ofd->ofd_grant_lock);
 144         return count;
 145 }
 146
 147 static int lprocfs_ofd_rd_precreate_batch(char *page, char **start, off_t off,
 148                                           int count, int *eof, void *data)
 149 {
 150         struct obd_device *obd = (struct obd_device *)data;
 151         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 152
 153         LASSERT(obd != NULL);
 154         *eof = 1;
 155         return snprintf(page, count, "%d\n", ofd->ofd_precreate_batch);
 156 }
 157
 158 static int lprocfs_ofd_wr_precreate_batch(struct file *file, const char *buffer,
 159                                           unsigned long count, void *data)
 160 {
 161         struct obd_device *obd = (struct obd_device *)data;
 162         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 163         int val;
 164         int rc;
 165
 166         rc = lprocfs_write_helper(buffer, count, &val);
 167         if (rc)
 168                 return rc;
 169
 170         if (val < 1)
 171                 return -EINVAL;
 172
 173         spin_lock(&ofd->ofd_batch_lock);
 174         ofd->ofd_precreate_batch = val;
 175         spin_unlock(&ofd->ofd_batch_lock);
 176         return count;
 177 }
 178
 179 static int lprocfs_ofd_rd_last_id(char *page, char **start, off_t off,
 180                                   int count, int *eof, void *data)
 181 {
 182         struct obd_device       *obd = data;
 183         struct ofd_device       *ofd;
 184         struct ofd_seq          *oseq = NULL;
 185         int                     retval = 0, rc;
 186
 187         if (obd == NULL)
 188                 return 0;
 189
 190         ofd = ofd_dev(obd->obd_lu_dev);
 191
 192         read_lock(&ofd->ofd_seq_list_lock);
 193         cfs_list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
 194                 rc = snprintf(page, count, DOSTID"\n", POSTID(&oseq->os_oi));
 195                 if (rc < 0) {
 196                         retval = rc;
 197                         break;
 198                 }
 199                 page += rc;
 200                 count -= rc;
 201                 retval += rc;
 202         }
 203         read_unlock(&ofd->ofd_seq_list_lock);
 204         return retval;
 205 }
 206
 207 int lprocfs_ofd_rd_fmd_max_num(char *page, char **start, off_t off,
 208                                int count, int *eof, void *data)
 209 {
 210         struct obd_device       *obd = data;
 211         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 212         int                      rc;
 213
 214         rc = snprintf(page, count, "%u\n", ofd->ofd_fmd_max_num);
 215         return rc;
 216 }
 217
 218 int lprocfs_ofd_wr_fmd_max_num(struct file *file, const char *buffer,
 219                                unsigned long count, void *data)
 220 {
 221         struct obd_device       *obd = data;
 222         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 223         int                      val;
 224         int                      rc;
 225
 226         rc = lprocfs_write_helper(buffer, count, &val);
 227         if (rc)
 228                 return rc;
 229
 230         if (val > 65536 || val < 1)
 231                 return -EINVAL;
 232
 233         ofd->ofd_fmd_max_num = val;
 234         return count;
 235 }
 236
 237 int lprocfs_ofd_rd_fmd_max_age(char *page, char **start, off_t off,
 238                                int count, int *eof, void *data)
 239 {
 240         struct obd_device       *obd = data;
 241         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 242         int                      rc;
 243
 244         rc = snprintf(page, count, "%ld\n", ofd->ofd_fmd_max_age / CFS_HZ);
 245         return rc;
 246 }
 247
 248 int lprocfs_ofd_wr_fmd_max_age(struct file *file, const char *buffer,
 249                                unsigned long count, void *data)
 250 {
 251         struct obd_device       *obd = data;
 252         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 253         int                      val;
 254         int                      rc;
 255
 256         rc = lprocfs_write_helper(buffer, count, &val);
 257         if (rc)
 258                 return rc;
 259
 260         if (val > 65536 || val < 1)
 261                 return -EINVAL;
 262
 263         ofd->ofd_fmd_max_age = val * CFS_HZ;
 264         return count;
 265 }
 266
 267 static int lprocfs_ofd_rd_capa(char *page, char **start, off_t off,
 268                                int count, int *eof, void *data)
 269 {
 270         struct obd_device       *obd = data;
 271         int                      rc;
 272
 273         rc = snprintf(page, count, "capability on: %s\n",
 274                       obd->u.filter.fo_fl_oss_capa ? "oss" : "");
 275         return rc;
 276 }
 277
 278 static int lprocfs_ofd_wr_capa(struct file *file, const char *buffer,
 279                                unsigned long count, void *data)
 280 {
 281         struct obd_device       *obd = data;
 282         int                      val, rc;
 283
 284         rc = lprocfs_write_helper(buffer, count, &val);
 285         if (rc)
 286                 return rc;
 287
 288         if (val & ~0x1) {
 289                 CERROR("invalid capability mode, only 0/1 are accepted.\n"
 290                        " 1: enable oss fid capability\n"
 291                        " 0: disable oss fid capability\n");
 292                 return -EINVAL;
 293         }
 294
 295         obd->u.filter.fo_fl_oss_capa = val;
 296         LCONSOLE_INFO("OSS %s %s fid capability.\n", obd->obd_name,
 297                       val ? "enabled" : "disabled");
 298         return count;
 299 }
 300
 301 static int lprocfs_ofd_rd_capa_count(char *page, char **start, off_t off,
 302                                      int count, int *eof, void *data)
 303 {
 304         return snprintf(page, count, "%d %d\n",
 305                         capa_count[CAPA_SITE_CLIENT],
 306                         capa_count[CAPA_SITE_SERVER]);
 307 }
 308
 309 int lprocfs_ofd_rd_degraded(char *page, char **start, off_t off,
 310                             int count, int *eof, void *data)
 311 {
 312         struct obd_device *obd = data;
 313         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 314
 315         return snprintf(page, count, "%u\n", ofd->ofd_raid_degraded);
 316 }
 317
 318 int lprocfs_ofd_wr_degraded(struct file *file, const char *buffer,
 319                             unsigned long count, void *data)
 320 {
 321         struct obd_device       *obd = data;
 322         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 323         int                      val, rc;
 324
 325         rc = lprocfs_write_helper(buffer, count, &val);
 326         if (rc)
 327                 return rc;
 328
 329         spin_lock(&ofd->ofd_flags_lock);
 330         ofd->ofd_raid_degraded = !!val;
 331         spin_unlock(&ofd->ofd_flags_lock);
 332
 333         return count;
 334 }
 335
 336 int lprocfs_ofd_rd_fstype(char *page, char **start, off_t off, int count,
 337                           int *eof, void *data)
 338 {
 339         struct obd_device *obd = data;
 340         struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 341         struct lu_device  *d;
 342
 343         LASSERT(ofd->ofd_osd);
 344         d = &ofd->ofd_osd->dd_lu_dev;
 345         LASSERT(d->ld_type);
 346         return snprintf(page, count, "%s\n", d->ld_type->ldt_name);
 347 }
 348
 349 int lprocfs_ofd_rd_syncjournal(char *page, char **start, off_t off,
 350                                int count, int *eof, void *data)
 351 {
 352         struct obd_device       *obd = data;
 353         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 354         int                      rc;
 355
 356         rc = snprintf(page, count, "%u\n", ofd->ofd_syncjournal);
 357         return rc;
 358 }
 359
 360 int lprocfs_ofd_wr_syncjournal(struct file *file, const char *buffer,
 361                                unsigned long count, void *data)
 362 {
 363         struct obd_device       *obd = data;
 364         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 365         int                      val;
 366         int                      rc;
 367
 368         rc = lprocfs_write_helper(buffer, count, &val);
 369         if (rc)
 370                 return rc;
 371
 372         if (val < 0)
 373                 return -EINVAL;
 374
 375         spin_lock(&ofd->ofd_flags_lock);
 376         ofd->ofd_syncjournal = !!val;
 377         ofd_slc_set(ofd);
 378         spin_unlock(&ofd->ofd_flags_lock);
 379
 380         return count;
 381 }
 382
 383 static char *sync_on_cancel_states[] = {"never",
 384                                         "blocking",
 385                                         "always" };
 386
 387 int lprocfs_ofd_rd_sync_lock_cancel(char *page, char **start, off_t off,
 388                                     int count, int *eof, void *data)
 389 {
 390         struct obd_device       *obd = data;
 391         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 392         int                      rc;
 393
 394         rc = snprintf(page, count, "%s\n",
 395                       sync_on_cancel_states[ofd->ofd_sync_lock_cancel]);
 396         return rc;
 397 }
 398
 399 int lprocfs_ofd_wr_sync_lock_cancel(struct file *file, const char *buffer,
 400                                     unsigned long count, void *data)
 401 {
 402         struct obd_device       *obd = data;
 403         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 404         int                      val = -1;
 405         int                      i;
 406
 407         for (i = 0 ; i < NUM_SYNC_ON_CANCEL_STATES; i++) {
 408                 if (memcmp(buffer, sync_on_cancel_states[i],
 409                            strlen(sync_on_cancel_states[i])) == 0) {
 410                         val = i;
 411                         break;
 412                 }
 413         }
 414         if (val == -1) {
 415                 int rc;
 416
 417                 rc = lprocfs_write_helper(buffer, count, &val);
 418                 if (rc)
 419                         return rc;
 420         }
 421
 422         if (val < 0 || val > 2)
 423                 return -EINVAL;
 424
 425         spin_lock(&ofd->ofd_flags_lock);
 426         ofd->ofd_sync_lock_cancel = val;
 427         spin_unlock(&ofd->ofd_flags_lock);
 428         return count;
 429 }
 430
 431 int lprocfs_ofd_rd_grant_compat_disable(char *page, char **start, off_t off,
 432                                         int count, int *eof, void *data)
 433 {
 434         struct obd_device       *obd = data;
 435         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 436         int                      rc;
 437
 438         rc = snprintf(page, count, "%u\n", ofd->ofd_grant_compat_disable);
 439         return rc;
 440 }
 441
 442 int lprocfs_ofd_wr_grant_compat_disable(struct file *file, const char *buffer,
 443                                         unsigned long count, void *data)
 444 {
 445         struct obd_device       *obd = data;
 446         struct ofd_device       *ofd = ofd_dev(obd->obd_lu_dev);
 447         int                      val;
 448         int                      rc;
 449
 450         rc = lprocfs_write_helper(buffer, count, &val);
 451         if (rc)
 452                 return rc;
 453
 454         if (val < 0)
 455                 return -EINVAL;
 456
 457         spin_lock(&ofd->ofd_flags_lock);
 458         ofd->ofd_grant_compat_disable = !!val;
 459         spin_unlock(&ofd->ofd_flags_lock);
 460
 461         return count;
 462 }
 463
 464 static struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
 465         { "uuid",                lprocfs_rd_uuid, 0, 0 },
 466         { "blocksize",           lprocfs_rd_blksize, 0, 0 },
 467         { "kbytestotal",         lprocfs_rd_kbytestotal, 0, 0 },
 468         { "kbytesfree",          lprocfs_rd_kbytesfree, 0, 0 },
 469         { "kbytesavail",         lprocfs_rd_kbytesavail, 0, 0 },
 470         { "filestotal",          lprocfs_rd_filestotal, 0, 0 },
 471         { "filesfree",           lprocfs_rd_filesfree, 0, 0 },
 472         { "seqs_allocated",      lprocfs_ofd_rd_seqs, 0, 0 },
 473         { "fstype",              lprocfs_ofd_rd_fstype, 0, 0 },
 474         { "last_id",             lprocfs_ofd_rd_last_id, 0, 0 },
 475         { "tot_dirty",           lprocfs_ofd_rd_tot_dirty,   0, 0 },
 476         { "tot_pending",         lprocfs_ofd_rd_tot_pending, 0, 0 },
 477         { "tot_granted",         lprocfs_ofd_rd_tot_granted, 0, 0 },
 478         { "grant_precreate",     lprocfs_ofd_rd_grant_precreate, 0, 0 },
 479         { "grant_ratio",         lprocfs_ofd_rd_grant_ratio,
 480                                  lprocfs_ofd_wr_grant_ratio, 0, 0 },
 481         { "precreate_batch",     lprocfs_ofd_rd_precreate_batch,
 482                                  lprocfs_ofd_wr_precreate_batch, 0 },
 483         { "recovery_status",     lprocfs_obd_rd_recovery_status, 0, 0 },
 484         { "recovery_time_soft",  lprocfs_obd_rd_recovery_time_soft,
 485                                  lprocfs_obd_wr_recovery_time_soft, 0},
 486         { "recovery_time_hard",  lprocfs_obd_rd_recovery_time_hard,
 487                                  lprocfs_obd_wr_recovery_time_hard, 0},
 488         { "evict_client",        0, lprocfs_wr_evict_client, 0,
 489                                  &lprocfs_evict_client_fops},
 490         { "num_exports",         lprocfs_rd_num_exports,   0, 0 },
 491         { "degraded",            lprocfs_ofd_rd_degraded,
 492                                  lprocfs_ofd_wr_degraded, 0},
 493         { "sync_journal",        lprocfs_ofd_rd_syncjournal,
 494                                  lprocfs_ofd_wr_syncjournal, 0 },
 495         { "sync_on_lock_cancel", lprocfs_ofd_rd_sync_lock_cancel,
 496                                  lprocfs_ofd_wr_sync_lock_cancel, 0 },
 497         { "instance",            lprocfs_target_rd_instance, 0 },
 498         { "ir_factor",           lprocfs_obd_rd_ir_factor,
 499                                  lprocfs_obd_wr_ir_factor, 0},
 500         { "grant_compat_disable", lprocfs_ofd_rd_grant_compat_disable,
 501                                   lprocfs_ofd_wr_grant_compat_disable, 0 },
 502         { "client_cache_count",  lprocfs_ofd_rd_fmd_max_num,
 503                                  lprocfs_ofd_wr_fmd_max_num, 0 },
 504         { "client_cache_seconds", lprocfs_ofd_rd_fmd_max_age,
 505                                   lprocfs_ofd_wr_fmd_max_age, 0 },
 506         { "capa",                lprocfs_ofd_rd_capa,
 507                                  lprocfs_ofd_wr_capa, 0 },
 508         { "capa_count",          lprocfs_ofd_rd_capa_count, 0, 0 },
 509         { "job_cleanup_interval", lprocfs_rd_job_interval,
 510                                   lprocfs_wr_job_interval, 0},
 511         { 0 }
 512 };
 513
 514 static struct lprocfs_vars lprocfs_ofd_module_vars[] = {
 515         { "num_refs",     lprocfs_rd_numrefs,   0, 0 },
 516         { 0 }
 517 };
 518
 519 void lprocfs_ofd_init_vars(struct lprocfs_static_vars *lvars)
 520 {
 521         lvars->module_vars  = lprocfs_ofd_module_vars;
 522         lvars->obd_vars     = lprocfs_ofd_obd_vars;
 523 }
 524
 525 void ofd_stats_counter_init(struct lprocfs_stats *stats)
 526 {
 527         LASSERT(stats && stats->ls_num == LPROC_OFD_STATS_LAST);
 528         lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
 529                              LPROCFS_CNTR_AVGMINMAX, "read", "bytes");
 530         lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
 531                              LPROCFS_CNTR_AVGMINMAX, "write", "bytes");
 532         lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
 533                              0, "setattr", "reqs");
 534         lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
 535                              0, "punch", "reqs");
 536         lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
 537                              0, "sync", "reqs");
 538 }
 539 #endif /* LPROCFS */