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