?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net: Convert dccp_v4_ops
[linux/fpc-iii.git] / fs / orangefs / orangefs-sysfs.c
blob079a465796f3ef95e318b3929b83fab005f42df7
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Documentation/ABI/stable/orangefs-sysfs:
4 *
5 * What: /sys/fs/orangefs/perf_counter_reset
6 * Date: June 2015
7 * Contact: Mike Marshall <hubcap@omnibond.com>
8 * Description:
9 * echo a 0 or a 1 into perf_counter_reset to
10 * reset all the counters in
11 * /sys/fs/orangefs/perf_counters
12 * except ones with PINT_PERF_PRESERVE set.
13 *
14 *
15 * What: /sys/fs/orangefs/perf_counters/...
16 * Date: Jun 2015
17 * Contact: Mike Marshall <hubcap@omnibond.com>
18 * Description:
19 * Counters and settings for various caches.
20 * Read only.
21 *
22 *
23 * What: /sys/fs/orangefs/perf_time_interval_secs
24 * Date: Jun 2015
25 * Contact: Mike Marshall <hubcap@omnibond.com>
26 * Description:
27 * Length of perf counter intervals in
28 * seconds.
29 *
30 *
31 * What: /sys/fs/orangefs/perf_history_size
32 * Date: Jun 2015
33 * Contact: Mike Marshall <hubcap@omnibond.com>
34 * Description:
35 * The perf_counters cache statistics have N, or
36 * perf_history_size, samples. The default is
37 * one.
38 *
39 * Every perf_time_interval_secs the (first)
40 * samples are reset.
41 *
42 * If N is greater than one, the "current" set
43 * of samples is reset, and the samples from the
44 * other N-1 intervals remain available.
45 *
46 *
47 * What: /sys/fs/orangefs/op_timeout_secs
48 * Date: Jun 2015
49 * Contact: Mike Marshall <hubcap@omnibond.com>
50 * Description:
51 * Service operation timeout in seconds.
52 *
53 *
54 * What: /sys/fs/orangefs/slot_timeout_secs
55 * Date: Jun 2015
56 * Contact: Mike Marshall <hubcap@omnibond.com>
57 * Description:
58 * "Slot" timeout in seconds. A "slot"
59 * is an indexed buffer in the shared
60 * memory segment used for communication
61 * between the kernel module and userspace.
62 * Slots are requested and waited for,
63 * the wait times out after slot_timeout_secs.
64 *
65 * What: /sys/fs/orangefs/dcache_timeout_msecs
66 * Date: Jul 2016
67 * Contact: Martin Brandenburg <martin@omnibond.com>
68 * Description:
69 * Time lookup is valid in milliseconds.
70 *
71 * What: /sys/fs/orangefs/getattr_timeout_msecs
72 * Date: Jul 2016
73 * Contact: Martin Brandenburg <martin@omnibond.com>
74 * Description:
75 * Time getattr is valid in milliseconds.
76 *
77 * What: /sys/fs/orangefs/readahead_count
78 * Date: Aug 2016
79 * Contact: Martin Brandenburg <martin@omnibond.com>
80 * Description:
81 * Readahead cache buffer count.
82 *
83 * What: /sys/fs/orangefs/readahead_size
84 * Date: Aug 2016
85 * Contact: Martin Brandenburg <martin@omnibond.com>
86 * Description:
87 * Readahead cache buffer size.
88 *
89 * What: /sys/fs/orangefs/readahead_count_size
90 * Date: Aug 2016
91 * Contact: Martin Brandenburg <martin@omnibond.com>
92 * Description:
93 * Readahead cache buffer count and size.
94 *
95 * What: /sys/fs/orangefs/readahead_readcnt
96 * Date: Jan 2017
97 * Contact: Martin Brandenburg <martin@omnibond.com>
98 * Description:
99 * Number of buffers (in multiples of readahead_size)
100 * which can be read ahead for a single file at once.
101 *
102 * What: /sys/fs/orangefs/acache/...
103 * Date: Jun 2015
104 * Contact: Martin Brandenburg <martin@omnibond.com>
105 * Description:
106 * Attribute cache configurable settings.
107 *
108 *
109 * What: /sys/fs/orangefs/ncache/...
110 * Date: Jun 2015
111 * Contact: Mike Marshall <hubcap@omnibond.com>
112 * Description:
113 * Name cache configurable settings.
114 *
115 *
116 * What: /sys/fs/orangefs/capcache/...
117 * Date: Jun 2015
118 * Contact: Mike Marshall <hubcap@omnibond.com>
119 * Description:
120 * Capability cache configurable settings.
121 *
122 *
123 * What: /sys/fs/orangefs/ccache/...
124 * Date: Jun 2015
125 * Contact: Mike Marshall <hubcap@omnibond.com>
126 * Description:
127 * Credential cache configurable settings.
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 * Every item calls orangefs_attr_show and orangefs_attr_store through
152 * orangefs_sysfs_ops. They look at the orangefs_attributes further below to
153 * call one of sysfs_int_show, sysfs_int_store, sysfs_service_op_show, or
154 * sysfs_service_op_store.
155 */
156
157 struct 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
168 static 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
180 static 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
197 static const struct sysfs_ops orangefs_sysfs_ops = {
198 .show = orangefs_attr_show,
199 .store = orangefs_attr_store,
200 };
201
202 static 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
260 out:
261
262 return rc;
263 }
264
265 static 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
290 out:
291 if (rc)
292 rc = -EINVAL;
293 else
294 rc = count;
295
296 return rc;
297 }
298
299 /*
300 * obtain attribute values from userspace with a service operation.
301 */
302 static 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 /* Can't do a service_operation if the client is not running... */
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 /* Drop unsupported requests first. */
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 * The service_operation will return an errno return code on
473 * error, and zero on success.
474 */
475 rc = service_operation(new_op, ser_op_type, ORANGEFS_OP_INTERRUPTIBLE);
476
477 out:
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 * pass attribute values back to userspace with a service operation.
508 *
509 * We have to do a memory allocation, an sscanf and a service operation.
510 * And we have to evaluate what the user entered, to make sure the
511 * value is within the range supported by the attribute. So, there's
512 * a lot of return code checking and mapping going on here.
513 *
514 * We want to return 1 if we think everything went OK, and
515 * EINVAL if not.
516 */
517 static 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; /* sic */
531
532 /* Can't do a service_operation if the client is not running... */
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 * The value we want to send back to userspace is in buf, unless this
543 * there are two parameters, which is specially handled below.
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 /* Drop unsupported requests first. */
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;
790 value_set:
791
792 /*
793 * The service_operation will return a errno return code on
794 * error, and zero on success.
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
806 out:
807 op_release(new_op);
808
809 if (rc == -ENOMEM || rc == 0)
810 rc = -EINVAL;
811
812 return rc;
813 }
814
815 static struct orangefs_attribute op_timeout_secs_attribute =
816 __ATTR(op_timeout_secs, 0664, sysfs_int_show, sysfs_int_store);
817
818 static struct orangefs_attribute slot_timeout_secs_attribute =
819 __ATTR(slot_timeout_secs, 0664, sysfs_int_show, sysfs_int_store);
820
821 static struct orangefs_attribute dcache_timeout_msecs_attribute =
822 __ATTR(dcache_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);
823
824 static struct orangefs_attribute getattr_timeout_msecs_attribute =
825 __ATTR(getattr_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);
826
827 static struct orangefs_attribute readahead_count_attribute =
828 __ATTR(readahead_count, 0664, sysfs_service_op_show,
829 sysfs_service_op_store);
830
831 static struct orangefs_attribute readahead_size_attribute =
832 __ATTR(readahead_size, 0664, sysfs_service_op_show,
833 sysfs_service_op_store);
834
835 static struct orangefs_attribute readahead_count_size_attribute =
836 __ATTR(readahead_count_size, 0664, sysfs_service_op_show,
837 sysfs_service_op_store);
838
839 static struct orangefs_attribute readahead_readcnt_attribute =
840 __ATTR(readahead_readcnt, 0664, sysfs_service_op_show,
841 sysfs_service_op_store);
842
843 static 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
849 static 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
855 static 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
861 static 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
876 static struct kobj_type orangefs_ktype = {
877 .sysfs_ops = &orangefs_sysfs_ops,
878 .default_attrs = orangefs_default_attrs,
879 };
880
881 static struct orangefs_attribute acache_hard_limit_attribute =
882 __ATTR(hard_limit,
883 0664,
884 sysfs_service_op_show,
885 sysfs_service_op_store);
886
887 static struct orangefs_attribute acache_reclaim_percent_attribute =
888 __ATTR(reclaim_percentage,
889 0664,
890 sysfs_service_op_show,
891 sysfs_service_op_store);
892
893 static struct orangefs_attribute acache_soft_limit_attribute =
894 __ATTR(soft_limit,
895 0664,
896 sysfs_service_op_show,
897 sysfs_service_op_store);
898
899 static struct orangefs_attribute acache_timeout_msecs_attribute =
900 __ATTR(timeout_msecs,
901 0664,
902 sysfs_service_op_show,
903 sysfs_service_op_store);
904
905 static 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
913 static struct kobj_type acache_orangefs_ktype = {
914 .sysfs_ops = &orangefs_sysfs_ops,
915 .default_attrs = acache_orangefs_default_attrs,
916 };
917
918 static struct orangefs_attribute capcache_hard_limit_attribute =
919 __ATTR(hard_limit,
920 0664,
921 sysfs_service_op_show,
922 sysfs_service_op_store);
923
924 static struct orangefs_attribute capcache_reclaim_percent_attribute =
925 __ATTR(reclaim_percentage,
926 0664,
927 sysfs_service_op_show,
928 sysfs_service_op_store);
929
930 static struct orangefs_attribute capcache_soft_limit_attribute =
931 __ATTR(soft_limit,
932 0664,
933 sysfs_service_op_show,
934 sysfs_service_op_store);
935
936 static struct orangefs_attribute capcache_timeout_secs_attribute =
937 __ATTR(timeout_secs,
938 0664,
939 sysfs_service_op_show,
940 sysfs_service_op_store);
941
942 static 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
950 static struct kobj_type capcache_orangefs_ktype = {
951 .sysfs_ops = &orangefs_sysfs_ops,
952 .default_attrs = capcache_orangefs_default_attrs,
953 };
954
955 static struct orangefs_attribute ccache_hard_limit_attribute =
956 __ATTR(hard_limit,
957 0664,
958 sysfs_service_op_show,
959 sysfs_service_op_store);
960
961 static struct orangefs_attribute ccache_reclaim_percent_attribute =
962 __ATTR(reclaim_percentage,
963 0664,
964 sysfs_service_op_show,
965 sysfs_service_op_store);
966
967 static struct orangefs_attribute ccache_soft_limit_attribute =
968 __ATTR(soft_limit,
969 0664,
970 sysfs_service_op_show,
971 sysfs_service_op_store);
972
973 static struct orangefs_attribute ccache_timeout_secs_attribute =
974 __ATTR(timeout_secs,
975 0664,
976 sysfs_service_op_show,
977 sysfs_service_op_store);
978
979 static 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
987 static struct kobj_type ccache_orangefs_ktype = {
988 .sysfs_ops = &orangefs_sysfs_ops,
989 .default_attrs = ccache_orangefs_default_attrs,
990 };
991
992 static struct orangefs_attribute ncache_hard_limit_attribute =
993 __ATTR(hard_limit,
994 0664,
995 sysfs_service_op_show,
996 sysfs_service_op_store);
997
998 static struct orangefs_attribute ncache_reclaim_percent_attribute =
999 __ATTR(reclaim_percentage,
1000 0664,
1001 sysfs_service_op_show,
1002 sysfs_service_op_store);
1003
1004 static struct orangefs_attribute ncache_soft_limit_attribute =
1005 __ATTR(soft_limit,
1006 0664,
1007 sysfs_service_op_show,
1008 sysfs_service_op_store);
1009
1010 static struct orangefs_attribute ncache_timeout_msecs_attribute =
1011 __ATTR(timeout_msecs,
1012 0664,
1013 sysfs_service_op_show,
1014 sysfs_service_op_store);
1015
1016 static 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
1024 static struct kobj_type ncache_orangefs_ktype = {
1025 .sysfs_ops = &orangefs_sysfs_ops,
1026 .default_attrs = ncache_orangefs_default_attrs,
1027 };
1028
1029 static struct orangefs_attribute pc_acache_attribute =
1030 __ATTR(acache,
1031 0664,
1032 sysfs_service_op_show,
1033 NULL);
1034
1035 static struct orangefs_attribute pc_capcache_attribute =
1036 __ATTR(capcache,
1037 0664,
1038 sysfs_service_op_show,
1039 NULL);
1040
1041 static struct orangefs_attribute pc_ncache_attribute =
1042 __ATTR(ncache,
1043 0664,
1044 sysfs_service_op_show,
1045 NULL);
1046
1047 static 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
1054 static struct kobj_type pc_orangefs_ktype = {
1055 .sysfs_ops = &orangefs_sysfs_ops,
1056 .default_attrs = pc_orangefs_default_attrs,
1057 };
1058
1059 static struct orangefs_attribute stats_reads_attribute =
1060 __ATTR(reads,
1061 0664,
1062 sysfs_int_show,
1063 NULL);
1064
1065 static struct orangefs_attribute stats_writes_attribute =
1066 __ATTR(writes,
1067 0664,
1068 sysfs_int_show,
1069 NULL);
1070
1071 static struct attribute *stats_orangefs_default_attrs[] = {
1072 &stats_reads_attribute.attr,
1073 &stats_writes_attribute.attr,
1074 NULL,
1075 };
1076
1077 static struct kobj_type stats_orangefs_ktype = {
1078 .sysfs_ops = &orangefs_sysfs_ops,
1079 .default_attrs = stats_orangefs_default_attrs,
1080 };
1081
1082 static struct kobject *orangefs_obj;
1083 static struct kobject *acache_orangefs_obj;
1084 static struct kobject *capcache_orangefs_obj;
1085 static struct kobject *ccache_orangefs_obj;
1086 static struct kobject *ncache_orangefs_obj;
1087 static struct kobject *pc_orangefs_obj;
1088 static struct kobject *stats_orangefs_obj;
1089
1090 int orangefs_sysfs_init(void)
1091 {
1092 int rc = -EINVAL;
1093
1094 gossip_debug(GOSSIP_SYSFS_DEBUG, "orangefs_sysfs_init: start\n");
1095
1096 /* create /sys/fs/orangefs. */
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 /* create /sys/fs/orangefs/acache. */
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 /* create /sys/fs/orangefs/capcache. */
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 /* create /sys/fs/orangefs/ccache. */
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 /* create /sys/fs/orangefs/ncache. */
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 /* create /sys/fs/orangefs/perf_counters. */
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 /* create /sys/fs/orangefs/stats. */
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
1214 stats_obj_bail:
1215 kobject_put(stats_orangefs_obj);
1216 pc_obj_bail:
1217 kobject_put(pc_orangefs_obj);
1218 ncache_obj_bail:
1219 kobject_put(ncache_orangefs_obj);
1220 ccache_obj_bail:
1221 kobject_put(ccache_orangefs_obj);
1222 capcache_obj_bail:
1223 kobject_put(capcache_orangefs_obj);
1224 acache_obj_bail:
1225 kobject_put(acache_orangefs_obj);
1226 ofs_obj_bail:
1227 kobject_put(orangefs_obj);
1228 out:
1229 return rc;
1230 }
1231
1232 void 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 }
Linux with added FPC-III support