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