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