lustre/fid/lproc_fid.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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2013, 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/fid/lproc_fid.c
  37  *
  38  * Lustre Sequence Manager
  39  *
  40  * Author: Yury Umanets <umka@clusterfs.com>
  41  */
  42
  43 #define DEBUG_SUBSYSTEM S_FID
  44
  45 #include <libcfs/libcfs.h>
  46 #include <linux/module.h>
  47 #include <obd.h>
  48 #include <obd_class.h>
  49 #include <obd_support.h>
  50 #include <lustre_fid.h>
  51 #include <lprocfs_status.h>
  52 #include "fid_internal.h"
  53 #include <md_object.h>
  54
  55 #ifdef LPROCFS
  56 /**
  57  * Reduce the SEQ range allocated to a node to a strict subset of the range
  58  * currently-allocated SEQ range.  If the specified range is "clear", then
  59  * drop all allocated sequences and request a new one from the master.
  60  *
  61  * Note: this function should only be used for testing, it is not necessarily
  62  * safe for production use.
  63  */
  64 static int
  65 lprocfs_fid_write_common(const char *buffer, unsigned long count,
  66                                 struct lu_seq_range *range)
  67 {
  68         struct lu_seq_range tmp = { 0, };
  69         int rc;
  70         ENTRY;
  71
  72         LASSERT(range != NULL);
  73
  74         if (count == 5 && strcmp(buffer, "clear") == 0) {
  75                 memset(range, 0, sizeof(*range));
  76                 RETURN(0);
  77         }
  78
  79         /* of the form "[0x0000000240000400 - 0x000000028000400]" */
  80         rc = sscanf(buffer, "[%llx - %llx]\n",
  81                     (long long unsigned *)&tmp.lsr_start,
  82                     (long long unsigned *)&tmp.lsr_end);
  83         if (!range_is_sane(&tmp) || range_is_zero(&tmp) ||
  84             tmp.lsr_start < range->lsr_start || tmp.lsr_end > range->lsr_end)
  85                 RETURN(-EINVAL);
  86         *range = tmp;
  87         RETURN(0);
  88 }
  89
  90 #ifdef HAVE_SERVER_SUPPORT
  91 /*
  92  * Server side procfs stuff.
  93  */
  94 static ssize_t
  95 lprocfs_server_fid_space_seq_write(struct file *file, const char *buffer,
  96                                         size_t count, loff_t *off)
  97 {
  98         struct lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
  99         int rc;
 100         ENTRY;
 101
 102         LASSERT(seq != NULL);
 103
 104         mutex_lock(&seq->lss_mutex);
 105         rc = lprocfs_fid_write_common(buffer, count, &seq->lss_space);
 106         if (rc == 0) {
 107                 CDEBUG(D_INFO, "%s: Space: "DRANGE"\n",
 108                         seq->lss_name, PRANGE(&seq->lss_space));
 109         }
 110         mutex_unlock(&seq->lss_mutex);
 111
 112         RETURN(count);
 113 }
 114
 115 static int
 116 lprocfs_server_fid_space_seq_show(struct seq_file *m, void *unused)
 117 {
 118         struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
 119         int rc;
 120         ENTRY;
 121
 122         LASSERT(seq != NULL);
 123
 124         mutex_lock(&seq->lss_mutex);
 125         rc = seq_printf(m, "["LPX64" - "LPX64"]:%x:%s\n",
 126                         PRANGE(&seq->lss_space));
 127         mutex_unlock(&seq->lss_mutex);
 128
 129         RETURN(rc);
 130 }
 131
 132 static int
 133 lprocfs_server_fid_server_seq_show(struct seq_file *m, void *unused)
 134 {
 135         struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
 136         struct client_obd *cli;
 137         int rc;
 138         ENTRY;
 139
 140         LASSERT(seq != NULL);
 141
 142         if (seq->lss_cli) {
 143                 if (seq->lss_cli->lcs_exp != NULL) {
 144                         cli = &seq->lss_cli->lcs_exp->exp_obd->u.cli;
 145                         rc = seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
 146                 } else {
 147                         rc = seq_printf(m, "%s\n",
 148                                         seq->lss_cli->lcs_srv->lss_name);
 149                 }
 150         } else {
 151                 rc = seq_printf(m, "<none>\n");
 152         }
 153
 154         RETURN(rc);
 155 }
 156
 157 static ssize_t
 158 lprocfs_server_fid_width_seq_write(struct file *file, const char *buffer,
 159                                         size_t count, loff_t *off)
 160 {
 161         struct lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
 162         int rc, val;
 163         ENTRY;
 164
 165         LASSERT(seq != NULL);
 166
 167         mutex_lock(&seq->lss_mutex);
 168
 169         rc = lprocfs_write_helper(buffer, count, &val);
 170         if (rc != 0) {
 171                 CERROR("%s: invalid width.\n", seq->lss_name);
 172                 GOTO(out_unlock, count = rc);
 173         }
 174
 175         seq->lss_width = val;
 176
 177         CDEBUG(D_INFO, "%s: Width: "LPU64"\n",
 178                seq->lss_name, seq->lss_width);
 179 out_unlock:
 180         mutex_unlock(&seq->lss_mutex);
 181
 182         RETURN(count);
 183 }
 184
 185 static int
 186 lprocfs_server_fid_width_seq_show(struct seq_file *m, void *unused)
 187 {
 188         struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
 189         int rc;
 190         ENTRY;
 191
 192         LASSERT(seq != NULL);
 193
 194         mutex_lock(&seq->lss_mutex);
 195         rc = seq_printf(m, LPU64"\n", seq->lss_width);
 196         mutex_unlock(&seq->lss_mutex);
 197
 198         RETURN(rc);
 199 }
 200
 201 LPROC_SEQ_FOPS(lprocfs_server_fid_space);
 202 LPROC_SEQ_FOPS(lprocfs_server_fid_width);
 203 LPROC_SEQ_FOPS_RO(lprocfs_server_fid_server);
 204
 205 struct lprocfs_seq_vars seq_server_proc_list[] = {
 206         { "space",      &lprocfs_server_fid_space_fops },
 207         { "width",      &lprocfs_server_fid_width_fops },
 208         { "server",     &lprocfs_server_fid_server_fops },
 209         { NULL }
 210 };
 211
 212 struct fld_seq_param {
 213         struct lu_env           fsp_env;
 214         struct dt_it            *fsp_it;
 215         struct lu_server_fld    *fsp_fld;
 216         struct lu_server_seq    *fsp_seq;
 217         unsigned int            fsp_stop:1;
 218 };
 219
 220 /*
 221  * XXX: below is a copy of the functions in lustre/fld/lproc_fld.c.
 222  * we want to avoid this duplication either by exporting the
 223  * functions or merging fid and fld into a single module.
 224  */
 225 static void *fldb_seq_start(struct seq_file *p, loff_t *pos)
 226 {
 227         struct fld_seq_param    *param = p->private;
 228         struct lu_server_fld    *fld;
 229         struct dt_object        *obj;
 230         const struct dt_it_ops  *iops;
 231
 232         if (param == NULL || param->fsp_stop)
 233                 return NULL;
 234
 235         fld = param->fsp_fld;
 236         obj = fld->lsf_obj;
 237         LASSERT(obj != NULL);
 238         iops = &obj->do_index_ops->dio_it;
 239
 240         iops->load(&param->fsp_env, param->fsp_it, *pos);
 241
 242         *pos = be64_to_cpu(*(__u64 *)iops->key(&param->fsp_env, param->fsp_it));
 243         return param;
 244 }
 245
 246 static void fldb_seq_stop(struct seq_file *p, void *v)
 247 {
 248         struct fld_seq_param    *param = p->private;
 249         const struct dt_it_ops  *iops;
 250         struct lu_server_fld    *fld;
 251         struct dt_object        *obj;
 252
 253         if (param == NULL)
 254                 return;
 255
 256         fld = param->fsp_fld;
 257         obj = fld->lsf_obj;
 258         LASSERT(obj != NULL);
 259         iops = &obj->do_index_ops->dio_it;
 260
 261         iops->put(&param->fsp_env, param->fsp_it);
 262 }
 263
 264 static void *fldb_seq_next(struct seq_file *p, void *v, loff_t *pos)
 265 {
 266         struct fld_seq_param    *param = p->private;
 267         struct lu_server_fld    *fld;
 268         struct dt_object        *obj;
 269         const struct dt_it_ops  *iops;
 270         int                     rc;
 271
 272         if (param == NULL || param->fsp_stop)
 273                 return NULL;
 274
 275         fld = param->fsp_fld;
 276         obj = fld->lsf_obj;
 277         LASSERT(obj != NULL);
 278         iops = &obj->do_index_ops->dio_it;
 279
 280         rc = iops->next(&param->fsp_env, param->fsp_it);
 281         if (rc > 0) {
 282                 param->fsp_stop = 1;
 283                 return NULL;
 284         }
 285
 286         *pos = be64_to_cpu(*(__u64 *)iops->key(&param->fsp_env, param->fsp_it));
 287         return param;
 288 }
 289
 290 static int fldb_seq_show(struct seq_file *p, void *v)
 291 {
 292         struct fld_seq_param    *param = p->private;
 293         struct lu_server_fld    *fld;
 294         struct dt_object        *obj;
 295         const struct dt_it_ops  *iops;
 296         struct lu_seq_range      fld_rec;
 297         int                     rc;
 298
 299         if (param == NULL || param->fsp_stop)
 300                 return 0;
 301
 302         fld = param->fsp_fld;
 303         obj = fld->lsf_obj;
 304         LASSERT(obj != NULL);
 305         iops = &obj->do_index_ops->dio_it;
 306
 307         rc = iops->rec(&param->fsp_env, param->fsp_it,
 308                        (struct dt_rec *)&fld_rec, 0);
 309         if (rc != 0) {
 310                 CERROR("%s: read record error: rc = %d\n",
 311                        fld->lsf_name, rc);
 312         } else if (fld_rec.lsr_start != 0) {
 313                 range_be_to_cpu(&fld_rec, &fld_rec);
 314                 rc = seq_printf(p, DRANGE"\n", PRANGE(&fld_rec));
 315         }
 316
 317         return rc;
 318 }
 319
 320 struct seq_operations fldb_sops = {
 321         .start = fldb_seq_start,
 322         .stop = fldb_seq_stop,
 323         .next = fldb_seq_next,
 324         .show = fldb_seq_show,
 325 };
 326
 327 static int fldb_seq_open(struct inode *inode, struct file *file)
 328 {
 329         struct seq_file         *seq;
 330         struct lu_server_seq    *ss = (struct lu_server_seq *) PDE_DATA(inode);
 331         struct lu_server_fld    *fld;
 332         struct dt_object        *obj;
 333         const struct dt_it_ops  *iops;
 334         struct fld_seq_param    *param = NULL;
 335         int                     env_init = 0;
 336         int                     rc;
 337
 338         fld = ss->lss_site->ss_server_fld;
 339         LASSERT(fld != NULL);
 340
 341         LPROCFS_ENTRY_CHECK(PDE(inode));
 342         rc = seq_open(file, &fldb_sops);
 343         if (rc)
 344                 return rc;
 345
 346         obj = fld->lsf_obj;
 347         if (obj == NULL) {
 348                 seq = file->private_data;
 349                 seq->private = NULL;
 350                 return 0;
 351         }
 352
 353         OBD_ALLOC_PTR(param);
 354         if (param == NULL)
 355                 GOTO(out, rc = -ENOMEM);
 356
 357         rc = lu_env_init(&param->fsp_env, LCT_MD_THREAD);
 358         if (rc != 0)
 359                 GOTO(out, rc);
 360
 361         env_init = 1;
 362         iops = &obj->do_index_ops->dio_it;
 363         param->fsp_it = iops->init(&param->fsp_env, obj, 0, NULL);
 364         if (IS_ERR(param->fsp_it))
 365                 GOTO(out, rc = PTR_ERR(param->fsp_it));
 366
 367         param->fsp_fld = fld;
 368         param->fsp_seq = ss;
 369         param->fsp_stop = 0;
 370
 371         seq = file->private_data;
 372         seq->private = param;
 373 out:
 374         if (rc != 0) {
 375                 if (env_init == 1)
 376                         lu_env_fini(&param->fsp_env);
 377                 if (param != NULL)
 378                         OBD_FREE_PTR(param);
 379         }
 380         return rc;
 381 }
 382
 383 static int fldb_seq_release(struct inode *inode, struct file *file)
 384 {
 385         struct seq_file         *seq = file->private_data;
 386         struct fld_seq_param    *param;
 387         struct lu_server_fld    *fld;
 388         struct dt_object        *obj;
 389         const struct dt_it_ops  *iops;
 390
 391         param = seq->private;
 392         if (param == NULL) {
 393                 lprocfs_seq_release(inode, file);
 394                 return 0;
 395         }
 396
 397         fld = param->fsp_fld;
 398         obj = fld->lsf_obj;
 399         LASSERT(obj != NULL);
 400         iops = &obj->do_index_ops->dio_it;
 401
 402         LASSERT(iops != NULL);
 403         LASSERT(param->fsp_it != NULL);
 404         iops->fini(&param->fsp_env, param->fsp_it);
 405         lu_env_fini(&param->fsp_env);
 406         OBD_FREE_PTR(param);
 407         lprocfs_seq_release(inode, file);
 408
 409         return 0;
 410 }
 411
 412 static ssize_t fldb_seq_write(struct file *file, const char *buf,
 413                               size_t len, loff_t *off)
 414 {
 415         struct seq_file         *seq = file->private_data;
 416         struct fld_seq_param    *param;
 417         struct lu_seq_range      range;
 418         int                      rc = 0;
 419         char                    *buffer, *_buffer;
 420         ENTRY;
 421
 422         param = seq->private;
 423         if (param == NULL)
 424                 RETURN(-EINVAL);
 425
 426         OBD_ALLOC(buffer, len + 1);
 427         if (buffer == NULL)
 428                 RETURN(-ENOMEM);
 429         memcpy(buffer, buf, len);
 430         buffer[len] = 0;
 431         _buffer = buffer;
 432
 433         /*
 434          * format - [0x0000000200000007-0x0000000200000008):0:mdt
 435          */
 436         if (*buffer != '[')
 437                 GOTO(out, rc = -EINVAL);
 438         buffer++;
 439
 440         range.lsr_start = simple_strtoull(buffer, &buffer, 0);
 441         if (*buffer != '-')
 442                 GOTO(out, rc = -EINVAL);
 443         buffer++;
 444
 445         range.lsr_end = simple_strtoull(buffer, &buffer, 0);
 446         if (*buffer != ')')
 447                 GOTO(out, rc = -EINVAL);
 448         buffer++;
 449         if (*buffer != ':')
 450                 GOTO(out, rc = -EINVAL);
 451         buffer++;
 452
 453         range.lsr_index = simple_strtoul(buffer, &buffer, 0);
 454         if (*buffer != ':')
 455                 GOTO(out, rc = -EINVAL);
 456         buffer++;
 457
 458         if (strncmp(buffer, "mdt", 3) == 0)
 459                 range.lsr_flags = LU_SEQ_RANGE_MDT;
 460         else if (strncmp(buffer, "ost", 3) == 0)
 461                 range.lsr_flags = LU_SEQ_RANGE_OST;
 462         else
 463                 GOTO(out, rc = -EINVAL);
 464
 465         rc = seq_server_alloc_spec(param->fsp_seq->lss_site->ss_control_seq,
 466                                    &range, &param->fsp_env);
 467
 468 out:
 469         OBD_FREE(_buffer, len + 1);
 470         RETURN(rc < 0 ? rc : len);
 471 }
 472
 473 const struct file_operations seq_fld_proc_seq_fops = {
 474         .owner   = THIS_MODULE,
 475         .open    = fldb_seq_open,
 476         .read    = seq_read,
 477         .write   = fldb_seq_write,
 478         .release = fldb_seq_release,
 479 };
 480
 481 #endif /* HAVE_SERVER_SUPPORT */
 482
 483 /* Client side procfs stuff */
 484 static ssize_t
 485 lprocfs_client_fid_space_seq_write(struct file *file, const char *buffer,
 486                                    size_t count, loff_t *off)
 487 {
 488         struct lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
 489         int rc;
 490         ENTRY;
 491
 492         LASSERT(seq != NULL);
 493
 494         mutex_lock(&seq->lcs_mutex);
 495         rc = lprocfs_fid_write_common(buffer, count, &seq->lcs_space);
 496         if (rc == 0) {
 497                 CDEBUG(D_INFO, "%s: Space: "DRANGE"\n",
 498                        seq->lcs_name, PRANGE(&seq->lcs_space));
 499         }
 500
 501         mutex_unlock(&seq->lcs_mutex);
 502
 503         RETURN(count);
 504 }
 505
 506 static int
 507 lprocfs_client_fid_space_seq_show(struct seq_file *m, void *unused)
 508 {
 509         struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
 510         int rc;
 511         ENTRY;
 512
 513         LASSERT(seq != NULL);
 514
 515         mutex_lock(&seq->lcs_mutex);
 516         rc = seq_printf(m, "["LPX64" - "LPX64"]:%x:%s\n",
 517                         PRANGE(&seq->lcs_space));
 518         mutex_unlock(&seq->lcs_mutex);
 519
 520         RETURN(rc);
 521 }
 522
 523 static ssize_t
 524 lprocfs_client_fid_width_seq_write(struct file *file, const char *buffer,
 525                                    size_t count, loff_t *off)
 526 {
 527         struct lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
 528         __u64  max;
 529         int rc, val;
 530         ENTRY;
 531
 532         LASSERT(seq != NULL);
 533
 534         mutex_lock(&seq->lcs_mutex);
 535
 536         rc = lprocfs_write_helper(buffer, count, &val);
 537         if (rc) {
 538                 mutex_unlock(&seq->lcs_mutex);
 539                 RETURN(rc);
 540         }
 541
 542         if (seq->lcs_type == LUSTRE_SEQ_DATA)
 543                 max = LUSTRE_DATA_SEQ_MAX_WIDTH;
 544         else
 545                 max = LUSTRE_METADATA_SEQ_MAX_WIDTH;
 546
 547         if (val <= max && val > 0) {
 548                 seq->lcs_width = val;
 549
 550                 if (rc == 0) {
 551                         CDEBUG(D_INFO, "%s: Sequence size: "LPU64"\n",
 552                                seq->lcs_name, seq->lcs_width);
 553                 }
 554         }
 555         mutex_unlock(&seq->lcs_mutex);
 556
 557         RETURN(count);
 558 }
 559
 560 static int
 561 lprocfs_client_fid_width_seq_show(struct seq_file *m, void *unused)
 562 {
 563         struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
 564         int rc;
 565         ENTRY;
 566
 567         LASSERT(seq != NULL);
 568
 569         mutex_lock(&seq->lcs_mutex);
 570         rc = seq_printf(m, LPU64"\n", seq->lcs_width);
 571         mutex_unlock(&seq->lcs_mutex);
 572
 573         RETURN(rc);
 574 }
 575
 576 static int
 577 lprocfs_client_fid_fid_seq_show(struct seq_file *m, void *unused)
 578 {
 579         struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
 580         int rc;
 581         ENTRY;
 582
 583         LASSERT(seq != NULL);
 584
 585         mutex_lock(&seq->lcs_mutex);
 586         rc = seq_printf(m, DFID"\n", PFID(&seq->lcs_fid));
 587         mutex_unlock(&seq->lcs_mutex);
 588
 589         RETURN(rc);
 590 }
 591
 592 static int
 593 lprocfs_client_fid_server_seq_show(struct seq_file *m, void *unused)
 594 {
 595         struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
 596         struct client_obd *cli;
 597         int rc;
 598         ENTRY;
 599
 600         LASSERT(seq != NULL);
 601
 602         if (seq->lcs_exp != NULL) {
 603                 cli = &seq->lcs_exp->exp_obd->u.cli;
 604                 rc = seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
 605         } else {
 606                 rc = seq_printf(m, "%s\n", seq->lcs_srv->lss_name);
 607         }
 608         RETURN(rc);
 609 }
 610
 611 LPROC_SEQ_FOPS(lprocfs_client_fid_space);
 612 LPROC_SEQ_FOPS(lprocfs_client_fid_width);
 613 LPROC_SEQ_FOPS_RO(lprocfs_client_fid_server);
 614 LPROC_SEQ_FOPS_RO(lprocfs_client_fid_fid);
 615
 616 struct lprocfs_seq_vars seq_client_proc_list[] = {
 617         { "space",      &lprocfs_client_fid_space_fops },
 618         { "width",      &lprocfs_client_fid_width_fops },
 619         { "server",     &lprocfs_client_fid_server_fops },
 620         { "fid",        &lprocfs_client_fid_fid_fops },
 621         { NULL }
 622 };
 623 #endif