1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131#include <linux/fs.h>
132#include <linux/kobject.h>
133#include <linux/string.h>
134#include <linux/sysfs.h>
135#include <linux/module.h>
136#include <linux/init.h>
137
138#include "protocol.h"
139#include "orangefs-kernel.h"
140#include "orangefs-sysfs.h"
141
142#define ORANGEFS_KOBJ_ID "orangefs"
143#define ACACHE_KOBJ_ID "acache"
144#define CAPCACHE_KOBJ_ID "capcache"
145#define CCACHE_KOBJ_ID "ccache"
146#define NCACHE_KOBJ_ID "ncache"
147#define PC_KOBJ_ID "pc"
148#define STATS_KOBJ_ID "stats"
149
150
151
152
153
154
155
156
157struct orangefs_attribute {
158 struct attribute attr;
159 ssize_t (*show)(struct kobject *kobj,
160 struct orangefs_attribute *attr,
161 char *buf);
162 ssize_t (*store)(struct kobject *kobj,
163 struct orangefs_attribute *attr,
164 const char *buf,
165 size_t count);
166};
167
168static ssize_t orangefs_attr_show(struct kobject *kobj,
169 struct attribute *attr,
170 char *buf)
171{
172 struct orangefs_attribute *attribute;
173
174 attribute = container_of(attr, struct orangefs_attribute, attr);
175 if (!attribute->show)
176 return -EIO;
177 return attribute->show(kobj, attribute, buf);
178}
179
180static ssize_t orangefs_attr_store(struct kobject *kobj,
181 struct attribute *attr,
182 const char *buf,
183 size_t len)
184{
185 struct orangefs_attribute *attribute;
186
187 if (!strcmp(kobj->name, PC_KOBJ_ID) ||
188 !strcmp(kobj->name, STATS_KOBJ_ID))
189 return -EPERM;
190
191 attribute = container_of(attr, struct orangefs_attribute, attr);
192 if (!attribute->store)
193 return -EIO;
194 return attribute->store(kobj, attribute, buf, len);
195}
196
197static const struct sysfs_ops orangefs_sysfs_ops = {
198 .show = orangefs_attr_show,
199 .store = orangefs_attr_store,
200};
201
202static ssize_t sysfs_int_show(struct kobject *kobj,
203 struct orangefs_attribute *attr, char *buf)
204{
205 int rc = -EIO;
206
207 gossip_debug(GOSSIP_SYSFS_DEBUG, "sysfs_int_show: id:%s:\n",
208 kobj->name);
209
210 if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
211 if (!strcmp(attr->attr.name, "op_timeout_secs")) {
212 rc = scnprintf(buf,
213 PAGE_SIZE,
214 "%d\n",
215 op_timeout_secs);
216 goto out;
217 } else if (!strcmp(attr->attr.name,
218 "slot_timeout_secs")) {
219 rc = scnprintf(buf,
220 PAGE_SIZE,
221 "%d\n",
222 slot_timeout_secs);
223 goto out;
224 } else if (!strcmp(attr->attr.name,
225 "dcache_timeout_msecs")) {
226 rc = scnprintf(buf,
227 PAGE_SIZE,
228 "%d\n",
229 orangefs_dcache_timeout_msecs);
230 goto out;
231 } else if (!strcmp(attr->attr.name,
232 "getattr_timeout_msecs")) {
233 rc = scnprintf(buf,
234 PAGE_SIZE,
235 "%d\n",
236 orangefs_getattr_timeout_msecs);
237 goto out;
238 } else {
239 goto out;
240 }
241
242 } else if (!strcmp(kobj->name, STATS_KOBJ_ID)) {
243 if (!strcmp(attr->attr.name, "reads")) {
244 rc = scnprintf(buf,
245 PAGE_SIZE,
246 "%lu\n",
247 orangefs_stats.reads);
248 goto out;
249 } else if (!strcmp(attr->attr.name, "writes")) {
250 rc = scnprintf(buf,
251 PAGE_SIZE,
252 "%lu\n",
253 orangefs_stats.writes);
254 goto out;
255 } else {
256 goto out;
257 }
258 }
259
260out:
261
262 return rc;
263}
264
265static ssize_t sysfs_int_store(struct kobject *kobj,
266 struct orangefs_attribute *attr, const char *buf, size_t count)
267{
268 int rc = 0;
269
270 gossip_debug(GOSSIP_SYSFS_DEBUG,
271 "sysfs_int_store: start attr->attr.name:%s: buf:%s:\n",
272 attr->attr.name, buf);
273
274 if (!strcmp(attr->attr.name, "op_timeout_secs")) {
275 rc = kstrtoint(buf, 0, &op_timeout_secs);
276 goto out;
277 } else if (!strcmp(attr->attr.name, "slot_timeout_secs")) {
278 rc = kstrtoint(buf, 0, &slot_timeout_secs);
279 goto out;
280 } else if (!strcmp(attr->attr.name, "dcache_timeout_msecs")) {
281 rc = kstrtoint(buf, 0, &orangefs_dcache_timeout_msecs);
282 goto out;
283 } else if (!strcmp(attr->attr.name, "getattr_timeout_msecs")) {
284 rc = kstrtoint(buf, 0, &orangefs_getattr_timeout_msecs);
285 goto out;
286 } else {
287 goto out;
288 }
289
290out:
291 if (rc)
292 rc = -EINVAL;
293 else
294 rc = count;
295
296 return rc;
297}
298
299
300
301
302static ssize_t sysfs_service_op_show(struct kobject *kobj,
303 struct orangefs_attribute *attr, char *buf)
304{
305 struct orangefs_kernel_op_s *new_op = NULL;
306 int rc = 0;
307 char *ser_op_type = NULL;
308 __u32 op_alloc_type;
309
310 gossip_debug(GOSSIP_SYSFS_DEBUG,
311 "sysfs_service_op_show: id:%s:\n",
312 kobj->name);
313
314 if (strcmp(kobj->name, PC_KOBJ_ID))
315 op_alloc_type = ORANGEFS_VFS_OP_PARAM;
316 else
317 op_alloc_type = ORANGEFS_VFS_OP_PERF_COUNT;
318
319 new_op = op_alloc(op_alloc_type);
320 if (!new_op)
321 return -ENOMEM;
322
323
324 rc = is_daemon_in_service();
325 if (rc) {
326 pr_info("%s: Client not running :%d:\n",
327 __func__,
328 is_daemon_in_service());
329 goto out;
330 }
331
332 if (strcmp(kobj->name, PC_KOBJ_ID))
333 new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_GET;
334
335 if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
336
337 if (!(orangefs_features & ORANGEFS_FEATURE_READAHEAD) &&
338 (!strcmp(attr->attr.name, "readahead_count") ||
339 !strcmp(attr->attr.name, "readahead_size") ||
340 !strcmp(attr->attr.name, "readahead_count_size") ||
341 !strcmp(attr->attr.name, "readahead_readcnt"))) {
342 rc = -EINVAL;
343 goto out;
344 }
345
346 if (!strcmp(attr->attr.name, "perf_history_size"))
347 new_op->upcall.req.param.op =
348 ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
349 else if (!strcmp(attr->attr.name,
350 "perf_time_interval_secs"))
351 new_op->upcall.req.param.op =
352 ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
353 else if (!strcmp(attr->attr.name,
354 "perf_counter_reset"))
355 new_op->upcall.req.param.op =
356 ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;
357
358 else if (!strcmp(attr->attr.name,
359 "readahead_count"))
360 new_op->upcall.req.param.op =
361 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT;
362
363 else if (!strcmp(attr->attr.name,
364 "readahead_size"))
365 new_op->upcall.req.param.op =
366 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_SIZE;
367
368 else if (!strcmp(attr->attr.name,
369 "readahead_count_size"))
370 new_op->upcall.req.param.op =
371 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT_SIZE;
372
373 else if (!strcmp(attr->attr.name,
374 "readahead_readcnt"))
375 new_op->upcall.req.param.op =
376 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_READCNT;
377 } else if (!strcmp(kobj->name, ACACHE_KOBJ_ID)) {
378 if (!strcmp(attr->attr.name, "timeout_msecs"))
379 new_op->upcall.req.param.op =
380 ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
381
382 if (!strcmp(attr->attr.name, "hard_limit"))
383 new_op->upcall.req.param.op =
384 ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
385
386 if (!strcmp(attr->attr.name, "soft_limit"))
387 new_op->upcall.req.param.op =
388 ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
389
390 if (!strcmp(attr->attr.name, "reclaim_percentage"))
391 new_op->upcall.req.param.op =
392 ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;
393
394 } else if (!strcmp(kobj->name, CAPCACHE_KOBJ_ID)) {
395 if (!strcmp(attr->attr.name, "timeout_secs"))
396 new_op->upcall.req.param.op =
397 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
398
399 if (!strcmp(attr->attr.name, "hard_limit"))
400 new_op->upcall.req.param.op =
401 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
402
403 if (!strcmp(attr->attr.name, "soft_limit"))
404 new_op->upcall.req.param.op =
405 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
406
407 if (!strcmp(attr->attr.name, "reclaim_percentage"))
408 new_op->upcall.req.param.op =
409 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;
410
411 } else if (!strcmp(kobj->name, CCACHE_KOBJ_ID)) {
412 if (!strcmp(attr->attr.name, "timeout_secs"))
413 new_op->upcall.req.param.op =
414 ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
415
416 if (!strcmp(attr->attr.name, "hard_limit"))
417 new_op->upcall.req.param.op =
418 ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
419
420 if (!strcmp(attr->attr.name, "soft_limit"))
421 new_op->upcall.req.param.op =
422 ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
423
424 if (!strcmp(attr->attr.name, "reclaim_percentage"))
425 new_op->upcall.req.param.op =
426 ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;
427
428 } else if (!strcmp(kobj->name, NCACHE_KOBJ_ID)) {
429 if (!strcmp(attr->attr.name, "timeout_msecs"))
430 new_op->upcall.req.param.op =
431 ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
432
433 if (!strcmp(attr->attr.name, "hard_limit"))
434 new_op->upcall.req.param.op =
435 ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
436
437 if (!strcmp(attr->attr.name, "soft_limit"))
438 new_op->upcall.req.param.op =
439 ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
440
441 if (!strcmp(attr->attr.name, "reclaim_percentage"))
442 new_op->upcall.req.param.op =
443 ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;
444
445 } else if (!strcmp(kobj->name, PC_KOBJ_ID)) {
446 if (!strcmp(attr->attr.name, ACACHE_KOBJ_ID))
447 new_op->upcall.req.perf_count.type =
448 ORANGEFS_PERF_COUNT_REQUEST_ACACHE;
449
450 if (!strcmp(attr->attr.name, CAPCACHE_KOBJ_ID))
451 new_op->upcall.req.perf_count.type =
452 ORANGEFS_PERF_COUNT_REQUEST_CAPCACHE;
453
454 if (!strcmp(attr->attr.name, NCACHE_KOBJ_ID))
455 new_op->upcall.req.perf_count.type =
456 ORANGEFS_PERF_COUNT_REQUEST_NCACHE;
457
458 } else {
459 gossip_err("sysfs_service_op_show: unknown kobj_id:%s:\n",
460 kobj->name);
461 rc = -EINVAL;
462 goto out;
463 }
464
465
466 if (strcmp(kobj->name, PC_KOBJ_ID))
467 ser_op_type = "orangefs_param";
468 else
469 ser_op_type = "orangefs_perf_count";
470
471
472
473
474
475 rc = service_operation(new_op, ser_op_type, ORANGEFS_OP_INTERRUPTIBLE);
476
477out:
478 if (!rc) {
479 if (strcmp(kobj->name, PC_KOBJ_ID)) {
480 if (new_op->upcall.req.param.op ==
481 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT_SIZE) {
482 rc = scnprintf(buf, PAGE_SIZE, "%d %d\n",
483 (int)new_op->downcall.resp.param.u.
484 value32[0],
485 (int)new_op->downcall.resp.param.u.
486 value32[1]);
487 } else {
488 rc = scnprintf(buf, PAGE_SIZE, "%d\n",
489 (int)new_op->downcall.resp.param.u.value64);
490 }
491 } else {
492 rc = scnprintf(
493 buf,
494 PAGE_SIZE,
495 "%s",
496 new_op->downcall.resp.perf_count.buffer);
497 }
498 }
499
500 op_release(new_op);
501
502 return rc;
503
504}
505
506
507
508
509
510
511
512
513
514
515
516
517static ssize_t sysfs_service_op_store(struct kobject *kobj,
518 struct orangefs_attribute *attr, const char *buf, size_t count)
519{
520 struct orangefs_kernel_op_s *new_op = NULL;
521 int val = 0;
522 int rc = 0;
523
524 gossip_debug(GOSSIP_SYSFS_DEBUG,
525 "sysfs_service_op_store: id:%s:\n",
526 kobj->name);
527
528 new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
529 if (!new_op)
530 return -EINVAL;
531
532
533 rc = is_daemon_in_service();
534 if (rc) {
535 pr_info("%s: Client not running :%d:\n",
536 __func__,
537 is_daemon_in_service());
538 goto out;
539 }
540
541
542
543
544
545 if (strcmp(kobj->name, ORANGEFS_KOBJ_ID) ||
546 strcmp(attr->attr.name, "readahead_count_size")) {
547 rc = kstrtoint(buf, 0, &val);
548 if (rc)
549 goto out;
550 }
551
552 new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
553
554 if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
555
556 if (!(orangefs_features & ORANGEFS_FEATURE_READAHEAD) &&
557 (!strcmp(attr->attr.name, "readahead_count") ||
558 !strcmp(attr->attr.name, "readahead_size") ||
559 !strcmp(attr->attr.name, "readahead_count_size") ||
560 !strcmp(attr->attr.name, "readahead_readcnt"))) {
561 rc = -EINVAL;
562 goto out;
563 }
564
565 if (!strcmp(attr->attr.name, "perf_history_size")) {
566 if (val > 0) {
567 new_op->upcall.req.param.op =
568 ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
569 } else {
570 rc = 0;
571 goto out;
572 }
573 } else if (!strcmp(attr->attr.name,
574 "perf_time_interval_secs")) {
575 if (val > 0) {
576 new_op->upcall.req.param.op =
577 ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
578 } else {
579 rc = 0;
580 goto out;
581 }
582 } else if (!strcmp(attr->attr.name,
583 "perf_counter_reset")) {
584 if ((val == 0) || (val == 1)) {
585 new_op->upcall.req.param.op =
586 ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;
587 } else {
588 rc = 0;
589 goto out;
590 }
591 } else if (!strcmp(attr->attr.name,
592 "readahead_count")) {
593 if ((val >= 0)) {
594 new_op->upcall.req.param.op =
595 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT;
596 } else {
597 rc = 0;
598 goto out;
599 }
600 } else if (!strcmp(attr->attr.name,
601 "readahead_size")) {
602 if ((val >= 0)) {
603 new_op->upcall.req.param.op =
604 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_SIZE;
605 } else {
606 rc = 0;
607 goto out;
608 }
609 } else if (!strcmp(attr->attr.name,
610 "readahead_count_size")) {
611 int val1, val2;
612 rc = sscanf(buf, "%d %d", &val1, &val2);
613 if (rc < 2) {
614 rc = 0;
615 goto out;
616 }
617 if ((val1 >= 0) && (val2 >= 0)) {
618 new_op->upcall.req.param.op =
619 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT_SIZE;
620 } else {
621 rc = 0;
622 goto out;
623 }
624 new_op->upcall.req.param.u.value32[0] = val1;
625 new_op->upcall.req.param.u.value32[1] = val2;
626 goto value_set;
627 } else if (!strcmp(attr->attr.name,
628 "readahead_readcnt")) {
629 if ((val >= 0)) {
630 new_op->upcall.req.param.op =
631 ORANGEFS_PARAM_REQUEST_OP_READAHEAD_READCNT;
632 } else {
633 rc = 0;
634 goto out;
635 }
636 }
637
638 } else if (!strcmp(kobj->name, ACACHE_KOBJ_ID)) {
639 if (!strcmp(attr->attr.name, "hard_limit")) {
640 if (val > -1) {
641 new_op->upcall.req.param.op =
642 ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
643 } else {
644 rc = 0;
645 goto out;
646 }
647 } else if (!strcmp(attr->attr.name, "soft_limit")) {
648 if (val > -1) {
649 new_op->upcall.req.param.op =
650 ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
651 } else {
652 rc = 0;
653 goto out;
654 }
655 } else if (!strcmp(attr->attr.name,
656 "reclaim_percentage")) {
657 if ((val > -1) && (val < 101)) {
658 new_op->upcall.req.param.op =
659 ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;
660 } else {
661 rc = 0;
662 goto out;
663 }
664 } else if (!strcmp(attr->attr.name, "timeout_msecs")) {
665 if (val > -1) {
666 new_op->upcall.req.param.op =
667 ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
668 } else {
669 rc = 0;
670 goto out;
671 }
672 }
673
674 } else if (!strcmp(kobj->name, CAPCACHE_KOBJ_ID)) {
675 if (!strcmp(attr->attr.name, "hard_limit")) {
676 if (val > -1) {
677 new_op->upcall.req.param.op =
678 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
679 } else {
680 rc = 0;
681 goto out;
682 }
683 } else if (!strcmp(attr->attr.name, "soft_limit")) {
684 if (val > -1) {
685 new_op->upcall.req.param.op =
686 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
687 } else {
688 rc = 0;
689 goto out;
690 }
691 } else if (!strcmp(attr->attr.name,
692 "reclaim_percentage")) {
693 if ((val > -1) && (val < 101)) {
694 new_op->upcall.req.param.op =
695 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;
696 } else {
697 rc = 0;
698 goto out;
699 }
700 } else if (!strcmp(attr->attr.name, "timeout_secs")) {
701 if (val > -1) {
702 new_op->upcall.req.param.op =
703 ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
704 } else {
705 rc = 0;
706 goto out;
707 }
708 }
709
710 } else if (!strcmp(kobj->name, CCACHE_KOBJ_ID)) {
711 if (!strcmp(attr->attr.name, "hard_limit")) {
712 if (val > -1) {
713 new_op->upcall.req.param.op =
714 ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
715 } else {
716 rc = 0;
717 goto out;
718 }
719 } else if (!strcmp(attr->attr.name, "soft_limit")) {
720 if (val > -1) {
721 new_op->upcall.req.param.op =
722 ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
723 } else {
724 rc = 0;
725 goto out;
726 }
727 } else if (!strcmp(attr->attr.name,
728 "reclaim_percentage")) {
729 if ((val > -1) && (val < 101)) {
730 new_op->upcall.req.param.op =
731 ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;
732 } else {
733 rc = 0;
734 goto out;
735 }
736 } else if (!strcmp(attr->attr.name, "timeout_secs")) {
737 if (val > -1) {
738 new_op->upcall.req.param.op =
739 ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
740 } else {
741 rc = 0;
742 goto out;
743 }
744 }
745
746 } else if (!strcmp(kobj->name, NCACHE_KOBJ_ID)) {
747 if (!strcmp(attr->attr.name, "hard_limit")) {
748 if (val > -1) {
749 new_op->upcall.req.param.op =
750 ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
751 } else {
752 rc = 0;
753 goto out;
754 }
755 } else if (!strcmp(attr->attr.name, "soft_limit")) {
756 if (val > -1) {
757 new_op->upcall.req.param.op =
758 ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
759 } else {
760 rc = 0;
761 goto out;
762 }
763 } else if (!strcmp(attr->attr.name,
764 "reclaim_percentage")) {
765 if ((val > -1) && (val < 101)) {
766 new_op->upcall.req.param.op =
767 ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;
768 } else {
769 rc = 0;
770 goto out;
771 }
772 } else if (!strcmp(attr->attr.name, "timeout_msecs")) {
773 if (val > -1) {
774 new_op->upcall.req.param.op =
775 ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
776 } else {
777 rc = 0;
778 goto out;
779 }
780 }
781
782 } else {
783 gossip_err("sysfs_service_op_store: unknown kobj_id:%s:\n",
784 kobj->name);
785 rc = -EINVAL;
786 goto out;
787 }
788
789 new_op->upcall.req.param.u.value64 = val;
790value_set:
791
792
793
794
795
796 rc = service_operation(new_op, "orangefs_param", ORANGEFS_OP_INTERRUPTIBLE);
797
798 if (rc < 0) {
799 gossip_err("sysfs_service_op_store: service op returned:%d:\n",
800 rc);
801 rc = 0;
802 } else {
803 rc = count;
804 }
805
806out:
807 op_release(new_op);
808
809 if (rc == -ENOMEM || rc == 0)
810 rc = -EINVAL;
811
812 return rc;
813}
814
815static struct orangefs_attribute op_timeout_secs_attribute =
816 __ATTR(op_timeout_secs, 0664, sysfs_int_show, sysfs_int_store);
817
818static struct orangefs_attribute slot_timeout_secs_attribute =
819 __ATTR(slot_timeout_secs, 0664, sysfs_int_show, sysfs_int_store);
820
821static struct orangefs_attribute dcache_timeout_msecs_attribute =
822 __ATTR(dcache_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);
823
824static struct orangefs_attribute getattr_timeout_msecs_attribute =
825 __ATTR(getattr_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);
826
827static struct orangefs_attribute readahead_count_attribute =
828 __ATTR(readahead_count, 0664, sysfs_service_op_show,
829 sysfs_service_op_store);
830
831static struct orangefs_attribute readahead_size_attribute =
832 __ATTR(readahead_size, 0664, sysfs_service_op_show,
833 sysfs_service_op_store);
834
835static struct orangefs_attribute readahead_count_size_attribute =
836 __ATTR(readahead_count_size, 0664, sysfs_service_op_show,
837 sysfs_service_op_store);
838
839static struct orangefs_attribute readahead_readcnt_attribute =
840 __ATTR(readahead_readcnt, 0664, sysfs_service_op_show,
841 sysfs_service_op_store);
842
843static struct orangefs_attribute perf_counter_reset_attribute =
844 __ATTR(perf_counter_reset,
845 0664,
846 sysfs_service_op_show,
847 sysfs_service_op_store);
848
849static struct orangefs_attribute perf_history_size_attribute =
850 __ATTR(perf_history_size,
851 0664,
852 sysfs_service_op_show,
853 sysfs_service_op_store);
854
855static struct orangefs_attribute perf_time_interval_secs_attribute =
856 __ATTR(perf_time_interval_secs,
857 0664,
858 sysfs_service_op_show,
859 sysfs_service_op_store);
860
861static struct attribute *orangefs_default_attrs[] = {
862 &op_timeout_secs_attribute.attr,
863 &slot_timeout_secs_attribute.attr,
864 &dcache_timeout_msecs_attribute.attr,
865 &getattr_timeout_msecs_attribute.attr,
866 &readahead_count_attribute.attr,
867 &readahead_size_attribute.attr,
868 &readahead_count_size_attribute.attr,
869 &readahead_readcnt_attribute.attr,
870 &perf_counter_reset_attribute.attr,
871 &perf_history_size_attribute.attr,
872 &perf_time_interval_secs_attribute.attr,
873 NULL,
874};
875
876static struct kobj_type orangefs_ktype = {
877 .sysfs_ops = &orangefs_sysfs_ops,
878 .default_attrs = orangefs_default_attrs,
879};
880
881static struct orangefs_attribute acache_hard_limit_attribute =
882 __ATTR(hard_limit,
883 0664,
884 sysfs_service_op_show,
885 sysfs_service_op_store);
886
887static struct orangefs_attribute acache_reclaim_percent_attribute =
888 __ATTR(reclaim_percentage,
889 0664,
890 sysfs_service_op_show,
891 sysfs_service_op_store);
892
893static struct orangefs_attribute acache_soft_limit_attribute =
894 __ATTR(soft_limit,
895 0664,
896 sysfs_service_op_show,
897 sysfs_service_op_store);
898
899static struct orangefs_attribute acache_timeout_msecs_attribute =
900 __ATTR(timeout_msecs,
901 0664,
902 sysfs_service_op_show,
903 sysfs_service_op_store);
904
905static struct attribute *acache_orangefs_default_attrs[] = {
906 &acache_hard_limit_attribute.attr,
907 &acache_reclaim_percent_attribute.attr,
908 &acache_soft_limit_attribute.attr,
909 &acache_timeout_msecs_attribute.attr,
910 NULL,
911};
912
913static struct kobj_type acache_orangefs_ktype = {
914 .sysfs_ops = &orangefs_sysfs_ops,
915 .default_attrs = acache_orangefs_default_attrs,
916};
917
918static struct orangefs_attribute capcache_hard_limit_attribute =
919 __ATTR(hard_limit,
920 0664,
921 sysfs_service_op_show,
922 sysfs_service_op_store);
923
924static struct orangefs_attribute capcache_reclaim_percent_attribute =
925 __ATTR(reclaim_percentage,
926 0664,
927 sysfs_service_op_show,
928 sysfs_service_op_store);
929
930static struct orangefs_attribute capcache_soft_limit_attribute =
931 __ATTR(soft_limit,
932 0664,
933 sysfs_service_op_show,
934 sysfs_service_op_store);
935
936static struct orangefs_attribute capcache_timeout_secs_attribute =
937 __ATTR(timeout_secs,
938 0664,
939 sysfs_service_op_show,
940 sysfs_service_op_store);
941
942static struct attribute *capcache_orangefs_default_attrs[] = {
943 &capcache_hard_limit_attribute.attr,
944 &capcache_reclaim_percent_attribute.attr,
945 &capcache_soft_limit_attribute.attr,
946 &capcache_timeout_secs_attribute.attr,
947 NULL,
948};
949
950static struct kobj_type capcache_orangefs_ktype = {
951 .sysfs_ops = &orangefs_sysfs_ops,
952 .default_attrs = capcache_orangefs_default_attrs,
953};
954
955static struct orangefs_attribute ccache_hard_limit_attribute =
956 __ATTR(hard_limit,
957 0664,
958 sysfs_service_op_show,
959 sysfs_service_op_store);
960
961static struct orangefs_attribute ccache_reclaim_percent_attribute =
962 __ATTR(reclaim_percentage,
963 0664,
964 sysfs_service_op_show,
965 sysfs_service_op_store);
966
967static struct orangefs_attribute ccache_soft_limit_attribute =
968 __ATTR(soft_limit,
969 0664,
970 sysfs_service_op_show,
971 sysfs_service_op_store);
972
973static struct orangefs_attribute ccache_timeout_secs_attribute =
974 __ATTR(timeout_secs,
975 0664,
976 sysfs_service_op_show,
977 sysfs_service_op_store);
978
979static struct attribute *ccache_orangefs_default_attrs[] = {
980 &ccache_hard_limit_attribute.attr,
981 &ccache_reclaim_percent_attribute.attr,
982 &ccache_soft_limit_attribute.attr,
983 &ccache_timeout_secs_attribute.attr,
984 NULL,
985};
986
987static struct kobj_type ccache_orangefs_ktype = {
988 .sysfs_ops = &orangefs_sysfs_ops,
989 .default_attrs = ccache_orangefs_default_attrs,
990};
991
992static struct orangefs_attribute ncache_hard_limit_attribute =
993 __ATTR(hard_limit,
994 0664,
995 sysfs_service_op_show,
996 sysfs_service_op_store);
997
998static struct orangefs_attribute ncache_reclaim_percent_attribute =
999 __ATTR(reclaim_percentage,
1000 0664,
1001 sysfs_service_op_show,
1002 sysfs_service_op_store);
1003
1004static struct orangefs_attribute ncache_soft_limit_attribute =
1005 __ATTR(soft_limit,
1006 0664,
1007 sysfs_service_op_show,
1008 sysfs_service_op_store);
1009
1010static struct orangefs_attribute ncache_timeout_msecs_attribute =
1011 __ATTR(timeout_msecs,
1012 0664,
1013 sysfs_service_op_show,
1014 sysfs_service_op_store);
1015
1016static struct attribute *ncache_orangefs_default_attrs[] = {
1017 &ncache_hard_limit_attribute.attr,
1018 &ncache_reclaim_percent_attribute.attr,
1019 &ncache_soft_limit_attribute.attr,
1020 &ncache_timeout_msecs_attribute.attr,
1021 NULL,
1022};
1023
1024static struct kobj_type ncache_orangefs_ktype = {
1025 .sysfs_ops = &orangefs_sysfs_ops,
1026 .default_attrs = ncache_orangefs_default_attrs,
1027};
1028
1029static struct orangefs_attribute pc_acache_attribute =
1030 __ATTR(acache,
1031 0664,
1032 sysfs_service_op_show,
1033 NULL);
1034
1035static struct orangefs_attribute pc_capcache_attribute =
1036 __ATTR(capcache,
1037 0664,
1038 sysfs_service_op_show,
1039 NULL);
1040
1041static struct orangefs_attribute pc_ncache_attribute =
1042 __ATTR(ncache,
1043 0664,
1044 sysfs_service_op_show,
1045 NULL);
1046
1047static struct attribute *pc_orangefs_default_attrs[] = {
1048 &pc_acache_attribute.attr,
1049 &pc_capcache_attribute.attr,
1050 &pc_ncache_attribute.attr,
1051 NULL,
1052};
1053
1054static struct kobj_type pc_orangefs_ktype = {
1055 .sysfs_ops = &orangefs_sysfs_ops,
1056 .default_attrs = pc_orangefs_default_attrs,
1057};
1058
1059static struct orangefs_attribute stats_reads_attribute =
1060 __ATTR(reads,
1061 0664,
1062 sysfs_int_show,
1063 NULL);
1064
1065static struct orangefs_attribute stats_writes_attribute =
1066 __ATTR(writes,
1067 0664,
1068 sysfs_int_show,
1069 NULL);
1070
1071static struct attribute *stats_orangefs_default_attrs[] = {
1072 &stats_reads_attribute.attr,
1073 &stats_writes_attribute.attr,
1074 NULL,
1075};
1076
1077static struct kobj_type stats_orangefs_ktype = {
1078 .sysfs_ops = &orangefs_sysfs_ops,
1079 .default_attrs = stats_orangefs_default_attrs,
1080};
1081
1082static struct kobject *orangefs_obj;
1083static struct kobject *acache_orangefs_obj;
1084static struct kobject *capcache_orangefs_obj;
1085static struct kobject *ccache_orangefs_obj;
1086static struct kobject *ncache_orangefs_obj;
1087static struct kobject *pc_orangefs_obj;
1088static struct kobject *stats_orangefs_obj;
1089
1090int orangefs_sysfs_init(void)
1091{
1092 int rc = -EINVAL;
1093
1094 gossip_debug(GOSSIP_SYSFS_DEBUG, "orangefs_sysfs_init: start\n");
1095
1096
1097 orangefs_obj = kzalloc(sizeof(*orangefs_obj), GFP_KERNEL);
1098 if (!orangefs_obj)
1099 goto out;
1100
1101 rc = kobject_init_and_add(orangefs_obj,
1102 &orangefs_ktype,
1103 fs_kobj,
1104 ORANGEFS_KOBJ_ID);
1105
1106 if (rc)
1107 goto ofs_obj_bail;
1108
1109 kobject_uevent(orangefs_obj, KOBJ_ADD);
1110
1111
1112 acache_orangefs_obj = kzalloc(sizeof(*acache_orangefs_obj), GFP_KERNEL);
1113 if (!acache_orangefs_obj) {
1114 rc = -EINVAL;
1115 goto ofs_obj_bail;
1116 }
1117
1118 rc = kobject_init_and_add(acache_orangefs_obj,
1119 &acache_orangefs_ktype,
1120 orangefs_obj,
1121 ACACHE_KOBJ_ID);
1122
1123 if (rc)
1124 goto acache_obj_bail;
1125
1126 kobject_uevent(acache_orangefs_obj, KOBJ_ADD);
1127
1128
1129 capcache_orangefs_obj =
1130 kzalloc(sizeof(*capcache_orangefs_obj), GFP_KERNEL);
1131 if (!capcache_orangefs_obj) {
1132 rc = -EINVAL;
1133 goto acache_obj_bail;
1134 }
1135
1136 rc = kobject_init_and_add(capcache_orangefs_obj,
1137 &capcache_orangefs_ktype,
1138 orangefs_obj,
1139 CAPCACHE_KOBJ_ID);
1140 if (rc)
1141 goto capcache_obj_bail;
1142
1143 kobject_uevent(capcache_orangefs_obj, KOBJ_ADD);
1144
1145
1146 ccache_orangefs_obj =
1147 kzalloc(sizeof(*ccache_orangefs_obj), GFP_KERNEL);
1148 if (!ccache_orangefs_obj) {
1149 rc = -EINVAL;
1150 goto capcache_obj_bail;
1151 }
1152
1153 rc = kobject_init_and_add(ccache_orangefs_obj,
1154 &ccache_orangefs_ktype,
1155 orangefs_obj,
1156 CCACHE_KOBJ_ID);
1157 if (rc)
1158 goto ccache_obj_bail;
1159
1160 kobject_uevent(ccache_orangefs_obj, KOBJ_ADD);
1161
1162
1163 ncache_orangefs_obj = kzalloc(sizeof(*ncache_orangefs_obj), GFP_KERNEL);
1164 if (!ncache_orangefs_obj) {
1165 rc = -EINVAL;
1166 goto ccache_obj_bail;
1167 }
1168
1169 rc = kobject_init_and_add(ncache_orangefs_obj,
1170 &ncache_orangefs_ktype,
1171 orangefs_obj,
1172 NCACHE_KOBJ_ID);
1173
1174 if (rc)
1175 goto ncache_obj_bail;
1176
1177 kobject_uevent(ncache_orangefs_obj, KOBJ_ADD);
1178
1179
1180 pc_orangefs_obj = kzalloc(sizeof(*pc_orangefs_obj), GFP_KERNEL);
1181 if (!pc_orangefs_obj) {
1182 rc = -EINVAL;
1183 goto ncache_obj_bail;
1184 }
1185
1186 rc = kobject_init_and_add(pc_orangefs_obj,
1187 &pc_orangefs_ktype,
1188 orangefs_obj,
1189 "perf_counters");
1190
1191 if (rc)
1192 goto pc_obj_bail;
1193
1194 kobject_uevent(pc_orangefs_obj, KOBJ_ADD);
1195
1196
1197 stats_orangefs_obj = kzalloc(sizeof(*stats_orangefs_obj), GFP_KERNEL);
1198 if (!stats_orangefs_obj) {
1199 rc = -EINVAL;
1200 goto pc_obj_bail;
1201 }
1202
1203 rc = kobject_init_and_add(stats_orangefs_obj,
1204 &stats_orangefs_ktype,
1205 orangefs_obj,
1206 STATS_KOBJ_ID);
1207
1208 if (rc)
1209 goto stats_obj_bail;
1210
1211 kobject_uevent(stats_orangefs_obj, KOBJ_ADD);
1212 goto out;
1213
1214stats_obj_bail:
1215 kobject_put(stats_orangefs_obj);
1216pc_obj_bail:
1217 kobject_put(pc_orangefs_obj);
1218ncache_obj_bail:
1219 kobject_put(ncache_orangefs_obj);
1220ccache_obj_bail:
1221 kobject_put(ccache_orangefs_obj);
1222capcache_obj_bail:
1223 kobject_put(capcache_orangefs_obj);
1224acache_obj_bail:
1225 kobject_put(acache_orangefs_obj);
1226ofs_obj_bail:
1227 kobject_put(orangefs_obj);
1228out:
1229 return rc;
1230}
1231
1232void orangefs_sysfs_exit(void)
1233{
1234 gossip_debug(GOSSIP_SYSFS_DEBUG, "orangefs_sysfs_exit: start\n");
1235 kobject_put(acache_orangefs_obj);
1236 kobject_put(capcache_orangefs_obj);
1237 kobject_put(ccache_orangefs_obj);
1238 kobject_put(ncache_orangefs_obj);
1239 kobject_put(pc_orangefs_obj);
1240 kobject_put(stats_orangefs_obj);
1241 kobject_put(orangefs_obj);
1242}
1243
