fs/orangefs/orangefs-sysfs.c

   1 /*
   2  * Documentation/ABI/stable/orangefs-sysfs:
   3  *
   4  * What:                /sys/fs/orangefs/perf_counter_reset
   5  * Date:                June 2015
   6  * Contact:             Mike Marshall <hubcap@omnibond.com>
   7  * Description:
   8  *                      echo a 0 or a 1 into perf_counter_reset to
   9  *                      reset all the counters in
  10  *                      /sys/fs/orangefs/perf_counters
  11  *                      except ones with PINT_PERF_PRESERVE set.
  12  *
  13  *
  14  * What:                /sys/fs/orangefs/perf_counters/...
  15  * Date:                Jun 2015
  16  * Contact:             Mike Marshall <hubcap@omnibond.com>
  17  * Description:
  18  *                      Counters and settings for various caches.
  19  *                      Read only.
  20  *
  21  *
  22  * What:                /sys/fs/orangefs/perf_time_interval_secs
  23  * Date:                Jun 2015
  24  * Contact:             Mike Marshall <hubcap@omnibond.com>
  25  * Description:
  26  *                      Length of perf counter intervals in
  27  *                      seconds.
  28  *
  29  *
  30  * What:                /sys/fs/orangefs/perf_history_size
  31  * Date:                Jun 2015
  32  * Contact:             Mike Marshall <hubcap@omnibond.com>
  33  * Description:
  34  *                      The perf_counters cache statistics have N, or
  35  *                      perf_history_size, samples. The default is
  36  *                      one.
  37  *
  38  *                      Every perf_time_interval_secs the (first)
  39  *                      samples are reset.
  40  *
  41  *                      If N is greater than one, the "current" set
  42  *                      of samples is reset, and the samples from the
  43  *                      other N-1 intervals remain available.
  44  *
  45  *
  46  * What:                /sys/fs/orangefs/op_timeout_secs
  47  * Date:                Jun 2015
  48  * Contact:             Mike Marshall <hubcap@omnibond.com>
  49  * Description:
  50  *                      Service operation timeout in seconds.
  51  *
  52  *
  53  * What:                /sys/fs/orangefs/slot_timeout_secs
  54  * Date:                Jun 2015
  55  * Contact:             Mike Marshall <hubcap@omnibond.com>
  56  * Description:
  57  *                      "Slot" timeout in seconds. A "slot"
  58  *                      is an indexed buffer in the shared
  59  *                      memory segment used for communication
  60  *                      between the kernel module and userspace.
  61  *                      Slots are requested and waited for,
  62  *                      the wait times out after slot_timeout_secs.
  63  *
  64  * What:                /sys/fs/orangefs/dcache_timeout_msecs
  65  * Date:                Jul 2016
  66  * Contact:             Martin Brandenburg <martin@omnibond.com>
  67  * Description:
  68  *                      Time lookup is valid in milliseconds.
  69  *
  70  * What:                /sys/fs/orangefs/getattr_timeout_msecs
  71  * Date:                Jul 2016
  72  * Contact:             Martin Brandenburg <martin@omnibond.com>
  73  * Description:
  74  *                      Time getattr is valid in milliseconds.
  75  *
  76  * What:                /sys/fs/orangefs/acache/...
  77  * Date:                Jun 2015
  78  * Contact:             Martin Brandenburg <martin@omnibond.com>
  79  * Description:
  80  *                      Attribute cache configurable settings.
  81  *
  82  *
  83  * What:                /sys/fs/orangefs/ncache/...
  84  * Date:                Jun 2015
  85  * Contact:             Mike Marshall <hubcap@omnibond.com>
  86  * Description:
  87  *                      Name cache configurable settings.
  88  *
  89  *
  90  * What:                /sys/fs/orangefs/capcache/...
  91  * Date:                Jun 2015
  92  * Contact:             Mike Marshall <hubcap@omnibond.com>
  93  * Description:
  94  *                      Capability cache configurable settings.
  95  *
  96  *
  97  * What:                /sys/fs/orangefs/ccache/...
  98  * Date:                Jun 2015
  99  * Contact:             Mike Marshall <hubcap@omnibond.com>
 100  * Description:
 101  *                      Credential cache configurable settings.
 102  *
 103  */
 104
 105 #include <linux/fs.h>
 106 #include <linux/kobject.h>
 107 #include <linux/string.h>
 108 #include <linux/sysfs.h>
 109 #include <linux/module.h>
 110 #include <linux/init.h>
 111
 112 #include "protocol.h"
 113 #include "orangefs-kernel.h"
 114 #include "orangefs-sysfs.h"
 115
 116 #define ORANGEFS_KOBJ_ID "orangefs"
 117 #define ACACHE_KOBJ_ID "acache"
 118 #define CAPCACHE_KOBJ_ID "capcache"
 119 #define CCACHE_KOBJ_ID "ccache"
 120 #define NCACHE_KOBJ_ID "ncache"
 121 #define PC_KOBJ_ID "pc"
 122 #define STATS_KOBJ_ID "stats"
 123
 124 struct orangefs_obj {
 125         struct kobject kobj;
 126         int op_timeout_secs;
 127         int perf_counter_reset;
 128         int perf_history_size;
 129         int perf_time_interval_secs;
 130         int slot_timeout_secs;
 131         int dcache_timeout_msecs;
 132         int getattr_timeout_msecs;
 133 };
 134
 135 struct acache_orangefs_obj {
 136         struct kobject kobj;
 137         int hard_limit;
 138         int reclaim_percentage;
 139         int soft_limit;
 140         int timeout_msecs;
 141 };
 142
 143 struct capcache_orangefs_obj {
 144         struct kobject kobj;
 145         int hard_limit;
 146         int reclaim_percentage;
 147         int soft_limit;
 148         int timeout_secs;
 149 };
 150
 151 struct ccache_orangefs_obj {
 152         struct kobject kobj;
 153         int hard_limit;
 154         int reclaim_percentage;
 155         int soft_limit;
 156         int timeout_secs;
 157 };
 158
 159 struct ncache_orangefs_obj {
 160         struct kobject kobj;
 161         int hard_limit;
 162         int reclaim_percentage;
 163         int soft_limit;
 164         int timeout_msecs;
 165 };
 166
 167 struct pc_orangefs_obj {
 168         struct kobject kobj;
 169         char *acache;
 170         char *capcache;
 171         char *ncache;
 172 };
 173
 174 struct stats_orangefs_obj {
 175         struct kobject kobj;
 176         int reads;
 177         int writes;
 178 };
 179
 180 struct orangefs_attribute {
 181         struct attribute attr;
 182         ssize_t (*show)(struct orangefs_obj *orangefs_obj,
 183                         struct orangefs_attribute *attr,
 184                         char *buf);
 185         ssize_t (*store)(struct orangefs_obj *orangefs_obj,
 186                          struct orangefs_attribute *attr,
 187                          const char *buf,
 188                          size_t count);
 189 };
 190
 191 struct acache_orangefs_attribute {
 192         struct attribute attr;
 193         ssize_t (*show)(struct acache_orangefs_obj *acache_orangefs_obj,
 194                         struct acache_orangefs_attribute *attr,
 195                         char *buf);
 196         ssize_t (*store)(struct acache_orangefs_obj *acache_orangefs_obj,
 197                          struct acache_orangefs_attribute *attr,
 198                          const char *buf,
 199                          size_t count);
 200 };
 201
 202 struct capcache_orangefs_attribute {
 203         struct attribute attr;
 204         ssize_t (*show)(struct capcache_orangefs_obj *capcache_orangefs_obj,
 205                         struct capcache_orangefs_attribute *attr,
 206                         char *buf);
 207         ssize_t (*store)(struct capcache_orangefs_obj *capcache_orangefs_obj,
 208                          struct capcache_orangefs_attribute *attr,
 209                          const char *buf,
 210                          size_t count);
 211 };
 212
 213 struct ccache_orangefs_attribute {
 214         struct attribute attr;
 215         ssize_t (*show)(struct ccache_orangefs_obj *ccache_orangefs_obj,
 216                         struct ccache_orangefs_attribute *attr,
 217                         char *buf);
 218         ssize_t (*store)(struct ccache_orangefs_obj *ccache_orangefs_obj,
 219                          struct ccache_orangefs_attribute *attr,
 220                          const char *buf,
 221                          size_t count);
 222 };
 223
 224 struct ncache_orangefs_attribute {
 225         struct attribute attr;
 226         ssize_t (*show)(struct ncache_orangefs_obj *ncache_orangefs_obj,
 227                         struct ncache_orangefs_attribute *attr,
 228                         char *buf);
 229         ssize_t (*store)(struct ncache_orangefs_obj *ncache_orangefs_obj,
 230                          struct ncache_orangefs_attribute *attr,
 231                          const char *buf,
 232                          size_t count);
 233 };
 234
 235 struct pc_orangefs_attribute {
 236         struct attribute attr;
 237         ssize_t (*show)(struct pc_orangefs_obj *pc_orangefs_obj,
 238                         struct pc_orangefs_attribute *attr,
 239                         char *buf);
 240         ssize_t (*store)(struct pc_orangefs_obj *pc_orangefs_obj,
 241                          struct pc_orangefs_attribute *attr,
 242                          const char *buf,
 243                          size_t count);
 244 };
 245
 246 struct stats_orangefs_attribute {
 247         struct attribute attr;
 248         ssize_t (*show)(struct stats_orangefs_obj *stats_orangefs_obj,
 249                         struct stats_orangefs_attribute *attr,
 250                         char *buf);
 251         ssize_t (*store)(struct stats_orangefs_obj *stats_orangefs_obj,
 252                          struct stats_orangefs_attribute *attr,
 253                          const char *buf,
 254                          size_t count);
 255 };
 256
 257 static ssize_t orangefs_attr_show(struct kobject *kobj,
 258                                   struct attribute *attr,
 259                                   char *buf)
 260 {
 261         struct orangefs_attribute *attribute;
 262         struct orangefs_obj *orangefs_obj;
 263         int rc;
 264
 265         attribute = container_of(attr, struct orangefs_attribute, attr);
 266         orangefs_obj = container_of(kobj, struct orangefs_obj, kobj);
 267
 268         if (!attribute->show) {
 269                 rc = -EIO;
 270                 goto out;
 271         }
 272
 273         rc = attribute->show(orangefs_obj, attribute, buf);
 274
 275 out:
 276         return rc;
 277 }
 278
 279 static ssize_t orangefs_attr_store(struct kobject *kobj,
 280                                    struct attribute *attr,
 281                                    const char *buf,
 282                                    size_t len)
 283 {
 284         struct orangefs_attribute *attribute;
 285         struct orangefs_obj *orangefs_obj;
 286         int rc;
 287
 288         gossip_debug(GOSSIP_SYSFS_DEBUG,
 289                      "orangefs_attr_store: start\n");
 290
 291         attribute = container_of(attr, struct orangefs_attribute, attr);
 292         orangefs_obj = container_of(kobj, struct orangefs_obj, kobj);
 293
 294         if (!attribute->store) {
 295                 rc = -EIO;
 296                 goto out;
 297         }
 298
 299         rc = attribute->store(orangefs_obj, attribute, buf, len);
 300
 301 out:
 302         return rc;
 303 }
 304
 305 static const struct sysfs_ops orangefs_sysfs_ops = {
 306         .show = orangefs_attr_show,
 307         .store = orangefs_attr_store,
 308 };
 309
 310 static ssize_t acache_orangefs_attr_show(struct kobject *kobj,
 311                                          struct attribute *attr,
 312                                          char *buf)
 313 {
 314         struct acache_orangefs_attribute *attribute;
 315         struct acache_orangefs_obj *acache_orangefs_obj;
 316         int rc;
 317
 318         attribute = container_of(attr, struct acache_orangefs_attribute, attr);
 319         acache_orangefs_obj =
 320                 container_of(kobj, struct acache_orangefs_obj, kobj);
 321
 322         if (!attribute->show) {
 323                 rc = -EIO;
 324                 goto out;
 325         }
 326
 327         rc = attribute->show(acache_orangefs_obj, attribute, buf);
 328
 329 out:
 330         return rc;
 331 }
 332
 333 static ssize_t acache_orangefs_attr_store(struct kobject *kobj,
 334                                           struct attribute *attr,
 335                                           const char *buf,
 336                                           size_t len)
 337 {
 338         struct acache_orangefs_attribute *attribute;
 339         struct acache_orangefs_obj *acache_orangefs_obj;
 340         int rc;
 341
 342         gossip_debug(GOSSIP_SYSFS_DEBUG,
 343                      "acache_orangefs_attr_store: start\n");
 344
 345         attribute = container_of(attr, struct acache_orangefs_attribute, attr);
 346         acache_orangefs_obj =
 347                 container_of(kobj, struct acache_orangefs_obj, kobj);
 348
 349         if (!attribute->store) {
 350                 rc = -EIO;
 351                 goto out;
 352         }
 353
 354         rc = attribute->store(acache_orangefs_obj, attribute, buf, len);
 355
 356 out:
 357         return rc;
 358 }
 359
 360 static const struct sysfs_ops acache_orangefs_sysfs_ops = {
 361         .show = acache_orangefs_attr_show,
 362         .store = acache_orangefs_attr_store,
 363 };
 364
 365 static ssize_t capcache_orangefs_attr_show(struct kobject *kobj,
 366                                            struct attribute *attr,
 367                                            char *buf)
 368 {
 369         struct capcache_orangefs_attribute *attribute;
 370         struct capcache_orangefs_obj *capcache_orangefs_obj;
 371         int rc;
 372
 373         attribute =
 374                 container_of(attr, struct capcache_orangefs_attribute, attr);
 375         capcache_orangefs_obj =
 376                 container_of(kobj, struct capcache_orangefs_obj, kobj);
 377
 378         if (!attribute->show) {
 379                 rc = -EIO;
 380                 goto out;
 381         }
 382
 383         rc = attribute->show(capcache_orangefs_obj, attribute, buf);
 384
 385 out:
 386         return rc;
 387 }
 388
 389 static ssize_t capcache_orangefs_attr_store(struct kobject *kobj,
 390                                             struct attribute *attr,
 391                                             const char *buf,
 392                                             size_t len)
 393 {
 394         struct capcache_orangefs_attribute *attribute;
 395         struct capcache_orangefs_obj *capcache_orangefs_obj;
 396         int rc;
 397
 398         gossip_debug(GOSSIP_SYSFS_DEBUG,
 399                      "capcache_orangefs_attr_store: start\n");
 400
 401         attribute =
 402                 container_of(attr, struct capcache_orangefs_attribute, attr);
 403         capcache_orangefs_obj =
 404                 container_of(kobj, struct capcache_orangefs_obj, kobj);
 405
 406         if (!attribute->store) {
 407                 rc = -EIO;
 408                 goto out;
 409         }
 410
 411         rc = attribute->store(capcache_orangefs_obj, attribute, buf, len);
 412
 413 out:
 414         return rc;
 415 }
 416
 417 static const struct sysfs_ops capcache_orangefs_sysfs_ops = {
 418         .show = capcache_orangefs_attr_show,
 419         .store = capcache_orangefs_attr_store,
 420 };
 421
 422 static ssize_t ccache_orangefs_attr_show(struct kobject *kobj,
 423                                          struct attribute *attr,
 424                                          char *buf)
 425 {
 426         struct ccache_orangefs_attribute *attribute;
 427         struct ccache_orangefs_obj *ccache_orangefs_obj;
 428         int rc;
 429
 430         attribute =
 431                 container_of(attr, struct ccache_orangefs_attribute, attr);
 432         ccache_orangefs_obj =
 433                 container_of(kobj, struct ccache_orangefs_obj, kobj);
 434
 435         if (!attribute->show) {
 436                 rc = -EIO;
 437                 goto out;
 438         }
 439
 440         rc = attribute->show(ccache_orangefs_obj, attribute, buf);
 441
 442 out:
 443         return rc;
 444 }
 445
 446 static ssize_t ccache_orangefs_attr_store(struct kobject *kobj,
 447                                           struct attribute *attr,
 448                                           const char *buf,
 449                                           size_t len)
 450 {
 451         struct ccache_orangefs_attribute *attribute;
 452         struct ccache_orangefs_obj *ccache_orangefs_obj;
 453         int rc;
 454
 455         gossip_debug(GOSSIP_SYSFS_DEBUG,
 456                      "ccache_orangefs_attr_store: start\n");
 457
 458         attribute =
 459                 container_of(attr, struct ccache_orangefs_attribute, attr);
 460         ccache_orangefs_obj =
 461                 container_of(kobj, struct ccache_orangefs_obj, kobj);
 462
 463         if (!attribute->store) {
 464                 rc = -EIO;
 465                 goto out;
 466         }
 467
 468         rc = attribute->store(ccache_orangefs_obj, attribute, buf, len);
 469
 470 out:
 471         return rc;
 472 }
 473
 474 static const struct sysfs_ops ccache_orangefs_sysfs_ops = {
 475         .show = ccache_orangefs_attr_show,
 476         .store = ccache_orangefs_attr_store,
 477 };
 478
 479 static ssize_t ncache_orangefs_attr_show(struct kobject *kobj,
 480                                          struct attribute *attr,
 481                                          char *buf)
 482 {
 483         struct ncache_orangefs_attribute *attribute;
 484         struct ncache_orangefs_obj *ncache_orangefs_obj;
 485         int rc;
 486
 487         attribute = container_of(attr, struct ncache_orangefs_attribute, attr);
 488         ncache_orangefs_obj =
 489                 container_of(kobj, struct ncache_orangefs_obj, kobj);
 490
 491         if (!attribute->show) {
 492                 rc = -EIO;
 493                 goto out;
 494         }
 495
 496         rc = attribute->show(ncache_orangefs_obj, attribute, buf);
 497
 498 out:
 499         return rc;
 500 }
 501
 502 static ssize_t ncache_orangefs_attr_store(struct kobject *kobj,
 503                                           struct attribute *attr,
 504                                           const char *buf,
 505                                           size_t len)
 506 {
 507         struct ncache_orangefs_attribute *attribute;
 508         struct ncache_orangefs_obj *ncache_orangefs_obj;
 509         int rc;
 510
 511         gossip_debug(GOSSIP_SYSFS_DEBUG,
 512                      "ncache_orangefs_attr_store: start\n");
 513
 514         attribute = container_of(attr, struct ncache_orangefs_attribute, attr);
 515         ncache_orangefs_obj =
 516                 container_of(kobj, struct ncache_orangefs_obj, kobj);
 517
 518         if (!attribute->store) {
 519                 rc = -EIO;
 520                 goto out;
 521         }
 522
 523         rc = attribute->store(ncache_orangefs_obj, attribute, buf, len);
 524
 525 out:
 526         return rc;
 527 }
 528
 529 static const struct sysfs_ops ncache_orangefs_sysfs_ops = {
 530         .show = ncache_orangefs_attr_show,
 531         .store = ncache_orangefs_attr_store,
 532 };
 533
 534 static ssize_t pc_orangefs_attr_show(struct kobject *kobj,
 535                                      struct attribute *attr,
 536                                      char *buf)
 537 {
 538         struct pc_orangefs_attribute *attribute;
 539         struct pc_orangefs_obj *pc_orangefs_obj;
 540         int rc;
 541
 542         attribute = container_of(attr, struct pc_orangefs_attribute, attr);
 543         pc_orangefs_obj =
 544                 container_of(kobj, struct pc_orangefs_obj, kobj);
 545
 546         if (!attribute->show) {
 547                 rc = -EIO;
 548                 goto out;
 549         }
 550
 551         rc = attribute->show(pc_orangefs_obj, attribute, buf);
 552
 553 out:
 554         return rc;
 555 }
 556
 557 static const struct sysfs_ops pc_orangefs_sysfs_ops = {
 558         .show = pc_orangefs_attr_show,
 559 };
 560
 561 static ssize_t stats_orangefs_attr_show(struct kobject *kobj,
 562                                         struct attribute *attr,
 563                                         char *buf)
 564 {
 565         struct stats_orangefs_attribute *attribute;
 566         struct stats_orangefs_obj *stats_orangefs_obj;
 567         int rc;
 568
 569         attribute = container_of(attr, struct stats_orangefs_attribute, attr);
 570         stats_orangefs_obj =
 571                 container_of(kobj, struct stats_orangefs_obj, kobj);
 572
 573         if (!attribute->show) {
 574                 rc = -EIO;
 575                 goto out;
 576         }
 577
 578         rc = attribute->show(stats_orangefs_obj, attribute, buf);
 579
 580 out:
 581         return rc;
 582 }
 583
 584 static const struct sysfs_ops stats_orangefs_sysfs_ops = {
 585         .show = stats_orangefs_attr_show,
 586 };
 587
 588 static void orangefs_release(struct kobject *kobj)
 589 {
 590         struct orangefs_obj *orangefs_obj;
 591
 592         orangefs_obj = container_of(kobj, struct orangefs_obj, kobj);
 593         kfree(orangefs_obj);
 594 }
 595
 596 static void acache_orangefs_release(struct kobject *kobj)
 597 {
 598         struct acache_orangefs_obj *acache_orangefs_obj;
 599
 600         acache_orangefs_obj =
 601                 container_of(kobj, struct acache_orangefs_obj, kobj);
 602         kfree(acache_orangefs_obj);
 603 }
 604
 605 static void capcache_orangefs_release(struct kobject *kobj)
 606 {
 607         struct capcache_orangefs_obj *capcache_orangefs_obj;
 608
 609         capcache_orangefs_obj =
 610                 container_of(kobj, struct capcache_orangefs_obj, kobj);
 611         kfree(capcache_orangefs_obj);
 612 }
 613
 614 static void ccache_orangefs_release(struct kobject *kobj)
 615 {
 616         struct ccache_orangefs_obj *ccache_orangefs_obj;
 617
 618         ccache_orangefs_obj =
 619                 container_of(kobj, struct ccache_orangefs_obj, kobj);
 620         kfree(ccache_orangefs_obj);
 621 }
 622
 623 static void ncache_orangefs_release(struct kobject *kobj)
 624 {
 625         struct ncache_orangefs_obj *ncache_orangefs_obj;
 626
 627         ncache_orangefs_obj =
 628                 container_of(kobj, struct ncache_orangefs_obj, kobj);
 629         kfree(ncache_orangefs_obj);
 630 }
 631
 632 static void pc_orangefs_release(struct kobject *kobj)
 633 {
 634         struct pc_orangefs_obj *pc_orangefs_obj;
 635
 636         pc_orangefs_obj =
 637                 container_of(kobj, struct pc_orangefs_obj, kobj);
 638         kfree(pc_orangefs_obj);
 639 }
 640
 641 static void stats_orangefs_release(struct kobject *kobj)
 642 {
 643         struct stats_orangefs_obj *stats_orangefs_obj;
 644
 645         stats_orangefs_obj =
 646                 container_of(kobj, struct stats_orangefs_obj, kobj);
 647         kfree(stats_orangefs_obj);
 648 }
 649
 650 static ssize_t sysfs_int_show(char *kobj_id, char *buf, void *attr)
 651 {
 652         int rc = -EIO;
 653         struct orangefs_attribute *orangefs_attr;
 654         struct stats_orangefs_attribute *stats_orangefs_attr;
 655
 656         gossip_debug(GOSSIP_SYSFS_DEBUG, "sysfs_int_show: id:%s:\n", kobj_id);
 657
 658         if (!strcmp(kobj_id, ORANGEFS_KOBJ_ID)) {
 659                 orangefs_attr = (struct orangefs_attribute *)attr;
 660
 661                 if (!strcmp(orangefs_attr->attr.name, "op_timeout_secs")) {
 662                         rc = scnprintf(buf,
 663                                        PAGE_SIZE,
 664                                        "%d\n",
 665                                        op_timeout_secs);
 666                         goto out;
 667                 } else if (!strcmp(orangefs_attr->attr.name,
 668                                    "slot_timeout_secs")) {
 669                         rc = scnprintf(buf,
 670                                        PAGE_SIZE,
 671                                        "%d\n",
 672                                        slot_timeout_secs);
 673                         goto out;
 674                 } else if (!strcmp(orangefs_attr->attr.name,
 675                                    "dcache_timeout_msecs")) {
 676                         rc = scnprintf(buf,
 677                                        PAGE_SIZE,
 678                                        "%d\n",
 679                                        dcache_timeout_msecs);
 680                         goto out;
 681                 } else if (!strcmp(orangefs_attr->attr.name,
 682                                    "getattr_timeout_msecs")) {
 683                         rc = scnprintf(buf,
 684                                        PAGE_SIZE,
 685                                        "%d\n",
 686                                        getattr_timeout_msecs);
 687                         goto out;
 688                 } else {
 689                         goto out;
 690                 }
 691
 692         } else if (!strcmp(kobj_id, STATS_KOBJ_ID)) {
 693                 stats_orangefs_attr = (struct stats_orangefs_attribute *)attr;
 694
 695                 if (!strcmp(stats_orangefs_attr->attr.name, "reads")) {
 696                         rc = scnprintf(buf,
 697                                        PAGE_SIZE,
 698                                        "%lu\n",
 699                                        g_orangefs_stats.reads);
 700                         goto out;
 701                 } else if (!strcmp(stats_orangefs_attr->attr.name, "writes")) {
 702                         rc = scnprintf(buf,
 703                                        PAGE_SIZE,
 704                                        "%lu\n",
 705                                        g_orangefs_stats.writes);
 706                         goto out;
 707                 } else {
 708                         goto out;
 709                 }
 710         }
 711
 712 out:
 713
 714         return rc;
 715 }
 716
 717 static ssize_t int_orangefs_show(struct orangefs_obj *orangefs_obj,
 718                                  struct orangefs_attribute *attr,
 719                                  char *buf)
 720 {
 721         int rc;
 722
 723         gossip_debug(GOSSIP_SYSFS_DEBUG,
 724                      "int_orangefs_show:start attr->attr.name:%s:\n",
 725                      attr->attr.name);
 726
 727         rc = sysfs_int_show(ORANGEFS_KOBJ_ID, buf, (void *) attr);
 728
 729         return rc;
 730 }
 731
 732 static ssize_t int_stats_show(struct stats_orangefs_obj *stats_orangefs_obj,
 733                         struct stats_orangefs_attribute *attr,
 734                         char *buf)
 735 {
 736         int rc;
 737
 738         gossip_debug(GOSSIP_SYSFS_DEBUG,
 739                      "int_stats_show:start attr->attr.name:%s:\n",
 740                      attr->attr.name);
 741
 742         rc = sysfs_int_show(STATS_KOBJ_ID, buf, (void *) attr);
 743
 744         return rc;
 745 }
 746
 747 static ssize_t int_store(struct orangefs_obj *orangefs_obj,
 748                          struct orangefs_attribute *attr,
 749                          const char *buf,
 750                          size_t count)
 751 {
 752         int rc = 0;
 753
 754         gossip_debug(GOSSIP_SYSFS_DEBUG,
 755                      "int_store: start attr->attr.name:%s: buf:%s:\n",
 756                      attr->attr.name, buf);
 757
 758         if (!strcmp(attr->attr.name, "op_timeout_secs")) {
 759                 rc = kstrtoint(buf, 0, &op_timeout_secs);
 760                 goto out;
 761         } else if (!strcmp(attr->attr.name, "slot_timeout_secs")) {
 762                 rc = kstrtoint(buf, 0, &slot_timeout_secs);
 763                 goto out;
 764         } else if (!strcmp(attr->attr.name, "dcache_timeout_msecs")) {
 765                 rc = kstrtoint(buf, 0, &dcache_timeout_msecs);
 766                 goto out;
 767         } else if (!strcmp(attr->attr.name, "getattr_timeout_msecs")) {
 768                 rc = kstrtoint(buf, 0, &getattr_timeout_msecs);
 769                 goto out;
 770         } else {
 771                 goto out;
 772         }
 773
 774 out:
 775         if (rc)
 776                 rc = -EINVAL;
 777         else
 778                 rc = count;
 779
 780         return rc;
 781 }
 782
 783 /*
 784  * obtain attribute values from userspace with a service operation.
 785  */
 786 static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
 787 {
 788         struct orangefs_kernel_op_s *new_op = NULL;
 789         int rc = 0;
 790         char *ser_op_type = NULL;
 791         struct orangefs_attribute *orangefs_attr;
 792         struct acache_orangefs_attribute *acache_attr;
 793         struct capcache_orangefs_attribute *capcache_attr;
 794         struct ccache_orangefs_attribute *ccache_attr;
 795         struct ncache_orangefs_attribute *ncache_attr;
 796         struct pc_orangefs_attribute *pc_attr;
 797         __u32 op_alloc_type;
 798
 799         gossip_debug(GOSSIP_SYSFS_DEBUG,
 800                      "sysfs_service_op_show: id:%s:\n",
 801                      kobj_id);
 802
 803         if (strcmp(kobj_id, PC_KOBJ_ID))
 804                 op_alloc_type = ORANGEFS_VFS_OP_PARAM;
 805         else
 806                 op_alloc_type = ORANGEFS_VFS_OP_PERF_COUNT;
 807
 808         new_op = op_alloc(op_alloc_type);
 809         if (!new_op)
 810                 return -ENOMEM;
 811
 812         /* Can't do a service_operation if the client is not running... */
 813         rc = is_daemon_in_service();
 814         if (rc) {
 815                 pr_info("%s: Client not running :%d:\n",
 816                         __func__,
 817                         is_daemon_in_service());
 818                 goto out;
 819         }
 820
 821         if (strcmp(kobj_id, PC_KOBJ_ID))
 822                 new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_GET;
 823
 824         if (!strcmp(kobj_id, ORANGEFS_KOBJ_ID)) {
 825                 orangefs_attr = (struct orangefs_attribute *)attr;
 826
 827                 if (!strcmp(orangefs_attr->attr.name, "perf_history_size"))
 828                         new_op->upcall.req.param.op =
 829                                 ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
 830                 else if (!strcmp(orangefs_attr->attr.name,
 831                                  "perf_time_interval_secs"))
 832                         new_op->upcall.req.param.op =
 833                                 ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
 834                 else if (!strcmp(orangefs_attr->attr.name,
 835                                  "perf_counter_reset"))
 836                         new_op->upcall.req.param.op =
 837                                 ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;
 838
 839         } else if (!strcmp(kobj_id, ACACHE_KOBJ_ID)) {
 840                 acache_attr = (struct acache_orangefs_attribute *)attr;
 841
 842                 if (!strcmp(acache_attr->attr.name, "timeout_msecs"))
 843                         new_op->upcall.req.param.op =
 844                                 ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
 845
 846                 if (!strcmp(acache_attr->attr.name, "hard_limit"))
 847                         new_op->upcall.req.param.op =
 848                                 ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
 849
 850                 if (!strcmp(acache_attr->attr.name, "soft_limit"))
 851                         new_op->upcall.req.param.op =
 852                                 ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
 853
 854                 if (!strcmp(acache_attr->attr.name, "reclaim_percentage"))
 855                         new_op->upcall.req.param.op =
 856                           ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;
 857
 858         } else if (!strcmp(kobj_id, CAPCACHE_KOBJ_ID)) {
 859                 capcache_attr = (struct capcache_orangefs_attribute *)attr;
 860
 861                 if (!strcmp(capcache_attr->attr.name, "timeout_secs"))
 862                         new_op->upcall.req.param.op =
 863                                 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
 864
 865                 if (!strcmp(capcache_attr->attr.name, "hard_limit"))
 866                         new_op->upcall.req.param.op =
 867                                 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
 868
 869                 if (!strcmp(capcache_attr->attr.name, "soft_limit"))
 870                         new_op->upcall.req.param.op =
 871                                 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
 872
 873                 if (!strcmp(capcache_attr->attr.name, "reclaim_percentage"))
 874                         new_op->upcall.req.param.op =
 875                           ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;
 876
 877         } else if (!strcmp(kobj_id, CCACHE_KOBJ_ID)) {
 878                 ccache_attr = (struct ccache_orangefs_attribute *)attr;
 879
 880                 if (!strcmp(ccache_attr->attr.name, "timeout_secs"))
 881                         new_op->upcall.req.param.op =
 882                                 ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
 883
 884                 if (!strcmp(ccache_attr->attr.name, "hard_limit"))
 885                         new_op->upcall.req.param.op =
 886                                 ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
 887
 888                 if (!strcmp(ccache_attr->attr.name, "soft_limit"))
 889                         new_op->upcall.req.param.op =
 890                                 ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
 891
 892                 if (!strcmp(ccache_attr->attr.name, "reclaim_percentage"))
 893                         new_op->upcall.req.param.op =
 894                           ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;
 895
 896         } else if (!strcmp(kobj_id, NCACHE_KOBJ_ID)) {
 897                 ncache_attr = (struct ncache_orangefs_attribute *)attr;
 898
 899                 if (!strcmp(ncache_attr->attr.name, "timeout_msecs"))
 900                         new_op->upcall.req.param.op =
 901                                 ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
 902
 903                 if (!strcmp(ncache_attr->attr.name, "hard_limit"))
 904                         new_op->upcall.req.param.op =
 905                                 ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
 906
 907                 if (!strcmp(ncache_attr->attr.name, "soft_limit"))
 908                         new_op->upcall.req.param.op =
 909                                 ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
 910
 911                 if (!strcmp(ncache_attr->attr.name, "reclaim_percentage"))
 912                         new_op->upcall.req.param.op =
 913                           ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;
 914
 915         } else if (!strcmp(kobj_id, PC_KOBJ_ID)) {
 916                 pc_attr = (struct pc_orangefs_attribute *)attr;
 917
 918                 if (!strcmp(pc_attr->attr.name, ACACHE_KOBJ_ID))
 919                         new_op->upcall.req.perf_count.type =
 920                                 ORANGEFS_PERF_COUNT_REQUEST_ACACHE;
 921
 922                 if (!strcmp(pc_attr->attr.name, CAPCACHE_KOBJ_ID))
 923                         new_op->upcall.req.perf_count.type =
 924                                 ORANGEFS_PERF_COUNT_REQUEST_CAPCACHE;
 925
 926                 if (!strcmp(pc_attr->attr.name, NCACHE_KOBJ_ID))
 927                         new_op->upcall.req.perf_count.type =
 928                                 ORANGEFS_PERF_COUNT_REQUEST_NCACHE;
 929
 930         } else {
 931                 gossip_err("sysfs_service_op_show: unknown kobj_id:%s:\n",
 932                            kobj_id);
 933                 rc = -EINVAL;
 934                 goto out;
 935         }
 936
 937
 938         if (strcmp(kobj_id, PC_KOBJ_ID))
 939                 ser_op_type = "orangefs_param";
 940         else
 941                 ser_op_type = "orangefs_perf_count";
 942
 943         /*
 944          * The service_operation will return an errno return code on
 945          * error, and zero on success.
 946          */
 947         rc = service_operation(new_op, ser_op_type, ORANGEFS_OP_INTERRUPTIBLE);
 948
 949 out:
 950         if (!rc) {
 951                 if (strcmp(kobj_id, PC_KOBJ_ID)) {
 952                         rc = scnprintf(buf,
 953                                        PAGE_SIZE,
 954                                        "%d\n",
 955                                        (int)new_op->downcall.resp.param.value);
 956                 } else {
 957                         rc = scnprintf(
 958                                 buf,
 959                                 PAGE_SIZE,
 960                                 "%s",
 961                                 new_op->downcall.resp.perf_count.buffer);
 962                 }
 963         }
 964
 965         op_release(new_op);
 966
 967         return rc;
 968
 969 }
 970
 971 static ssize_t service_orangefs_show(struct orangefs_obj *orangefs_obj,
 972                                      struct orangefs_attribute *attr,
 973                                      char *buf)
 974 {
 975         int rc = 0;
 976
 977         rc = sysfs_service_op_show(ORANGEFS_KOBJ_ID, buf, (void *)attr);
 978
 979         return rc;
 980 }
 981
 982 static ssize_t
 983         service_acache_show(struct acache_orangefs_obj *acache_orangefs_obj,
 984                             struct acache_orangefs_attribute *attr,
 985                             char *buf)
 986 {
 987         int rc = 0;
 988
 989         rc = sysfs_service_op_show(ACACHE_KOBJ_ID, buf, (void *)attr);
 990
 991         return rc;
 992 }
 993
 994 static ssize_t service_capcache_show(struct capcache_orangefs_obj
 995                                         *capcache_orangefs_obj,
 996                                      struct capcache_orangefs_attribute *attr,
 997                                      char *buf)
 998 {
 999         int rc = 0;
1000
1001         rc = sysfs_service_op_show(CAPCACHE_KOBJ_ID, buf, (void *)attr);
1002
1003         return rc;
1004 }
1005
1006 static ssize_t service_ccache_show(struct ccache_orangefs_obj
1007                                         *ccache_orangefs_obj,
1008                                    struct ccache_orangefs_attribute *attr,
1009                                    char *buf)
1010 {
1011         int rc = 0;
1012
1013         rc = sysfs_service_op_show(CCACHE_KOBJ_ID, buf, (void *)attr);
1014
1015         return rc;
1016 }
1017
1018 static ssize_t
1019         service_ncache_show(struct ncache_orangefs_obj *ncache_orangefs_obj,
1020                             struct ncache_orangefs_attribute *attr,
1021                             char *buf)
1022 {
1023         int rc = 0;
1024
1025         rc = sysfs_service_op_show(NCACHE_KOBJ_ID, buf, (void *)attr);
1026
1027         return rc;
1028 }
1029
1030 static ssize_t
1031         service_pc_show(struct pc_orangefs_obj *pc_orangefs_obj,
1032                             struct pc_orangefs_attribute *attr,
1033                             char *buf)
1034 {
1035         int rc = 0;
1036
1037         rc = sysfs_service_op_show(PC_KOBJ_ID, buf, (void *)attr);
1038
1039         return rc;
1040 }
1041
1042 /*
1043  * pass attribute values back to userspace with a service operation.
1044  *
1045  * We have to do a memory allocation, an sscanf and a service operation.
1046  * And we have to evaluate what the user entered, to make sure the
1047  * value is within the range supported by the attribute. So, there's
1048  * a lot of return code checking and mapping going on here.
1049  *
1050  * We want to return 1 if we think everything went OK, and
1051  * EINVAL if not.
1052  */
1053 static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
1054 {
1055         struct orangefs_kernel_op_s *new_op = NULL;
1056         int val = 0;
1057         int rc = 0;
1058         struct orangefs_attribute *orangefs_attr;
1059         struct acache_orangefs_attribute *acache_attr;
1060         struct capcache_orangefs_attribute *capcache_attr;
1061         struct ccache_orangefs_attribute *ccache_attr;
1062         struct ncache_orangefs_attribute *ncache_attr;
1063
1064         gossip_debug(GOSSIP_SYSFS_DEBUG,
1065                      "sysfs_service_op_store: id:%s:\n",
1066                      kobj_id);
1067
1068         new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
1069         if (!new_op)
1070                 return -EINVAL; /* sic */
1071
1072         /* Can't do a service_operation if the client is not running... */
1073         rc = is_daemon_in_service();
1074         if (rc) {
1075                 pr_info("%s: Client not running :%d:\n",
1076                         __func__,
1077                         is_daemon_in_service());
1078                 goto out;
1079         }
1080
1081         /*
1082          * The value we want to send back to userspace is in buf.
1083          */
1084         rc = kstrtoint(buf, 0, &val);
1085         if (rc)
1086                 goto out;
1087
1088         if (!strcmp(kobj_id, ORANGEFS_KOBJ_ID)) {
1089                 orangefs_attr = (struct orangefs_attribute *)attr;
1090
1091                 if (!strcmp(orangefs_attr->attr.name, "perf_history_size")) {
1092                         if (val > 0) {
1093                                 new_op->upcall.req.param.op =
1094                                   ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
1095                         } else {
1096                                 rc = 0;
1097                                 goto out;
1098                         }
1099                 } else if (!strcmp(orangefs_attr->attr.name,
1100                                    "perf_time_interval_secs")) {
1101                         if (val > 0) {
1102                                 new_op->upcall.req.param.op =
1103                                 ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
1104                         } else {
1105                                 rc = 0;
1106                                 goto out;
1107                         }
1108                 } else if (!strcmp(orangefs_attr->attr.name,
1109                                    "perf_counter_reset")) {
1110                         if ((val == 0) || (val == 1)) {
1111                                 new_op->upcall.req.param.op =
1112                                         ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;
1113                         } else {
1114                                 rc = 0;
1115                                 goto out;
1116                         }
1117                 }
1118
1119         } else if (!strcmp(kobj_id, ACACHE_KOBJ_ID)) {
1120                 acache_attr = (struct acache_orangefs_attribute *)attr;
1121
1122                 if (!strcmp(acache_attr->attr.name, "hard_limit")) {
1123                         if (val > -1) {
1124                                 new_op->upcall.req.param.op =
1125                                   ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
1126                         } else {
1127                                 rc = 0;
1128                                 goto out;
1129                         }
1130                 } else if (!strcmp(acache_attr->attr.name, "soft_limit")) {
1131                         if (val > -1) {
1132                                 new_op->upcall.req.param.op =
1133                                   ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
1134                         } else {
1135                                 rc = 0;
1136                                 goto out;
1137                         }
1138                 } else if (!strcmp(acache_attr->attr.name,
1139                                    "reclaim_percentage")) {
1140                         if ((val > -1) && (val < 101)) {
1141                                 new_op->upcall.req.param.op =
1142                                   ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;
1143                         } else {
1144                                 rc = 0;
1145                                 goto out;
1146                         }
1147                 } else if (!strcmp(acache_attr->attr.name, "timeout_msecs")) {
1148                         if (val > -1) {
1149                                 new_op->upcall.req.param.op =
1150                                   ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
1151                         } else {
1152                                 rc = 0;
1153                                 goto out;
1154                         }
1155                 }
1156
1157         } else if (!strcmp(kobj_id, CAPCACHE_KOBJ_ID)) {
1158                 capcache_attr = (struct capcache_orangefs_attribute *)attr;
1159
1160                 if (!strcmp(capcache_attr->attr.name, "hard_limit")) {
1161                         if (val > -1) {
1162                                 new_op->upcall.req.param.op =
1163                                   ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
1164                         } else {
1165                                 rc = 0;
1166                                 goto out;
1167                         }
1168                 } else if (!strcmp(capcache_attr->attr.name, "soft_limit")) {
1169                         if (val > -1) {
1170                                 new_op->upcall.req.param.op =
1171                                   ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
1172                         } else {
1173                                 rc = 0;
1174                                 goto out;
1175                         }
1176                 } else if (!strcmp(capcache_attr->attr.name,
1177                                    "reclaim_percentage")) {
1178                         if ((val > -1) && (val < 101)) {
1179                                 new_op->upcall.req.param.op =
1180                                   ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;
1181                         } else {
1182                                 rc = 0;
1183                                 goto out;
1184                         }
1185                 } else if (!strcmp(capcache_attr->attr.name, "timeout_secs")) {
1186                         if (val > -1) {
1187                                 new_op->upcall.req.param.op =
1188                                   ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
1189                         } else {
1190                                 rc = 0;
1191                                 goto out;
1192                         }
1193                 }
1194
1195         } else if (!strcmp(kobj_id, CCACHE_KOBJ_ID)) {
1196                 ccache_attr = (struct ccache_orangefs_attribute *)attr;
1197
1198                 if (!strcmp(ccache_attr->attr.name, "hard_limit")) {
1199                         if (val > -1) {
1200                                 new_op->upcall.req.param.op =
1201                                   ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
1202                         } else {
1203                                 rc = 0;
1204                                 goto out;
1205                         }
1206                 } else if (!strcmp(ccache_attr->attr.name, "soft_limit")) {
1207                         if (val > -1) {
1208                                 new_op->upcall.req.param.op =
1209                                   ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
1210                         } else {
1211                                 rc = 0;
1212                                 goto out;
1213                         }
1214                 } else if (!strcmp(ccache_attr->attr.name,
1215                                    "reclaim_percentage")) {
1216                         if ((val > -1) && (val < 101)) {
1217                                 new_op->upcall.req.param.op =
1218                                   ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;
1219                         } else {
1220                                 rc = 0;
1221                                 goto out;
1222                         }
1223                 } else if (!strcmp(ccache_attr->attr.name, "timeout_secs")) {
1224                         if (val > -1) {
1225                                 new_op->upcall.req.param.op =
1226                                   ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
1227                         } else {
1228                                 rc = 0;
1229                                 goto out;
1230                         }
1231                 }
1232
1233         } else if (!strcmp(kobj_id, NCACHE_KOBJ_ID)) {
1234                 ncache_attr = (struct ncache_orangefs_attribute *)attr;
1235
1236                 if (!strcmp(ncache_attr->attr.name, "hard_limit")) {
1237                         if (val > -1) {
1238                                 new_op->upcall.req.param.op =
1239                                   ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
1240                         } else {
1241                                 rc = 0;
1242                                 goto out;
1243                         }
1244                 } else if (!strcmp(ncache_attr->attr.name, "soft_limit")) {
1245                         if (val > -1) {
1246                                 new_op->upcall.req.param.op =
1247                                   ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
1248                         } else {
1249                                 rc = 0;
1250                                 goto out;
1251                         }
1252                 } else if (!strcmp(ncache_attr->attr.name,
1253                                    "reclaim_percentage")) {
1254                         if ((val > -1) && (val < 101)) {
1255                                 new_op->upcall.req.param.op =
1256                                         ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;
1257                         } else {
1258                                 rc = 0;
1259                                 goto out;
1260                         }
1261                 } else if (!strcmp(ncache_attr->attr.name, "timeout_msecs")) {
1262                         if (val > -1) {
1263                                 new_op->upcall.req.param.op =
1264                                   ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
1265                         } else {
1266                                 rc = 0;
1267                                 goto out;
1268                         }
1269                 }
1270
1271         } else {
1272                 gossip_err("sysfs_service_op_store: unknown kobj_id:%s:\n",
1273                            kobj_id);
1274                 rc = -EINVAL;
1275                 goto out;
1276         }
1277
1278         new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
1279
1280         new_op->upcall.req.param.value = val;
1281
1282         /*
1283          * The service_operation will return a errno return code on
1284          * error, and zero on success.
1285          */
1286         rc = service_operation(new_op, "orangefs_param", ORANGEFS_OP_INTERRUPTIBLE);
1287
1288         if (rc < 0) {
1289                 gossip_err("sysfs_service_op_store: service op returned:%d:\n",
1290                         rc);
1291                 rc = 0;
1292         } else {
1293                 rc = 1;
1294         }
1295
1296 out:
1297         op_release(new_op);
1298
1299         if (rc == -ENOMEM || rc == 0)
1300                 rc = -EINVAL;
1301
1302         return rc;
1303 }
1304
1305 static ssize_t
1306         service_orangefs_store(struct orangefs_obj *orangefs_obj,
1307                                struct orangefs_attribute *attr,
1308                                const char *buf,
1309                                size_t count)
1310 {
1311         int rc = 0;
1312
1313         rc = sysfs_service_op_store(ORANGEFS_KOBJ_ID, buf, (void *) attr);
1314
1315         /* rc should have an errno value if the service_op went bad. */
1316         if (rc == 1)
1317                 rc = count;
1318
1319         return rc;
1320 }
1321
1322 static ssize_t
1323         service_acache_store(struct acache_orangefs_obj *acache_orangefs_obj,
1324                              struct acache_orangefs_attribute *attr,
1325                              const char *buf,
1326                              size_t count)
1327 {
1328         int rc = 0;
1329
1330         rc = sysfs_service_op_store(ACACHE_KOBJ_ID, buf, (void *) attr);
1331
1332         /* rc should have an errno value if the service_op went bad. */
1333         if (rc == 1)
1334                 rc = count;
1335
1336         return rc;
1337 }
1338
1339 static ssize_t
1340         service_capcache_store(struct capcache_orangefs_obj
1341                                 *capcache_orangefs_obj,
1342                                struct capcache_orangefs_attribute *attr,
1343                                const char *buf,
1344                                size_t count)
1345 {
1346         int rc = 0;
1347
1348         rc = sysfs_service_op_store(CAPCACHE_KOBJ_ID, buf, (void *) attr);
1349
1350         /* rc should have an errno value if the service_op went bad. */
1351         if (rc == 1)
1352                 rc = count;
1353
1354         return rc;
1355 }
1356
1357 static ssize_t service_ccache_store(struct ccache_orangefs_obj
1358                                         *ccache_orangefs_obj,
1359                                     struct ccache_orangefs_attribute *attr,
1360                                     const char *buf,
1361                                     size_t count)
1362 {
1363         int rc = 0;
1364
1365         rc = sysfs_service_op_store(CCACHE_KOBJ_ID, buf, (void *) attr);
1366
1367         /* rc should have an errno value if the service_op went bad. */
1368         if (rc == 1)
1369                 rc = count;
1370
1371         return rc;
1372 }
1373
1374 static ssize_t
1375         service_ncache_store(struct ncache_orangefs_obj *ncache_orangefs_obj,
1376                              struct ncache_orangefs_attribute *attr,
1377                              const char *buf,
1378                              size_t count)
1379 {
1380         int rc = 0;
1381
1382         rc = sysfs_service_op_store(NCACHE_KOBJ_ID, buf, (void *) attr);
1383
1384         /* rc should have an errno value if the service_op went bad. */
1385         if (rc == 1)
1386                 rc = count;
1387
1388         return rc;
1389 }
1390
1391 static struct orangefs_attribute op_timeout_secs_attribute =
1392         __ATTR(op_timeout_secs, 0664, int_orangefs_show, int_store);
1393
1394 static struct orangefs_attribute slot_timeout_secs_attribute =
1395         __ATTR(slot_timeout_secs, 0664, int_orangefs_show, int_store);
1396
1397 static struct orangefs_attribute dcache_timeout_msecs_attribute =
1398         __ATTR(dcache_timeout_msecs, 0664, int_orangefs_show, int_store);
1399
1400 static struct orangefs_attribute getattr_timeout_msecs_attribute =
1401         __ATTR(getattr_timeout_msecs, 0664, int_orangefs_show, int_store);
1402
1403 static struct orangefs_attribute perf_counter_reset_attribute =
1404         __ATTR(perf_counter_reset,
1405                0664,
1406                service_orangefs_show,
1407                service_orangefs_store);
1408
1409 static struct orangefs_attribute perf_history_size_attribute =
1410         __ATTR(perf_history_size,
1411                0664,
1412                service_orangefs_show,
1413                service_orangefs_store);
1414
1415 static struct orangefs_attribute perf_time_interval_secs_attribute =
1416         __ATTR(perf_time_interval_secs,
1417                0664,
1418                service_orangefs_show,
1419                service_orangefs_store);
1420
1421 static struct attribute *orangefs_default_attrs[] = {
1422         &op_timeout_secs_attribute.attr,
1423         &slot_timeout_secs_attribute.attr,
1424         &dcache_timeout_msecs_attribute.attr,
1425         &getattr_timeout_msecs_attribute.attr,
1426         &perf_counter_reset_attribute.attr,
1427         &perf_history_size_attribute.attr,
1428         &perf_time_interval_secs_attribute.attr,
1429         NULL,
1430 };
1431
1432 static struct kobj_type orangefs_ktype = {
1433         .sysfs_ops = &orangefs_sysfs_ops,
1434         .release = orangefs_release,
1435         .default_attrs = orangefs_default_attrs,
1436 };
1437
1438 static struct acache_orangefs_attribute acache_hard_limit_attribute =
1439         __ATTR(hard_limit,
1440                0664,
1441                service_acache_show,
1442                service_acache_store);
1443
1444 static struct acache_orangefs_attribute acache_reclaim_percent_attribute =
1445         __ATTR(reclaim_percentage,
1446                0664,
1447                service_acache_show,
1448                service_acache_store);
1449
1450 static struct acache_orangefs_attribute acache_soft_limit_attribute =
1451         __ATTR(soft_limit,
1452                0664,
1453                service_acache_show,
1454                service_acache_store);
1455
1456 static struct acache_orangefs_attribute acache_timeout_msecs_attribute =
1457         __ATTR(timeout_msecs,
1458                0664,
1459                service_acache_show,
1460                service_acache_store);
1461
1462 static struct attribute *acache_orangefs_default_attrs[] = {
1463         &acache_hard_limit_attribute.attr,
1464         &acache_reclaim_percent_attribute.attr,
1465         &acache_soft_limit_attribute.attr,
1466         &acache_timeout_msecs_attribute.attr,
1467         NULL,
1468 };
1469
1470 static struct kobj_type acache_orangefs_ktype = {
1471         .sysfs_ops = &acache_orangefs_sysfs_ops,
1472         .release = acache_orangefs_release,
1473         .default_attrs = acache_orangefs_default_attrs,
1474 };
1475
1476 static struct capcache_orangefs_attribute capcache_hard_limit_attribute =
1477         __ATTR(hard_limit,
1478                0664,
1479                service_capcache_show,
1480                service_capcache_store);
1481
1482 static struct capcache_orangefs_attribute capcache_reclaim_percent_attribute =
1483         __ATTR(reclaim_percentage,
1484                0664,
1485                service_capcache_show,
1486                service_capcache_store);
1487
1488 static struct capcache_orangefs_attribute capcache_soft_limit_attribute =
1489         __ATTR(soft_limit,
1490                0664,
1491                service_capcache_show,
1492                service_capcache_store);
1493
1494 static struct capcache_orangefs_attribute capcache_timeout_secs_attribute =
1495         __ATTR(timeout_secs,
1496                0664,
1497                service_capcache_show,
1498                service_capcache_store);
1499
1500 static struct attribute *capcache_orangefs_default_attrs[] = {
1501         &capcache_hard_limit_attribute.attr,
1502         &capcache_reclaim_percent_attribute.attr,
1503         &capcache_soft_limit_attribute.attr,
1504         &capcache_timeout_secs_attribute.attr,
1505         NULL,
1506 };
1507
1508 static struct kobj_type capcache_orangefs_ktype = {
1509         .sysfs_ops = &capcache_orangefs_sysfs_ops,
1510         .release = capcache_orangefs_release,
1511         .default_attrs = capcache_orangefs_default_attrs,
1512 };
1513
1514 static struct ccache_orangefs_attribute ccache_hard_limit_attribute =
1515         __ATTR(hard_limit,
1516                0664,
1517                service_ccache_show,
1518                service_ccache_store);
1519
1520 static struct ccache_orangefs_attribute ccache_reclaim_percent_attribute =
1521         __ATTR(reclaim_percentage,
1522                0664,
1523                service_ccache_show,
1524                service_ccache_store);
1525
1526 static struct ccache_orangefs_attribute ccache_soft_limit_attribute =
1527         __ATTR(soft_limit,
1528                0664,
1529                service_ccache_show,
1530                service_ccache_store);
1531
1532 static struct ccache_orangefs_attribute ccache_timeout_secs_attribute =
1533         __ATTR(timeout_secs,
1534                0664,
1535                service_ccache_show,
1536                service_ccache_store);
1537
1538 static struct attribute *ccache_orangefs_default_attrs[] = {
1539         &ccache_hard_limit_attribute.attr,
1540         &ccache_reclaim_percent_attribute.attr,
1541         &ccache_soft_limit_attribute.attr,
1542         &ccache_timeout_secs_attribute.attr,
1543         NULL,
1544 };
1545
1546 static struct kobj_type ccache_orangefs_ktype = {
1547         .sysfs_ops = &ccache_orangefs_sysfs_ops,
1548         .release = ccache_orangefs_release,
1549         .default_attrs = ccache_orangefs_default_attrs,
1550 };
1551
1552 static struct ncache_orangefs_attribute ncache_hard_limit_attribute =
1553         __ATTR(hard_limit,
1554                0664,
1555                service_ncache_show,
1556                service_ncache_store);
1557
1558 static struct ncache_orangefs_attribute ncache_reclaim_percent_attribute =
1559         __ATTR(reclaim_percentage,
1560                0664,
1561                service_ncache_show,
1562                service_ncache_store);
1563
1564 static struct ncache_orangefs_attribute ncache_soft_limit_attribute =
1565         __ATTR(soft_limit,
1566                0664,
1567                service_ncache_show,
1568                service_ncache_store);
1569
1570 static struct ncache_orangefs_attribute ncache_timeout_msecs_attribute =
1571         __ATTR(timeout_msecs,
1572                0664,
1573                service_ncache_show,
1574                service_ncache_store);
1575
1576 static struct attribute *ncache_orangefs_default_attrs[] = {
1577         &ncache_hard_limit_attribute.attr,
1578         &ncache_reclaim_percent_attribute.attr,
1579         &ncache_soft_limit_attribute.attr,
1580         &ncache_timeout_msecs_attribute.attr,
1581         NULL,
1582 };
1583
1584 static struct kobj_type ncache_orangefs_ktype = {
1585         .sysfs_ops = &ncache_orangefs_sysfs_ops,
1586         .release = ncache_orangefs_release,
1587         .default_attrs = ncache_orangefs_default_attrs,
1588 };
1589
1590 static struct pc_orangefs_attribute pc_acache_attribute =
1591         __ATTR(acache,
1592                0664,
1593                service_pc_show,
1594                NULL);
1595
1596 static struct pc_orangefs_attribute pc_capcache_attribute =
1597         __ATTR(capcache,
1598                0664,
1599                service_pc_show,
1600                NULL);
1601
1602 static struct pc_orangefs_attribute pc_ncache_attribute =
1603         __ATTR(ncache,
1604                0664,
1605                service_pc_show,
1606                NULL);
1607
1608 static struct attribute *pc_orangefs_default_attrs[] = {
1609         &pc_acache_attribute.attr,
1610         &pc_capcache_attribute.attr,
1611         &pc_ncache_attribute.attr,
1612         NULL,
1613 };
1614
1615 static struct kobj_type pc_orangefs_ktype = {
1616         .sysfs_ops = &pc_orangefs_sysfs_ops,
1617         .release = pc_orangefs_release,
1618         .default_attrs = pc_orangefs_default_attrs,
1619 };
1620
1621 static struct stats_orangefs_attribute stats_reads_attribute =
1622         __ATTR(reads,
1623                0664,
1624                int_stats_show,
1625                NULL);
1626
1627 static struct stats_orangefs_attribute stats_writes_attribute =
1628         __ATTR(writes,
1629                0664,
1630                int_stats_show,
1631                NULL);
1632
1633 static struct attribute *stats_orangefs_default_attrs[] = {
1634         &stats_reads_attribute.attr,
1635         &stats_writes_attribute.attr,
1636         NULL,
1637 };
1638
1639 static struct kobj_type stats_orangefs_ktype = {
1640         .sysfs_ops = &stats_orangefs_sysfs_ops,
1641         .release = stats_orangefs_release,
1642         .default_attrs = stats_orangefs_default_attrs,
1643 };
1644
1645 static struct orangefs_obj *orangefs_obj;
1646 static struct acache_orangefs_obj *acache_orangefs_obj;
1647 static struct capcache_orangefs_obj *capcache_orangefs_obj;
1648 static struct ccache_orangefs_obj *ccache_orangefs_obj;
1649 static struct ncache_orangefs_obj *ncache_orangefs_obj;
1650 static struct pc_orangefs_obj *pc_orangefs_obj;
1651 static struct stats_orangefs_obj *stats_orangefs_obj;
1652
1653 int orangefs_sysfs_init(void)
1654 {
1655         int rc = -EINVAL;
1656
1657         gossip_debug(GOSSIP_SYSFS_DEBUG, "orangefs_sysfs_init: start\n");
1658
1659         /* create /sys/fs/orangefs. */
1660         orangefs_obj = kzalloc(sizeof(*orangefs_obj), GFP_KERNEL);
1661         if (!orangefs_obj)
1662                 goto out;
1663
1664         rc = kobject_init_and_add(&orangefs_obj->kobj,
1665                                   &orangefs_ktype,
1666                                   fs_kobj,
1667                                   ORANGEFS_KOBJ_ID);
1668
1669         if (rc)
1670                 goto ofs_obj_bail;
1671
1672         kobject_uevent(&orangefs_obj->kobj, KOBJ_ADD);
1673
1674         /* create /sys/fs/orangefs/acache. */
1675         acache_orangefs_obj = kzalloc(sizeof(*acache_orangefs_obj), GFP_KERNEL);
1676         if (!acache_orangefs_obj) {
1677                 rc = -EINVAL;
1678                 goto ofs_obj_bail;
1679         }
1680
1681         rc = kobject_init_and_add(&acache_orangefs_obj->kobj,
1682                                   &acache_orangefs_ktype,
1683                                   &orangefs_obj->kobj,
1684                                   ACACHE_KOBJ_ID);
1685
1686         if (rc)
1687                 goto acache_obj_bail;
1688
1689         kobject_uevent(&acache_orangefs_obj->kobj, KOBJ_ADD);
1690
1691         /* create /sys/fs/orangefs/capcache. */
1692         capcache_orangefs_obj =
1693                 kzalloc(sizeof(*capcache_orangefs_obj), GFP_KERNEL);
1694         if (!capcache_orangefs_obj) {
1695                 rc = -EINVAL;
1696                 goto acache_obj_bail;
1697         }
1698
1699         rc = kobject_init_and_add(&capcache_orangefs_obj->kobj,
1700                                   &capcache_orangefs_ktype,
1701                                   &orangefs_obj->kobj,
1702                                   CAPCACHE_KOBJ_ID);
1703         if (rc)
1704                 goto capcache_obj_bail;
1705
1706         kobject_uevent(&capcache_orangefs_obj->kobj, KOBJ_ADD);
1707
1708         /* create /sys/fs/orangefs/ccache. */
1709         ccache_orangefs_obj =
1710                 kzalloc(sizeof(*ccache_orangefs_obj), GFP_KERNEL);
1711         if (!ccache_orangefs_obj) {
1712                 rc = -EINVAL;
1713                 goto capcache_obj_bail;
1714         }
1715
1716         rc = kobject_init_and_add(&ccache_orangefs_obj->kobj,
1717                                   &ccache_orangefs_ktype,
1718                                   &orangefs_obj->kobj,
1719                                   CCACHE_KOBJ_ID);
1720         if (rc)
1721                 goto ccache_obj_bail;
1722
1723         kobject_uevent(&ccache_orangefs_obj->kobj, KOBJ_ADD);
1724
1725         /* create /sys/fs/orangefs/ncache. */
1726         ncache_orangefs_obj = kzalloc(sizeof(*ncache_orangefs_obj), GFP_KERNEL);
1727         if (!ncache_orangefs_obj) {
1728                 rc = -EINVAL;
1729                 goto ccache_obj_bail;
1730         }
1731
1732         rc = kobject_init_and_add(&ncache_orangefs_obj->kobj,
1733                                   &ncache_orangefs_ktype,
1734                                   &orangefs_obj->kobj,
1735                                   NCACHE_KOBJ_ID);
1736
1737         if (rc)
1738                 goto ncache_obj_bail;
1739
1740         kobject_uevent(&ncache_orangefs_obj->kobj, KOBJ_ADD);
1741
1742         /* create /sys/fs/orangefs/perf_counters. */
1743         pc_orangefs_obj = kzalloc(sizeof(*pc_orangefs_obj), GFP_KERNEL);
1744         if (!pc_orangefs_obj) {
1745                 rc = -EINVAL;
1746                 goto ncache_obj_bail;
1747         }
1748
1749         rc = kobject_init_and_add(&pc_orangefs_obj->kobj,
1750                                   &pc_orangefs_ktype,
1751                                   &orangefs_obj->kobj,
1752                                   "perf_counters");
1753
1754         if (rc)
1755                 goto pc_obj_bail;
1756
1757         kobject_uevent(&pc_orangefs_obj->kobj, KOBJ_ADD);
1758
1759         /* create /sys/fs/orangefs/stats. */
1760         stats_orangefs_obj = kzalloc(sizeof(*stats_orangefs_obj), GFP_KERNEL);
1761         if (!stats_orangefs_obj) {
1762                 rc = -EINVAL;
1763                 goto pc_obj_bail;
1764         }
1765
1766         rc = kobject_init_and_add(&stats_orangefs_obj->kobj,
1767                                   &stats_orangefs_ktype,
1768                                   &orangefs_obj->kobj,
1769                                   STATS_KOBJ_ID);
1770
1771         if (rc)
1772                 goto stats_obj_bail;
1773
1774         kobject_uevent(&stats_orangefs_obj->kobj, KOBJ_ADD);
1775         goto out;
1776
1777 stats_obj_bail:
1778                 kobject_put(&stats_orangefs_obj->kobj);
1779
1780 pc_obj_bail:
1781                 kobject_put(&pc_orangefs_obj->kobj);
1782
1783 ncache_obj_bail:
1784                 kobject_put(&ncache_orangefs_obj->kobj);
1785
1786 ccache_obj_bail:
1787                 kobject_put(&ccache_orangefs_obj->kobj);
1788
1789 capcache_obj_bail:
1790                 kobject_put(&capcache_orangefs_obj->kobj);
1791
1792 acache_obj_bail:
1793                 kobject_put(&acache_orangefs_obj->kobj);
1794
1795 ofs_obj_bail:
1796                 kobject_put(&orangefs_obj->kobj);
1797 out:
1798         return rc;
1799 }
1800
1801 void orangefs_sysfs_exit(void)
1802 {
1803         gossip_debug(GOSSIP_SYSFS_DEBUG, "orangefs_sysfs_exit: start\n");
1804
1805         kobject_put(&acache_orangefs_obj->kobj);
1806         kobject_put(&capcache_orangefs_obj->kobj);
1807         kobject_put(&ccache_orangefs_obj->kobj);
1808         kobject_put(&ncache_orangefs_obj->kobj);
1809         kobject_put(&pc_orangefs_obj->kobj);
1810         kobject_put(&stats_orangefs_obj->kobj);
1811
1812         kobject_put(&orangefs_obj->kobj);
1813 }