blob: 10e149ae5e3aad289f3070714ef5b8530078acf0 [file] [log] [blame]
Joel Becker24ef1812008-01-29 17:37:32 -08001/* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * stackglue.c
5 *
6 * Code which implements an OCFS2 specific interface to underlying
7 * cluster stacks.
8 *
9 * Copyright (C) 2007 Oracle. All rights reserved.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public
13 * License as published by the Free Software Foundation, version 2.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 */
20
Joel Becker286eaa92008-02-01 15:03:57 -080021#include <linux/list.h>
22#include <linux/spinlock.h>
23#include <linux/module.h>
Joel Becker4670c462008-02-01 14:39:35 -080024#include <linux/slab.h>
Joel Becker6953b4c2008-01-29 16:59:56 -080025#include <linux/kmod.h>
Joel Becker74ae4e12008-01-31 23:56:17 -080026#include <linux/fs.h>
27#include <linux/kobject.h>
28#include <linux/sysfs.h>
Joel Becker3878f112008-05-30 15:30:49 -070029#include <linux/sysctl.h>
Joel Becker4670c462008-02-01 14:39:35 -080030
Joel Becker9c6c8772008-02-01 15:17:30 -080031#include "ocfs2_fs.h"
32
Joel Becker24ef1812008-01-29 17:37:32 -080033#include "stackglue.h"
34
Joel Becker9c6c8772008-02-01 15:17:30 -080035#define OCFS2_STACK_PLUGIN_O2CB "o2cb"
36#define OCFS2_STACK_PLUGIN_USER "user"
Joel Becker9f9a99f2008-05-30 15:43:58 -070037#define OCFS2_MAX_HB_CTL_PATH 256
Joel Becker9c6c8772008-02-01 15:17:30 -080038
Joel Becker286eaa92008-02-01 15:03:57 -080039static struct ocfs2_locking_protocol *lproto;
40static DEFINE_SPINLOCK(ocfs2_stack_lock);
41static LIST_HEAD(ocfs2_stack_list);
Joel Becker9c6c8772008-02-01 15:17:30 -080042static char cluster_stack_name[OCFS2_STACK_LABEL_LEN + 1];
Joel Becker9f9a99f2008-05-30 15:43:58 -070043static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
Joel Becker286eaa92008-02-01 15:03:57 -080044
45/*
46 * The stack currently in use. If not null, active_stack->sp_count > 0,
47 * the module is pinned, and the locking protocol cannot be changed.
48 */
49static struct ocfs2_stack_plugin *active_stack;
50
51static struct ocfs2_stack_plugin *ocfs2_stack_lookup(const char *name)
52{
53 struct ocfs2_stack_plugin *p;
54
55 assert_spin_locked(&ocfs2_stack_lock);
56
57 list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
58 if (!strcmp(p->sp_name, name))
59 return p;
60 }
61
62 return NULL;
63}
64
Joel Becker9c6c8772008-02-01 15:17:30 -080065static int ocfs2_stack_driver_request(const char *stack_name,
66 const char *plugin_name)
Joel Becker286eaa92008-02-01 15:03:57 -080067{
68 int rc;
69 struct ocfs2_stack_plugin *p;
70
71 spin_lock(&ocfs2_stack_lock);
72
Joel Becker9c6c8772008-02-01 15:17:30 -080073 /*
74 * If the stack passed by the filesystem isn't the selected one,
75 * we can't continue.
76 */
77 if (strcmp(stack_name, cluster_stack_name)) {
78 rc = -EBUSY;
79 goto out;
80 }
81
Joel Becker286eaa92008-02-01 15:03:57 -080082 if (active_stack) {
83 /*
84 * If the active stack isn't the one we want, it cannot
85 * be selected right now.
86 */
Joel Becker9c6c8772008-02-01 15:17:30 -080087 if (!strcmp(active_stack->sp_name, plugin_name))
Joel Becker286eaa92008-02-01 15:03:57 -080088 rc = 0;
89 else
90 rc = -EBUSY;
91 goto out;
92 }
93
Joel Becker9c6c8772008-02-01 15:17:30 -080094 p = ocfs2_stack_lookup(plugin_name);
Joel Becker286eaa92008-02-01 15:03:57 -080095 if (!p || !try_module_get(p->sp_owner)) {
96 rc = -ENOENT;
97 goto out;
98 }
99
100 /* Ok, the stack is pinned */
101 p->sp_count++;
102 active_stack = p;
103
104 rc = 0;
105
106out:
107 spin_unlock(&ocfs2_stack_lock);
108 return rc;
109}
110
111/*
112 * This function looks up the appropriate stack and makes it active. If
113 * there is no stack, it tries to load it. It will fail if the stack still
114 * cannot be found. It will also fail if a different stack is in use.
115 */
Joel Becker9c6c8772008-02-01 15:17:30 -0800116static int ocfs2_stack_driver_get(const char *stack_name)
Joel Becker286eaa92008-02-01 15:03:57 -0800117{
118 int rc;
Joel Becker9c6c8772008-02-01 15:17:30 -0800119 char *plugin_name = OCFS2_STACK_PLUGIN_O2CB;
Joel Becker286eaa92008-02-01 15:03:57 -0800120
Joel Becker9c6c8772008-02-01 15:17:30 -0800121 /*
122 * Classic stack does not pass in a stack name. This is
123 * compatible with older tools as well.
124 */
125 if (!stack_name || !*stack_name)
126 stack_name = OCFS2_STACK_PLUGIN_O2CB;
127
128 if (strlen(stack_name) != OCFS2_STACK_LABEL_LEN) {
129 printk(KERN_ERR
130 "ocfs2 passed an invalid cluster stack label: \"%s\"\n",
131 stack_name);
132 return -EINVAL;
133 }
134
135 /* Anything that isn't the classic stack is a user stack */
136 if (strcmp(stack_name, OCFS2_STACK_PLUGIN_O2CB))
137 plugin_name = OCFS2_STACK_PLUGIN_USER;
138
139 rc = ocfs2_stack_driver_request(stack_name, plugin_name);
Joel Becker286eaa92008-02-01 15:03:57 -0800140 if (rc == -ENOENT) {
Joel Becker9c6c8772008-02-01 15:17:30 -0800141 request_module("ocfs2_stack_%s", plugin_name);
142 rc = ocfs2_stack_driver_request(stack_name, plugin_name);
Joel Becker286eaa92008-02-01 15:03:57 -0800143 }
144
145 if (rc == -ENOENT) {
146 printk(KERN_ERR
147 "ocfs2: Cluster stack driver \"%s\" cannot be found\n",
Joel Becker9c6c8772008-02-01 15:17:30 -0800148 plugin_name);
Joel Becker286eaa92008-02-01 15:03:57 -0800149 } else if (rc == -EBUSY) {
150 printk(KERN_ERR
Joel Becker9c6c8772008-02-01 15:17:30 -0800151 "ocfs2: A different cluster stack is in use\n");
Joel Becker286eaa92008-02-01 15:03:57 -0800152 }
153
154 return rc;
155}
156
157static void ocfs2_stack_driver_put(void)
158{
159 spin_lock(&ocfs2_stack_lock);
160 BUG_ON(active_stack == NULL);
161 BUG_ON(active_stack->sp_count == 0);
162
163 active_stack->sp_count--;
164 if (!active_stack->sp_count) {
165 module_put(active_stack->sp_owner);
166 active_stack = NULL;
167 }
168 spin_unlock(&ocfs2_stack_lock);
169}
170
171int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin)
172{
173 int rc;
174
175 spin_lock(&ocfs2_stack_lock);
176 if (!ocfs2_stack_lookup(plugin->sp_name)) {
177 plugin->sp_count = 0;
178 plugin->sp_proto = lproto;
179 list_add(&plugin->sp_list, &ocfs2_stack_list);
180 printk(KERN_INFO "ocfs2: Registered cluster interface %s\n",
181 plugin->sp_name);
182 rc = 0;
183 } else {
184 printk(KERN_ERR "ocfs2: Stack \"%s\" already registered\n",
185 plugin->sp_name);
186 rc = -EEXIST;
187 }
188 spin_unlock(&ocfs2_stack_lock);
189
190 return rc;
191}
192EXPORT_SYMBOL_GPL(ocfs2_stack_glue_register);
193
194void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin)
195{
196 struct ocfs2_stack_plugin *p;
197
198 spin_lock(&ocfs2_stack_lock);
199 p = ocfs2_stack_lookup(plugin->sp_name);
200 if (p) {
201 BUG_ON(p != plugin);
202 BUG_ON(plugin == active_stack);
203 BUG_ON(plugin->sp_count != 0);
204 list_del_init(&plugin->sp_list);
205 printk(KERN_INFO "ocfs2: Unregistered cluster interface %s\n",
206 plugin->sp_name);
207 } else {
208 printk(KERN_ERR "Stack \"%s\" is not registered\n",
209 plugin->sp_name);
210 }
211 spin_unlock(&ocfs2_stack_lock);
212}
213EXPORT_SYMBOL_GPL(ocfs2_stack_glue_unregister);
214
215void ocfs2_stack_glue_set_locking_protocol(struct ocfs2_locking_protocol *proto)
216{
217 struct ocfs2_stack_plugin *p;
218
219 BUG_ON(proto == NULL);
220
221 spin_lock(&ocfs2_stack_lock);
222 BUG_ON(active_stack != NULL);
223
224 lproto = proto;
225 list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
226 p->sp_proto = lproto;
227 }
228
229 spin_unlock(&ocfs2_stack_lock);
230}
231EXPORT_SYMBOL_GPL(ocfs2_stack_glue_set_locking_protocol);
Joel Becker24ef1812008-01-29 17:37:32 -0800232
Joel Becker24ef1812008-01-29 17:37:32 -0800233
David Teiglandcf4d8d72008-02-20 14:29:27 -0800234/*
235 * The ocfs2_dlm_lock() and ocfs2_dlm_unlock() functions take
236 * "struct ocfs2_lock_res *astarg" instead of "void *astarg" because the
237 * underlying stack plugins need to pilfer the lksb off of the lock_res.
238 * If some other structure needs to be passed as an astarg, the plugins
239 * will need to be given a different avenue to the lksb.
240 */
Joel Becker553aa7e2008-02-01 14:51:03 -0800241int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn,
242 int mode,
243 union ocfs2_dlm_lksb *lksb,
244 u32 flags,
245 void *name,
246 unsigned int namelen,
David Teiglandcf4d8d72008-02-20 14:29:27 -0800247 struct ocfs2_lock_res *astarg)
Joel Becker553aa7e2008-02-01 14:51:03 -0800248{
Joel Becker286eaa92008-02-01 15:03:57 -0800249 BUG_ON(lproto == NULL);
Joel Becker553aa7e2008-02-01 14:51:03 -0800250
Joel Becker286eaa92008-02-01 15:03:57 -0800251 return active_stack->sp_ops->dlm_lock(conn, mode, lksb, flags,
252 name, namelen, astarg);
Joel Becker24ef1812008-01-29 17:37:32 -0800253}
Joel Becker286eaa92008-02-01 15:03:57 -0800254EXPORT_SYMBOL_GPL(ocfs2_dlm_lock);
Joel Becker24ef1812008-01-29 17:37:32 -0800255
Joel Becker553aa7e2008-02-01 14:51:03 -0800256int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn,
257 union ocfs2_dlm_lksb *lksb,
258 u32 flags,
David Teiglandcf4d8d72008-02-20 14:29:27 -0800259 struct ocfs2_lock_res *astarg)
Joel Becker553aa7e2008-02-01 14:51:03 -0800260{
Joel Becker286eaa92008-02-01 15:03:57 -0800261 BUG_ON(lproto == NULL);
Joel Becker553aa7e2008-02-01 14:51:03 -0800262
Joel Becker286eaa92008-02-01 15:03:57 -0800263 return active_stack->sp_ops->dlm_unlock(conn, lksb, flags, astarg);
Joel Becker8f2c9c12008-02-01 12:16:57 -0800264}
Joel Becker286eaa92008-02-01 15:03:57 -0800265EXPORT_SYMBOL_GPL(ocfs2_dlm_unlock);
Joel Becker8f2c9c12008-02-01 12:16:57 -0800266
Joel Becker553aa7e2008-02-01 14:51:03 -0800267int ocfs2_dlm_lock_status(union ocfs2_dlm_lksb *lksb)
268{
Joel Becker286eaa92008-02-01 15:03:57 -0800269 return active_stack->sp_ops->lock_status(lksb);
Joel Becker553aa7e2008-02-01 14:51:03 -0800270}
Joel Becker286eaa92008-02-01 15:03:57 -0800271EXPORT_SYMBOL_GPL(ocfs2_dlm_lock_status);
Joel Becker553aa7e2008-02-01 14:51:03 -0800272
Joel Becker8f2c9c12008-02-01 12:16:57 -0800273/*
274 * Why don't we cast to ocfs2_meta_lvb? The "clean" answer is that we
275 * don't cast at the glue level. The real answer is that the header
276 * ordering is nigh impossible.
277 */
Joel Becker553aa7e2008-02-01 14:51:03 -0800278void *ocfs2_dlm_lvb(union ocfs2_dlm_lksb *lksb)
279{
Joel Becker286eaa92008-02-01 15:03:57 -0800280 return active_stack->sp_ops->lock_lvb(lksb);
Joel Beckercf0acdc2008-01-29 16:59:55 -0800281}
Joel Becker286eaa92008-02-01 15:03:57 -0800282EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb);
Joel Beckercf0acdc2008-01-29 16:59:55 -0800283
Joel Becker553aa7e2008-02-01 14:51:03 -0800284void ocfs2_dlm_dump_lksb(union ocfs2_dlm_lksb *lksb)
285{
Joel Becker286eaa92008-02-01 15:03:57 -0800286 active_stack->sp_ops->dump_lksb(lksb);
Joel Becker553aa7e2008-02-01 14:51:03 -0800287}
Joel Becker286eaa92008-02-01 15:03:57 -0800288EXPORT_SYMBOL_GPL(ocfs2_dlm_dump_lksb);
Joel Becker553aa7e2008-02-01 14:51:03 -0800289
Joel Becker9c6c8772008-02-01 15:17:30 -0800290int ocfs2_cluster_connect(const char *stack_name,
291 const char *group,
Joel Becker4670c462008-02-01 14:39:35 -0800292 int grouplen,
293 void (*recovery_handler)(int node_num,
294 void *recovery_data),
295 void *recovery_data,
296 struct ocfs2_cluster_connection **conn)
297{
298 int rc = 0;
299 struct ocfs2_cluster_connection *new_conn;
Joel Becker4670c462008-02-01 14:39:35 -0800300
301 BUG_ON(group == NULL);
302 BUG_ON(conn == NULL);
303 BUG_ON(recovery_handler == NULL);
304
305 if (grouplen > GROUP_NAME_MAX) {
306 rc = -EINVAL;
307 goto out;
308 }
309
310 new_conn = kzalloc(sizeof(struct ocfs2_cluster_connection),
311 GFP_KERNEL);
312 if (!new_conn) {
313 rc = -ENOMEM;
314 goto out;
315 }
316
317 memcpy(new_conn->cc_name, group, grouplen);
318 new_conn->cc_namelen = grouplen;
319 new_conn->cc_recovery_handler = recovery_handler;
320 new_conn->cc_recovery_data = recovery_data;
321
322 /* Start the new connection at our maximum compatibility level */
Joel Becker286eaa92008-02-01 15:03:57 -0800323 new_conn->cc_version = lproto->lp_max_version;
Joel Becker4670c462008-02-01 14:39:35 -0800324
Joel Becker286eaa92008-02-01 15:03:57 -0800325 /* This will pin the stack driver if successful */
Joel Becker9c6c8772008-02-01 15:17:30 -0800326 rc = ocfs2_stack_driver_get(stack_name);
Joel Becker286eaa92008-02-01 15:03:57 -0800327 if (rc)
328 goto out_free;
329
330 rc = active_stack->sp_ops->connect(new_conn);
Joel Becker553aa7e2008-02-01 14:51:03 -0800331 if (rc) {
Joel Becker286eaa92008-02-01 15:03:57 -0800332 ocfs2_stack_driver_put();
Joel Becker4670c462008-02-01 14:39:35 -0800333 goto out_free;
334 }
335
Joel Becker4670c462008-02-01 14:39:35 -0800336 *conn = new_conn;
337
338out_free:
Joel Becker553aa7e2008-02-01 14:51:03 -0800339 if (rc)
Joel Becker4670c462008-02-01 14:39:35 -0800340 kfree(new_conn);
Joel Becker4670c462008-02-01 14:39:35 -0800341
342out:
343 return rc;
344}
Joel Becker286eaa92008-02-01 15:03:57 -0800345EXPORT_SYMBOL_GPL(ocfs2_cluster_connect);
Joel Becker4670c462008-02-01 14:39:35 -0800346
Joel Becker286eaa92008-02-01 15:03:57 -0800347/* If hangup_pending is 0, the stack driver will be dropped */
348int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn,
349 int hangup_pending)
Joel Becker553aa7e2008-02-01 14:51:03 -0800350{
351 int ret;
352
353 BUG_ON(conn == NULL);
354
Joel Becker2c394502008-05-30 15:58:26 -0700355 ret = active_stack->sp_ops->disconnect(conn);
Joel Becker553aa7e2008-02-01 14:51:03 -0800356
357 /* XXX Should we free it anyway? */
Joel Becker286eaa92008-02-01 15:03:57 -0800358 if (!ret) {
Joel Becker553aa7e2008-02-01 14:51:03 -0800359 kfree(conn);
Joel Becker286eaa92008-02-01 15:03:57 -0800360 if (!hangup_pending)
361 ocfs2_stack_driver_put();
362 }
Joel Becker553aa7e2008-02-01 14:51:03 -0800363
364 return ret;
365}
Joel Becker286eaa92008-02-01 15:03:57 -0800366EXPORT_SYMBOL_GPL(ocfs2_cluster_disconnect);
Joel Becker553aa7e2008-02-01 14:51:03 -0800367
Joel Becker9f9a99f2008-05-30 15:43:58 -0700368/*
369 * Leave the group for this filesystem. This is executed by a userspace
370 * program (stored in ocfs2_hb_ctl_path).
371 */
372static void ocfs2_leave_group(const char *group)
373{
374 int ret;
375 char *argv[5], *envp[3];
376
377 argv[0] = ocfs2_hb_ctl_path;
378 argv[1] = "-K";
379 argv[2] = "-u";
380 argv[3] = (char *)group;
381 argv[4] = NULL;
382
383 /* minimal command environment taken from cpu_run_sbin_hotplug */
384 envp[0] = "HOME=/";
385 envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
386 envp[2] = NULL;
387
388 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
389 if (ret < 0) {
390 printk(KERN_ERR
391 "ocfs2: Error %d running user helper "
392 "\"%s %s %s %s\"\n",
393 ret, argv[0], argv[1], argv[2], argv[3]);
394 }
395}
396
397/*
398 * Hangup is a required post-umount. ocfs2-tools software expects the
399 * filesystem to call "ocfs2_hb_ctl" during unmount. This happens
400 * regardless of whether the DLM got started, so we can't do it
401 * in ocfs2_cluster_disconnect(). The ocfs2_leave_group() function does
402 * the actual work.
403 */
Joel Becker6953b4c2008-01-29 16:59:56 -0800404void ocfs2_cluster_hangup(const char *group, int grouplen)
405{
406 BUG_ON(group == NULL);
407 BUG_ON(group[grouplen] != '\0');
408
Joel Becker9f9a99f2008-05-30 15:43:58 -0700409 ocfs2_leave_group(group);
410
Joel Becker286eaa92008-02-01 15:03:57 -0800411 /* cluster_disconnect() was called with hangup_pending==1 */
412 ocfs2_stack_driver_put();
Joel Becker19fdb622008-01-30 15:38:24 -0800413}
Joel Becker286eaa92008-02-01 15:03:57 -0800414EXPORT_SYMBOL_GPL(ocfs2_cluster_hangup);
Joel Becker19fdb622008-01-30 15:38:24 -0800415
Joel Becker553aa7e2008-02-01 14:51:03 -0800416int ocfs2_cluster_this_node(unsigned int *node)
417{
Joel Becker286eaa92008-02-01 15:03:57 -0800418 return active_stack->sp_ops->this_node(node);
Joel Becker553aa7e2008-02-01 14:51:03 -0800419}
Joel Becker286eaa92008-02-01 15:03:57 -0800420EXPORT_SYMBOL_GPL(ocfs2_cluster_this_node);
Joel Becker553aa7e2008-02-01 14:51:03 -0800421
Joel Becker286eaa92008-02-01 15:03:57 -0800422
Joel Becker74ae4e12008-01-31 23:56:17 -0800423/*
424 * Sysfs bits
425 */
426
427static ssize_t ocfs2_max_locking_protocol_show(struct kobject *kobj,
428 struct kobj_attribute *attr,
429 char *buf)
430{
431 ssize_t ret = 0;
432
433 spin_lock(&ocfs2_stack_lock);
434 if (lproto)
435 ret = snprintf(buf, PAGE_SIZE, "%u.%u\n",
436 lproto->lp_max_version.pv_major,
437 lproto->lp_max_version.pv_minor);
438 spin_unlock(&ocfs2_stack_lock);
439
440 return ret;
441}
442
443static struct kobj_attribute ocfs2_attr_max_locking_protocol =
444 __ATTR(max_locking_protocol, S_IFREG | S_IRUGO,
445 ocfs2_max_locking_protocol_show, NULL);
446
447static ssize_t ocfs2_loaded_cluster_plugins_show(struct kobject *kobj,
448 struct kobj_attribute *attr,
449 char *buf)
450{
451 ssize_t ret = 0, total = 0, remain = PAGE_SIZE;
452 struct ocfs2_stack_plugin *p;
453
454 spin_lock(&ocfs2_stack_lock);
455 list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
456 ret = snprintf(buf, remain, "%s\n",
457 p->sp_name);
458 if (ret < 0) {
459 total = ret;
460 break;
461 }
462 if (ret == remain) {
463 /* snprintf() didn't fit */
464 total = -E2BIG;
465 break;
466 }
467 total += ret;
468 remain -= ret;
469 }
470 spin_unlock(&ocfs2_stack_lock);
471
472 return total;
473}
474
475static struct kobj_attribute ocfs2_attr_loaded_cluster_plugins =
476 __ATTR(loaded_cluster_plugins, S_IFREG | S_IRUGO,
477 ocfs2_loaded_cluster_plugins_show, NULL);
478
479static ssize_t ocfs2_active_cluster_plugin_show(struct kobject *kobj,
480 struct kobj_attribute *attr,
481 char *buf)
482{
483 ssize_t ret = 0;
484
485 spin_lock(&ocfs2_stack_lock);
486 if (active_stack) {
487 ret = snprintf(buf, PAGE_SIZE, "%s\n",
488 active_stack->sp_name);
489 if (ret == PAGE_SIZE)
490 ret = -E2BIG;
491 }
492 spin_unlock(&ocfs2_stack_lock);
493
494 return ret;
495}
496
497static struct kobj_attribute ocfs2_attr_active_cluster_plugin =
498 __ATTR(active_cluster_plugin, S_IFREG | S_IRUGO,
499 ocfs2_active_cluster_plugin_show, NULL);
500
Joel Becker9c6c8772008-02-01 15:17:30 -0800501static ssize_t ocfs2_cluster_stack_show(struct kobject *kobj,
502 struct kobj_attribute *attr,
503 char *buf)
504{
505 ssize_t ret;
506 spin_lock(&ocfs2_stack_lock);
507 ret = snprintf(buf, PAGE_SIZE, "%s\n", cluster_stack_name);
508 spin_unlock(&ocfs2_stack_lock);
509
510 return ret;
511}
512
513static ssize_t ocfs2_cluster_stack_store(struct kobject *kobj,
514 struct kobj_attribute *attr,
515 const char *buf, size_t count)
516{
517 size_t len = count;
518 ssize_t ret;
519
520 if (len == 0)
521 return len;
522
523 if (buf[len - 1] == '\n')
524 len--;
525
526 if ((len != OCFS2_STACK_LABEL_LEN) ||
527 (strnlen(buf, len) != len))
528 return -EINVAL;
529
530 spin_lock(&ocfs2_stack_lock);
531 if (active_stack) {
532 if (!strncmp(buf, cluster_stack_name, len))
533 ret = count;
534 else
535 ret = -EBUSY;
536 } else {
537 memcpy(cluster_stack_name, buf, len);
538 ret = count;
539 }
540 spin_unlock(&ocfs2_stack_lock);
541
542 return ret;
543}
544
545
546static struct kobj_attribute ocfs2_attr_cluster_stack =
547 __ATTR(cluster_stack, S_IFREG | S_IRUGO | S_IWUSR,
548 ocfs2_cluster_stack_show,
549 ocfs2_cluster_stack_store);
550
Joel Becker74ae4e12008-01-31 23:56:17 -0800551static struct attribute *ocfs2_attrs[] = {
552 &ocfs2_attr_max_locking_protocol.attr,
553 &ocfs2_attr_loaded_cluster_plugins.attr,
554 &ocfs2_attr_active_cluster_plugin.attr,
Joel Becker9c6c8772008-02-01 15:17:30 -0800555 &ocfs2_attr_cluster_stack.attr,
Joel Becker74ae4e12008-01-31 23:56:17 -0800556 NULL,
557};
558
559static struct attribute_group ocfs2_attr_group = {
560 .attrs = ocfs2_attrs,
561};
562
563static struct kset *ocfs2_kset;
564
565static void ocfs2_sysfs_exit(void)
566{
567 kset_unregister(ocfs2_kset);
568}
569
570static int ocfs2_sysfs_init(void)
571{
572 int ret;
573
574 ocfs2_kset = kset_create_and_add("ocfs2", NULL, fs_kobj);
575 if (!ocfs2_kset)
576 return -ENOMEM;
577
578 ret = sysfs_create_group(&ocfs2_kset->kobj, &ocfs2_attr_group);
579 if (ret)
580 goto error;
581
582 return 0;
583
584error:
585 kset_unregister(ocfs2_kset);
586 return ret;
587}
588
Joel Becker3878f112008-05-30 15:30:49 -0700589/*
590 * Sysctl bits
591 *
592 * The sysctl lives at /proc/sys/fs/ocfs2/nm/hb_ctl_path. The 'nm' doesn't
593 * make as much sense in a multiple cluster stack world, but it's safer
594 * and easier to preserve the name.
595 */
596
597#define FS_OCFS2_NM 1
598
Joel Becker3878f112008-05-30 15:30:49 -0700599static ctl_table ocfs2_nm_table[] = {
600 {
601 .ctl_name = 1,
602 .procname = "hb_ctl_path",
603 .data = ocfs2_hb_ctl_path,
604 .maxlen = OCFS2_MAX_HB_CTL_PATH,
605 .mode = 0644,
606 .proc_handler = &proc_dostring,
607 .strategy = &sysctl_string,
608 },
609 { .ctl_name = 0 }
610};
611
612static ctl_table ocfs2_mod_table[] = {
613 {
614 .ctl_name = FS_OCFS2_NM,
615 .procname = "nm",
616 .data = NULL,
617 .maxlen = 0,
618 .mode = 0555,
619 .child = ocfs2_nm_table
620 },
621 { .ctl_name = 0}
622};
623
624static ctl_table ocfs2_kern_table[] = {
625 {
626 .ctl_name = FS_OCFS2,
627 .procname = "ocfs2",
628 .data = NULL,
629 .maxlen = 0,
630 .mode = 0555,
631 .child = ocfs2_mod_table
632 },
633 { .ctl_name = 0}
634};
635
636static ctl_table ocfs2_root_table[] = {
637 {
638 .ctl_name = CTL_FS,
639 .procname = "fs",
640 .data = NULL,
641 .maxlen = 0,
642 .mode = 0555,
643 .child = ocfs2_kern_table
644 },
645 { .ctl_name = 0 }
646};
647
648static struct ctl_table_header *ocfs2_table_header = NULL;
649
Joel Becker3878f112008-05-30 15:30:49 -0700650
651/*
652 * Initialization
653 */
654
Joel Becker286eaa92008-02-01 15:03:57 -0800655static int __init ocfs2_stack_glue_init(void)
Joel Becker24ef1812008-01-29 17:37:32 -0800656{
Joel Becker9c6c8772008-02-01 15:17:30 -0800657 strcpy(cluster_stack_name, OCFS2_STACK_PLUGIN_O2CB);
658
Joel Becker3878f112008-05-30 15:30:49 -0700659 ocfs2_table_header = register_sysctl_table(ocfs2_root_table);
660 if (!ocfs2_table_header) {
661 printk(KERN_ERR
662 "ocfs2 stack glue: unable to register sysctl\n");
663 return -ENOMEM; /* or something. */
664 }
665
Joel Becker74ae4e12008-01-31 23:56:17 -0800666 return ocfs2_sysfs_init();
Joel Becker24ef1812008-01-29 17:37:32 -0800667}
668
Joel Becker286eaa92008-02-01 15:03:57 -0800669static void __exit ocfs2_stack_glue_exit(void)
670{
671 lproto = NULL;
Joel Becker74ae4e12008-01-31 23:56:17 -0800672 ocfs2_sysfs_exit();
Joel Becker3878f112008-05-30 15:30:49 -0700673 if (ocfs2_table_header)
674 unregister_sysctl_table(ocfs2_table_header);
Joel Becker286eaa92008-02-01 15:03:57 -0800675}
676
677MODULE_AUTHOR("Oracle");
678MODULE_DESCRIPTION("ocfs2 cluter stack glue layer");
679MODULE_LICENSE("GPL");
680module_init(ocfs2_stack_glue_init);
681module_exit(ocfs2_stack_glue_exit);