1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * stackglue.c
4 *
5 * Code which implements an OCFS2 specific interface to underlying
6 * cluster stacks.
7 *
8 * Copyright (C) 2007, 2009 Oracle. All rights reserved.
9 */
10
11 #include <linux/list.h>
12 #include <linux/spinlock.h>
13 #include <linux/string.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/kmod.h>
17 #include <linux/fs.h>
18 #include <linux/kobject.h>
19 #include <linux/sysfs.h>
20 #include <linux/sysctl.h>
21
22 #include "ocfs2_fs.h"
23
24 #include "stackglue.h"
25
26 #define OCFS2_STACK_PLUGIN_O2CB "o2cb"
27 #define OCFS2_STACK_PLUGIN_USER "user"
28 #define OCFS2_MAX_HB_CTL_PATH 256
29
30 static struct ocfs2_protocol_version locking_max_version;
31 static DEFINE_SPINLOCK(ocfs2_stack_lock);
32 static LIST_HEAD(ocfs2_stack_list);
33 static char cluster_stack_name[OCFS2_STACK_LABEL_LEN + 1];
34 static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
35
36 /*
37 * The stack currently in use. If not null, active_stack->sp_count > 0,
38 * the module is pinned, and the locking protocol cannot be changed.
39 */
40 static struct ocfs2_stack_plugin *active_stack;
41
ocfs2_stack_lookup(const char * name)42 static struct ocfs2_stack_plugin *ocfs2_stack_lookup(const char *name)
43 {
44 struct ocfs2_stack_plugin *p;
45
46 assert_spin_locked(&ocfs2_stack_lock);
47
48 list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
49 if (!strcmp(p->sp_name, name))
50 return p;
51 }
52
53 return NULL;
54 }
55
ocfs2_stack_driver_request(const char * stack_name,const char * plugin_name)56 static int ocfs2_stack_driver_request(const char *stack_name,
57 const char *plugin_name)
58 {
59 int rc;
60 struct ocfs2_stack_plugin *p;
61
62 spin_lock(&ocfs2_stack_lock);
63
64 /*
65 * If the stack passed by the filesystem isn't the selected one,
66 * we can't continue.
67 */
68 if (strcmp(stack_name, cluster_stack_name)) {
69 rc = -EBUSY;
70 goto out;
71 }
72
73 if (active_stack) {
74 /*
75 * If the active stack isn't the one we want, it cannot
76 * be selected right now.
77 */
78 if (!strcmp(active_stack->sp_name, plugin_name))
79 rc = 0;
80 else
81 rc = -EBUSY;
82 goto out;
83 }
84
85 p = ocfs2_stack_lookup(plugin_name);
86 if (!p || !try_module_get(p->sp_owner)) {
87 rc = -ENOENT;
88 goto out;
89 }
90
91 active_stack = p;
92 rc = 0;
93
94 out:
95 /* If we found it, pin it */
96 if (!rc)
97 active_stack->sp_count++;
98
99 spin_unlock(&ocfs2_stack_lock);
100 return rc;
101 }
102
103 /*
104 * This function looks up the appropriate stack and makes it active. If
105 * there is no stack, it tries to load it. It will fail if the stack still
106 * cannot be found. It will also fail if a different stack is in use.
107 */
ocfs2_stack_driver_get(const char * stack_name)108 static int ocfs2_stack_driver_get(const char *stack_name)
109 {
110 int rc;
111 char *plugin_name = OCFS2_STACK_PLUGIN_O2CB;
112
113 /*
114 * Classic stack does not pass in a stack name. This is
115 * compatible with older tools as well.
116 */
117 if (!stack_name || !*stack_name)
118 stack_name = OCFS2_STACK_PLUGIN_O2CB;
119
120 if (strlen(stack_name) != OCFS2_STACK_LABEL_LEN) {
121 printk(KERN_ERR
122 "ocfs2 passed an invalid cluster stack label: \"%s\"\n",
123 stack_name);
124 return -EINVAL;
125 }
126
127 /* Anything that isn't the classic stack is a user stack */
128 if (strcmp(stack_name, OCFS2_STACK_PLUGIN_O2CB))
129 plugin_name = OCFS2_STACK_PLUGIN_USER;
130
131 rc = ocfs2_stack_driver_request(stack_name, plugin_name);
132 if (rc == -ENOENT) {
133 request_module("ocfs2_stack_%s", plugin_name);
134 rc = ocfs2_stack_driver_request(stack_name, plugin_name);
135 }
136
137 if (rc == -ENOENT) {
138 printk(KERN_ERR
139 "ocfs2: Cluster stack driver \"%s\" cannot be found\n",
140 plugin_name);
141 } else if (rc == -EBUSY) {
142 printk(KERN_ERR
143 "ocfs2: A different cluster stack is in use\n");
144 }
145
146 return rc;
147 }
148
ocfs2_stack_driver_put(void)149 static void ocfs2_stack_driver_put(void)
150 {
151 spin_lock(&ocfs2_stack_lock);
152 BUG_ON(active_stack == NULL);
153 BUG_ON(active_stack->sp_count == 0);
154
155 active_stack->sp_count--;
156 if (!active_stack->sp_count) {
157 module_put(active_stack->sp_owner);
158 active_stack = NULL;
159 }
160 spin_unlock(&ocfs2_stack_lock);
161 }
162
ocfs2_stack_glue_register(struct ocfs2_stack_plugin * plugin)163 int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin)
164 {
165 int rc;
166
167 spin_lock(&ocfs2_stack_lock);
168 if (!ocfs2_stack_lookup(plugin->sp_name)) {
169 plugin->sp_count = 0;
170 plugin->sp_max_proto = locking_max_version;
171 list_add(&plugin->sp_list, &ocfs2_stack_list);
172 printk(KERN_INFO "ocfs2: Registered cluster interface %s\n",
173 plugin->sp_name);
174 rc = 0;
175 } else {
176 printk(KERN_ERR "ocfs2: Stack \"%s\" already registered\n",
177 plugin->sp_name);
178 rc = -EEXIST;
179 }
180 spin_unlock(&ocfs2_stack_lock);
181
182 return rc;
183 }
184 EXPORT_SYMBOL_GPL(ocfs2_stack_glue_register);
185
ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin * plugin)186 void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin)
187 {
188 struct ocfs2_stack_plugin *p;
189
190 spin_lock(&ocfs2_stack_lock);
191 p = ocfs2_stack_lookup(plugin->sp_name);
192 if (p) {
193 BUG_ON(p != plugin);
194 BUG_ON(plugin == active_stack);
195 BUG_ON(plugin->sp_count != 0);
196 list_del_init(&plugin->sp_list);
197 printk(KERN_INFO "ocfs2: Unregistered cluster interface %s\n",
198 plugin->sp_name);
199 } else {
200 printk(KERN_ERR "Stack \"%s\" is not registered\n",
201 plugin->sp_name);
202 }
203 spin_unlock(&ocfs2_stack_lock);
204 }
205 EXPORT_SYMBOL_GPL(ocfs2_stack_glue_unregister);
206
ocfs2_stack_glue_set_max_proto_version(struct ocfs2_protocol_version * max_proto)207 void ocfs2_stack_glue_set_max_proto_version(struct ocfs2_protocol_version *max_proto)
208 {
209 struct ocfs2_stack_plugin *p;
210
211 spin_lock(&ocfs2_stack_lock);
212 if (memcmp(max_proto, &locking_max_version,
213 sizeof(struct ocfs2_protocol_version))) {
214 BUG_ON(locking_max_version.pv_major != 0);
215
216 locking_max_version = *max_proto;
217 list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
218 p->sp_max_proto = locking_max_version;
219 }
220 }
221 spin_unlock(&ocfs2_stack_lock);
222 }
223 EXPORT_SYMBOL_GPL(ocfs2_stack_glue_set_max_proto_version);
224
225
226 /*
227 * The ocfs2_dlm_lock() and ocfs2_dlm_unlock() functions take no argument
228 * for the ast and bast functions. They will pass the lksb to the ast
229 * and bast. The caller can wrap the lksb with their own structure to
230 * get more information.
231 */
ocfs2_dlm_lock(struct ocfs2_cluster_connection * conn,int mode,struct ocfs2_dlm_lksb * lksb,u32 flags,void * name,unsigned int namelen)232 int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn,
233 int mode,
234 struct ocfs2_dlm_lksb *lksb,
235 u32 flags,
236 void *name,
237 unsigned int namelen)
238 {
239 if (!lksb->lksb_conn)
240 lksb->lksb_conn = conn;
241 else
242 BUG_ON(lksb->lksb_conn != conn);
243 return active_stack->sp_ops->dlm_lock(conn, mode, lksb, flags,
244 name, namelen);
245 }
246 EXPORT_SYMBOL_GPL(ocfs2_dlm_lock);
247
ocfs2_dlm_unlock(struct ocfs2_cluster_connection * conn,struct ocfs2_dlm_lksb * lksb,u32 flags)248 int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn,
249 struct ocfs2_dlm_lksb *lksb,
250 u32 flags)
251 {
252 BUG_ON(lksb->lksb_conn == NULL);
253
254 return active_stack->sp_ops->dlm_unlock(conn, lksb, flags);
255 }
256 EXPORT_SYMBOL_GPL(ocfs2_dlm_unlock);
257
ocfs2_dlm_lock_status(struct ocfs2_dlm_lksb * lksb)258 int ocfs2_dlm_lock_status(struct ocfs2_dlm_lksb *lksb)
259 {
260 return active_stack->sp_ops->lock_status(lksb);
261 }
262 EXPORT_SYMBOL_GPL(ocfs2_dlm_lock_status);
263
ocfs2_dlm_lvb_valid(struct ocfs2_dlm_lksb * lksb)264 int ocfs2_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb)
265 {
266 return active_stack->sp_ops->lvb_valid(lksb);
267 }
268 EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb_valid);
269
ocfs2_dlm_lvb(struct ocfs2_dlm_lksb * lksb)270 void *ocfs2_dlm_lvb(struct ocfs2_dlm_lksb *lksb)
271 {
272 return active_stack->sp_ops->lock_lvb(lksb);
273 }
274 EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb);
275
ocfs2_dlm_dump_lksb(struct ocfs2_dlm_lksb * lksb)276 void ocfs2_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb)
277 {
278 active_stack->sp_ops->dump_lksb(lksb);
279 }
280 EXPORT_SYMBOL_GPL(ocfs2_dlm_dump_lksb);
281
ocfs2_stack_supports_plocks(void)282 int ocfs2_stack_supports_plocks(void)
283 {
284 return active_stack && active_stack->sp_ops->plock;
285 }
286 EXPORT_SYMBOL_GPL(ocfs2_stack_supports_plocks);
287
288 /*
289 * ocfs2_plock() can only be safely called if
290 * ocfs2_stack_supports_plocks() returned true
291 */
ocfs2_plock(struct ocfs2_cluster_connection * conn,u64 ino,struct file * file,int cmd,struct file_lock * fl)292 int ocfs2_plock(struct ocfs2_cluster_connection *conn, u64 ino,
293 struct file *file, int cmd, struct file_lock *fl)
294 {
295 WARN_ON_ONCE(active_stack->sp_ops->plock == NULL);
296 if (active_stack->sp_ops->plock)
297 return active_stack->sp_ops->plock(conn, ino, file, cmd, fl);
298 return -EOPNOTSUPP;
299 }
300 EXPORT_SYMBOL_GPL(ocfs2_plock);
301
ocfs2_cluster_connect(const char * stack_name,const char * cluster_name,int cluster_name_len,const char * group,int grouplen,struct ocfs2_locking_protocol * lproto,void (* recovery_handler)(int node_num,void * recovery_data),void * recovery_data,struct ocfs2_cluster_connection ** conn)302 int ocfs2_cluster_connect(const char *stack_name,
303 const char *cluster_name,
304 int cluster_name_len,
305 const char *group,
306 int grouplen,
307 struct ocfs2_locking_protocol *lproto,
308 void (*recovery_handler)(int node_num,
309 void *recovery_data),
310 void *recovery_data,
311 struct ocfs2_cluster_connection **conn)
312 {
313 int rc = 0;
314 struct ocfs2_cluster_connection *new_conn;
315
316 BUG_ON(group == NULL);
317 BUG_ON(conn == NULL);
318 BUG_ON(recovery_handler == NULL);
319
320 if (grouplen > GROUP_NAME_MAX) {
321 rc = -EINVAL;
322 goto out;
323 }
324
325 if (memcmp(&lproto->lp_max_version, &locking_max_version,
326 sizeof(struct ocfs2_protocol_version))) {
327 rc = -EINVAL;
328 goto out;
329 }
330
331 new_conn = kzalloc(sizeof(struct ocfs2_cluster_connection),
332 GFP_KERNEL);
333 if (!new_conn) {
334 rc = -ENOMEM;
335 goto out;
336 }
337
338 strscpy(new_conn->cc_name, group, GROUP_NAME_MAX + 1);
339 new_conn->cc_namelen = grouplen;
340 if (cluster_name_len)
341 strscpy(new_conn->cc_cluster_name, cluster_name,
342 CLUSTER_NAME_MAX + 1);
343 new_conn->cc_cluster_name_len = cluster_name_len;
344 new_conn->cc_recovery_handler = recovery_handler;
345 new_conn->cc_recovery_data = recovery_data;
346
347 new_conn->cc_proto = lproto;
348 /* Start the new connection at our maximum compatibility level */
349 new_conn->cc_version = lproto->lp_max_version;
350
351 /* This will pin the stack driver if successful */
352 rc = ocfs2_stack_driver_get(stack_name);
353 if (rc)
354 goto out_free;
355
356 rc = active_stack->sp_ops->connect(new_conn);
357 if (rc) {
358 ocfs2_stack_driver_put();
359 goto out_free;
360 }
361
362 *conn = new_conn;
363
364 out_free:
365 if (rc)
366 kfree(new_conn);
367
368 out:
369 return rc;
370 }
371 EXPORT_SYMBOL_GPL(ocfs2_cluster_connect);
372
373 /* The caller will ensure all nodes have the same cluster stack */
ocfs2_cluster_connect_agnostic(const char * group,int grouplen,struct ocfs2_locking_protocol * lproto,void (* recovery_handler)(int node_num,void * recovery_data),void * recovery_data,struct ocfs2_cluster_connection ** conn)374 int ocfs2_cluster_connect_agnostic(const char *group,
375 int grouplen,
376 struct ocfs2_locking_protocol *lproto,
377 void (*recovery_handler)(int node_num,
378 void *recovery_data),
379 void *recovery_data,
380 struct ocfs2_cluster_connection **conn)
381 {
382 char *stack_name = NULL;
383
384 if (cluster_stack_name[0])
385 stack_name = cluster_stack_name;
386 return ocfs2_cluster_connect(stack_name, NULL, 0, group, grouplen,
387 lproto, recovery_handler, recovery_data,
388 conn);
389 }
390 EXPORT_SYMBOL_GPL(ocfs2_cluster_connect_agnostic);
391
392 /* If hangup_pending is 0, the stack driver will be dropped */
ocfs2_cluster_disconnect(struct ocfs2_cluster_connection * conn,int hangup_pending)393 int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn,
394 int hangup_pending)
395 {
396 int ret;
397
398 BUG_ON(conn == NULL);
399
400 ret = active_stack->sp_ops->disconnect(conn);
401
402 /* XXX Should we free it anyway? */
403 if (!ret) {
404 kfree(conn);
405 if (!hangup_pending)
406 ocfs2_stack_driver_put();
407 }
408
409 return ret;
410 }
411 EXPORT_SYMBOL_GPL(ocfs2_cluster_disconnect);
412
413 /*
414 * Leave the group for this filesystem. This is executed by a userspace
415 * program (stored in ocfs2_hb_ctl_path).
416 */
ocfs2_leave_group(const char * group)417 static void ocfs2_leave_group(const char *group)
418 {
419 int ret;
420 char *argv[5], *envp[3];
421
422 argv[0] = ocfs2_hb_ctl_path;
423 argv[1] = "-K";
424 argv[2] = "-u";
425 argv[3] = (char *)group;
426 argv[4] = NULL;
427
428 /* minimal command environment taken from cpu_run_sbin_hotplug */
429 envp[0] = "HOME=/";
430 envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
431 envp[2] = NULL;
432
433 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
434 if (ret < 0) {
435 printk(KERN_ERR
436 "ocfs2: Error %d running user helper "
437 "\"%s %s %s %s\"\n",
438 ret, argv[0], argv[1], argv[2], argv[3]);
439 }
440 }
441
442 /*
443 * Hangup is a required post-umount. ocfs2-tools software expects the
444 * filesystem to call "ocfs2_hb_ctl" during unmount. This happens
445 * regardless of whether the DLM got started, so we can't do it
446 * in ocfs2_cluster_disconnect(). The ocfs2_leave_group() function does
447 * the actual work.
448 */
ocfs2_cluster_hangup(const char * group,int grouplen)449 void ocfs2_cluster_hangup(const char *group, int grouplen)
450 {
451 BUG_ON(group == NULL);
452 BUG_ON(group[grouplen] != '\0');
453
454 ocfs2_leave_group(group);
455
456 /* cluster_disconnect() was called with hangup_pending==1 */
457 ocfs2_stack_driver_put();
458 }
459 EXPORT_SYMBOL_GPL(ocfs2_cluster_hangup);
460
ocfs2_cluster_this_node(struct ocfs2_cluster_connection * conn,unsigned int * node)461 int ocfs2_cluster_this_node(struct ocfs2_cluster_connection *conn,
462 unsigned int *node)
463 {
464 return active_stack->sp_ops->this_node(conn, node);
465 }
466 EXPORT_SYMBOL_GPL(ocfs2_cluster_this_node);
467
468
469 /*
470 * Sysfs bits
471 */
472
ocfs2_max_locking_protocol_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)473 static ssize_t ocfs2_max_locking_protocol_show(struct kobject *kobj,
474 struct kobj_attribute *attr,
475 char *buf)
476 {
477 ssize_t ret = 0;
478
479 spin_lock(&ocfs2_stack_lock);
480 if (locking_max_version.pv_major)
481 ret = snprintf(buf, PAGE_SIZE, "%u.%u\n",
482 locking_max_version.pv_major,
483 locking_max_version.pv_minor);
484 spin_unlock(&ocfs2_stack_lock);
485
486 return ret;
487 }
488
489 static struct kobj_attribute ocfs2_attr_max_locking_protocol =
490 __ATTR(max_locking_protocol, S_IRUGO,
491 ocfs2_max_locking_protocol_show, NULL);
492
ocfs2_loaded_cluster_plugins_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)493 static ssize_t ocfs2_loaded_cluster_plugins_show(struct kobject *kobj,
494 struct kobj_attribute *attr,
495 char *buf)
496 {
497 ssize_t ret = 0, total = 0, remain = PAGE_SIZE;
498 struct ocfs2_stack_plugin *p;
499
500 spin_lock(&ocfs2_stack_lock);
501 list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
502 ret = snprintf(buf, remain, "%s\n",
503 p->sp_name);
504 if (ret >= remain) {
505 /* snprintf() didn't fit */
506 total = -E2BIG;
507 break;
508 }
509 total += ret;
510 remain -= ret;
511 }
512 spin_unlock(&ocfs2_stack_lock);
513
514 return total;
515 }
516
517 static struct kobj_attribute ocfs2_attr_loaded_cluster_plugins =
518 __ATTR(loaded_cluster_plugins, S_IRUGO,
519 ocfs2_loaded_cluster_plugins_show, NULL);
520
ocfs2_active_cluster_plugin_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)521 static ssize_t ocfs2_active_cluster_plugin_show(struct kobject *kobj,
522 struct kobj_attribute *attr,
523 char *buf)
524 {
525 ssize_t ret = 0;
526
527 spin_lock(&ocfs2_stack_lock);
528 if (active_stack) {
529 ret = snprintf(buf, PAGE_SIZE, "%s\n",
530 active_stack->sp_name);
531 if (ret >= PAGE_SIZE)
532 ret = -E2BIG;
533 }
534 spin_unlock(&ocfs2_stack_lock);
535
536 return ret;
537 }
538
539 static struct kobj_attribute ocfs2_attr_active_cluster_plugin =
540 __ATTR(active_cluster_plugin, S_IRUGO,
541 ocfs2_active_cluster_plugin_show, NULL);
542
ocfs2_cluster_stack_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)543 static ssize_t ocfs2_cluster_stack_show(struct kobject *kobj,
544 struct kobj_attribute *attr,
545 char *buf)
546 {
547 ssize_t ret;
548 spin_lock(&ocfs2_stack_lock);
549 ret = snprintf(buf, PAGE_SIZE, "%s\n", cluster_stack_name);
550 spin_unlock(&ocfs2_stack_lock);
551
552 return ret;
553 }
554
ocfs2_cluster_stack_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)555 static ssize_t ocfs2_cluster_stack_store(struct kobject *kobj,
556 struct kobj_attribute *attr,
557 const char *buf, size_t count)
558 {
559 size_t len = count;
560 ssize_t ret;
561
562 if (len == 0)
563 return len;
564
565 if (buf[len - 1] == '\n')
566 len--;
567
568 if ((len != OCFS2_STACK_LABEL_LEN) ||
569 (strnlen(buf, len) != len))
570 return -EINVAL;
571
572 spin_lock(&ocfs2_stack_lock);
573 if (active_stack) {
574 if (!strncmp(buf, cluster_stack_name, len))
575 ret = count;
576 else
577 ret = -EBUSY;
578 } else {
579 memcpy(cluster_stack_name, buf, len);
580 ret = count;
581 }
582 spin_unlock(&ocfs2_stack_lock);
583
584 return ret;
585 }
586
587
588 static struct kobj_attribute ocfs2_attr_cluster_stack =
589 __ATTR(cluster_stack, S_IRUGO | S_IWUSR,
590 ocfs2_cluster_stack_show,
591 ocfs2_cluster_stack_store);
592
593
594
ocfs2_dlm_recover_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)595 static ssize_t ocfs2_dlm_recover_show(struct kobject *kobj,
596 struct kobj_attribute *attr,
597 char *buf)
598 {
599 return snprintf(buf, PAGE_SIZE, "1\n");
600 }
601
602 static struct kobj_attribute ocfs2_attr_dlm_recover_support =
603 __ATTR(dlm_recover_callback_support, S_IRUGO,
604 ocfs2_dlm_recover_show, NULL);
605
606 static struct attribute *ocfs2_attrs[] = {
607 &ocfs2_attr_max_locking_protocol.attr,
608 &ocfs2_attr_loaded_cluster_plugins.attr,
609 &ocfs2_attr_active_cluster_plugin.attr,
610 &ocfs2_attr_cluster_stack.attr,
611 &ocfs2_attr_dlm_recover_support.attr,
612 NULL,
613 };
614
615 static const struct attribute_group ocfs2_attr_group = {
616 .attrs = ocfs2_attrs,
617 };
618
619 struct kset *ocfs2_kset;
620 EXPORT_SYMBOL_GPL(ocfs2_kset);
621
ocfs2_sysfs_exit(void)622 static void ocfs2_sysfs_exit(void)
623 {
624 kset_unregister(ocfs2_kset);
625 }
626
ocfs2_sysfs_init(void)627 static int ocfs2_sysfs_init(void)
628 {
629 int ret;
630
631 ocfs2_kset = kset_create_and_add("ocfs2", NULL, fs_kobj);
632 if (!ocfs2_kset)
633 return -ENOMEM;
634
635 ret = sysfs_create_group(&ocfs2_kset->kobj, &ocfs2_attr_group);
636 if (ret)
637 goto error;
638
639 return 0;
640
641 error:
642 kset_unregister(ocfs2_kset);
643 return ret;
644 }
645
646 /*
647 * Sysctl bits
648 *
649 * The sysctl lives at /proc/sys/fs/ocfs2/nm/hb_ctl_path. The 'nm' doesn't
650 * make as much sense in a multiple cluster stack world, but it's safer
651 * and easier to preserve the name.
652 */
653
654 static const struct ctl_table ocfs2_nm_table[] = {
655 {
656 .procname = "hb_ctl_path",
657 .data = ocfs2_hb_ctl_path,
658 .maxlen = OCFS2_MAX_HB_CTL_PATH,
659 .mode = 0644,
660 .proc_handler = proc_dostring,
661 },
662 };
663
664 static struct ctl_table_header *ocfs2_table_header;
665
666 /*
667 * Initialization
668 */
669
ocfs2_stack_glue_init(void)670 static int __init ocfs2_stack_glue_init(void)
671 {
672 int ret;
673
674 strscpy(cluster_stack_name, OCFS2_STACK_PLUGIN_O2CB);
675
676 ocfs2_table_header = register_sysctl("fs/ocfs2/nm", ocfs2_nm_table);
677 if (!ocfs2_table_header) {
678 printk(KERN_ERR
679 "ocfs2 stack glue: unable to register sysctl\n");
680 return -ENOMEM; /* or something. */
681 }
682
683 ret = ocfs2_sysfs_init();
684 if (ret)
685 unregister_sysctl_table(ocfs2_table_header);
686
687 return ret;
688 }
689
ocfs2_stack_glue_exit(void)690 static void __exit ocfs2_stack_glue_exit(void)
691 {
692 memset(&locking_max_version, 0,
693 sizeof(struct ocfs2_protocol_version));
694 ocfs2_sysfs_exit();
695 unregister_sysctl_table(ocfs2_table_header);
696 }
697
698 MODULE_AUTHOR("Oracle");
699 MODULE_DESCRIPTION("ocfs2 cluster stack glue layer");
700 MODULE_LICENSE("GPL");
701 module_init(ocfs2_stack_glue_init);
702 module_exit(ocfs2_stack_glue_exit);
703