stackglue.c 17 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7 8 9
/* -*- mode: c; c-basic-offset: 8; -*-
 * vim: noexpandtab sw=8 ts=8 sts=0:
 *
 * stackglue.c
 *
 * Code which implements an OCFS2 specific interface to underlying
 * cluster stacks.
 *
10
 * Copyright (C) 2007, 2009 Oracle.  All rights reserved.
11 12
 */

13 14 15
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/module.h>
16
#include <linux/slab.h>
17
#include <linux/kmod.h>
18 19 20
#include <linux/fs.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
21
#include <linux/sysctl.h>
22

23 24
#include "ocfs2_fs.h"

25
#include "stackglue.h"
26

27 28
#define OCFS2_STACK_PLUGIN_O2CB		"o2cb"
#define OCFS2_STACK_PLUGIN_USER		"user"
29
#define OCFS2_MAX_HB_CTL_PATH		256
30

31
static struct ocfs2_protocol_version locking_max_version;
32 33
static DEFINE_SPINLOCK(ocfs2_stack_lock);
static LIST_HEAD(ocfs2_stack_list);
34
static char cluster_stack_name[OCFS2_STACK_LABEL_LEN + 1];
35
static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
36

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
/*
 * The stack currently in use.  If not null, active_stack->sp_count > 0,
 * the module is pinned, and the locking protocol cannot be changed.
 */
static struct ocfs2_stack_plugin *active_stack;

static struct ocfs2_stack_plugin *ocfs2_stack_lookup(const char *name)
{
	struct ocfs2_stack_plugin *p;

	assert_spin_locked(&ocfs2_stack_lock);

	list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
		if (!strcmp(p->sp_name, name))
			return p;
	}

	return NULL;
}

57 58
static int ocfs2_stack_driver_request(const char *stack_name,
				      const char *plugin_name)
59 60 61 62 63 64
{
	int rc;
	struct ocfs2_stack_plugin *p;

	spin_lock(&ocfs2_stack_lock);

65 66 67 68 69 70 71 72 73
	/*
	 * If the stack passed by the filesystem isn't the selected one,
	 * we can't continue.
	 */
	if (strcmp(stack_name, cluster_stack_name)) {
		rc = -EBUSY;
		goto out;
	}

74 75 76 77 78
	if (active_stack) {
		/*
		 * If the active stack isn't the one we want, it cannot
		 * be selected right now.
		 */
79
		if (!strcmp(active_stack->sp_name, plugin_name))
80 81 82 83 84 85
			rc = 0;
		else
			rc = -EBUSY;
		goto out;
	}

86
	p = ocfs2_stack_lookup(plugin_name);
87 88 89 90 91 92 93 94 95
	if (!p || !try_module_get(p->sp_owner)) {
		rc = -ENOENT;
		goto out;
	}

	active_stack = p;
	rc = 0;

out:
96 97 98 99
	/* If we found it, pin it */
	if (!rc)
		active_stack->sp_count++;

100 101 102 103 104 105 106 107 108
	spin_unlock(&ocfs2_stack_lock);
	return rc;
}

/*
 * This function looks up the appropriate stack and makes it active.  If
 * there is no stack, it tries to load it.  It will fail if the stack still
 * cannot be found.  It will also fail if a different stack is in use.
 */
109
static int ocfs2_stack_driver_get(const char *stack_name)
110 111
{
	int rc;
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
	char *plugin_name = OCFS2_STACK_PLUGIN_O2CB;

	/*
	 * Classic stack does not pass in a stack name.  This is
	 * compatible with older tools as well.
	 */
	if (!stack_name || !*stack_name)
		stack_name = OCFS2_STACK_PLUGIN_O2CB;

	if (strlen(stack_name) != OCFS2_STACK_LABEL_LEN) {
		printk(KERN_ERR
		       "ocfs2 passed an invalid cluster stack label: \"%s\"\n",
		       stack_name);
		return -EINVAL;
	}
127

128 129 130 131 132
	/* Anything that isn't the classic stack is a user stack */
	if (strcmp(stack_name, OCFS2_STACK_PLUGIN_O2CB))
		plugin_name = OCFS2_STACK_PLUGIN_USER;

	rc = ocfs2_stack_driver_request(stack_name, plugin_name);
133
	if (rc == -ENOENT) {
134 135
		request_module("ocfs2_stack_%s", plugin_name);
		rc = ocfs2_stack_driver_request(stack_name, plugin_name);
136 137 138 139 140
	}

	if (rc == -ENOENT) {
		printk(KERN_ERR
		       "ocfs2: Cluster stack driver \"%s\" cannot be found\n",
141
		       plugin_name);
142 143
	} else if (rc == -EBUSY) {
		printk(KERN_ERR
144
		       "ocfs2: A different cluster stack is in use\n");
145 146 147 148
	}

	return rc;
}
149

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
static void ocfs2_stack_driver_put(void)
{
	spin_lock(&ocfs2_stack_lock);
	BUG_ON(active_stack == NULL);
	BUG_ON(active_stack->sp_count == 0);

	active_stack->sp_count--;
	if (!active_stack->sp_count) {
		module_put(active_stack->sp_owner);
		active_stack = NULL;
	}
	spin_unlock(&ocfs2_stack_lock);
}

int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin)
{
	int rc;

	spin_lock(&ocfs2_stack_lock);
	if (!ocfs2_stack_lookup(plugin->sp_name)) {
		plugin->sp_count = 0;
171
		plugin->sp_max_proto = locking_max_version;
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
		list_add(&plugin->sp_list, &ocfs2_stack_list);
		printk(KERN_INFO "ocfs2: Registered cluster interface %s\n",
		       plugin->sp_name);
		rc = 0;
	} else {
		printk(KERN_ERR "ocfs2: Stack \"%s\" already registered\n",
		       plugin->sp_name);
		rc = -EEXIST;
	}
	spin_unlock(&ocfs2_stack_lock);

	return rc;
}
EXPORT_SYMBOL_GPL(ocfs2_stack_glue_register);

void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin)
{
	struct ocfs2_stack_plugin *p;

	spin_lock(&ocfs2_stack_lock);
	p = ocfs2_stack_lookup(plugin->sp_name);
	if (p) {
		BUG_ON(p != plugin);
		BUG_ON(plugin == active_stack);
		BUG_ON(plugin->sp_count != 0);
		list_del_init(&plugin->sp_list);
		printk(KERN_INFO "ocfs2: Unregistered cluster interface %s\n",
		       plugin->sp_name);
	} else {
		printk(KERN_ERR "Stack \"%s\" is not registered\n",
		       plugin->sp_name);
	}
	spin_unlock(&ocfs2_stack_lock);
}
EXPORT_SYMBOL_GPL(ocfs2_stack_glue_unregister);

208
void ocfs2_stack_glue_set_max_proto_version(struct ocfs2_protocol_version *max_proto)
209 210 211 212
{
	struct ocfs2_stack_plugin *p;

	spin_lock(&ocfs2_stack_lock);
213 214 215
	if (memcmp(max_proto, &locking_max_version,
		   sizeof(struct ocfs2_protocol_version))) {
		BUG_ON(locking_max_version.pv_major != 0);
216

217 218 219 220
		locking_max_version = *max_proto;
		list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
			p->sp_max_proto = locking_max_version;
		}
221 222 223
	}
	spin_unlock(&ocfs2_stack_lock);
}
224
EXPORT_SYMBOL_GPL(ocfs2_stack_glue_set_max_proto_version);
225

226

227
/*
228 229 230 231
 * The ocfs2_dlm_lock() and ocfs2_dlm_unlock() functions take no argument
 * for the ast and bast functions.  They will pass the lksb to the ast
 * and bast.  The caller can wrap the lksb with their own structure to
 * get more information.
232
 */
233 234
int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn,
		   int mode,
235
		   struct ocfs2_dlm_lksb *lksb,
236 237
		   u32 flags,
		   void *name,
238
		   unsigned int namelen)
239
{
240 241 242 243
	if (!lksb->lksb_conn)
		lksb->lksb_conn = conn;
	else
		BUG_ON(lksb->lksb_conn != conn);
244
	return active_stack->sp_ops->dlm_lock(conn, mode, lksb, flags,
245
					      name, namelen);
246
}
247
EXPORT_SYMBOL_GPL(ocfs2_dlm_lock);
248

249
int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn,
250
		     struct ocfs2_dlm_lksb *lksb,
251
		     u32 flags)
252
{
253
	BUG_ON(lksb->lksb_conn == NULL);
254

255
	return active_stack->sp_ops->dlm_unlock(conn, lksb, flags);
256
}
257
EXPORT_SYMBOL_GPL(ocfs2_dlm_unlock);
258

259
int ocfs2_dlm_lock_status(struct ocfs2_dlm_lksb *lksb)
260
{
261
	return active_stack->sp_ops->lock_status(lksb);
262
}
263
EXPORT_SYMBOL_GPL(ocfs2_dlm_lock_status);
264

265
int ocfs2_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb)
266 267 268 269 270
{
	return active_stack->sp_ops->lvb_valid(lksb);
}
EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb_valid);

271
void *ocfs2_dlm_lvb(struct ocfs2_dlm_lksb *lksb)
272
{
273
	return active_stack->sp_ops->lock_lvb(lksb);
274
}
275
EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb);
276

277
void ocfs2_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb)
278
{
279
	active_stack->sp_ops->dump_lksb(lksb);
280
}
281
EXPORT_SYMBOL_GPL(ocfs2_dlm_dump_lksb);
282

283 284
int ocfs2_stack_supports_plocks(void)
{
Mark Fasheh's avatar
Mark Fasheh committed
285
	return active_stack && active_stack->sp_ops->plock;
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
}
EXPORT_SYMBOL_GPL(ocfs2_stack_supports_plocks);

/*
 * ocfs2_plock() can only be safely called if
 * ocfs2_stack_supports_plocks() returned true
 */
int ocfs2_plock(struct ocfs2_cluster_connection *conn, u64 ino,
		struct file *file, int cmd, struct file_lock *fl)
{
	WARN_ON_ONCE(active_stack->sp_ops->plock == NULL);
	if (active_stack->sp_ops->plock)
		return active_stack->sp_ops->plock(conn, ino, file, cmd, fl);
	return -EOPNOTSUPP;
}
EXPORT_SYMBOL_GPL(ocfs2_plock);

303
int ocfs2_cluster_connect(const char *stack_name,
304 305
			  const char *cluster_name,
			  int cluster_name_len,
306
			  const char *group,
307
			  int grouplen,
308
			  struct ocfs2_locking_protocol *lproto,
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
			  void (*recovery_handler)(int node_num,
						   void *recovery_data),
			  void *recovery_data,
			  struct ocfs2_cluster_connection **conn)
{
	int rc = 0;
	struct ocfs2_cluster_connection *new_conn;

	BUG_ON(group == NULL);
	BUG_ON(conn == NULL);
	BUG_ON(recovery_handler == NULL);

	if (grouplen > GROUP_NAME_MAX) {
		rc = -EINVAL;
		goto out;
	}

326 327 328 329 330 331
	if (memcmp(&lproto->lp_max_version, &locking_max_version,
		   sizeof(struct ocfs2_protocol_version))) {
		rc = -EINVAL;
		goto out;
	}

332 333 334 335 336 337 338
	new_conn = kzalloc(sizeof(struct ocfs2_cluster_connection),
			   GFP_KERNEL);
	if (!new_conn) {
		rc = -ENOMEM;
		goto out;
	}

339
	strlcpy(new_conn->cc_name, group, GROUP_NAME_MAX + 1);
340
	new_conn->cc_namelen = grouplen;
341 342 343
	if (cluster_name_len)
		strlcpy(new_conn->cc_cluster_name, cluster_name,
			CLUSTER_NAME_MAX + 1);
344
	new_conn->cc_cluster_name_len = cluster_name_len;
345 346 347
	new_conn->cc_recovery_handler = recovery_handler;
	new_conn->cc_recovery_data = recovery_data;

348
	new_conn->cc_proto = lproto;
349
	/* Start the new connection at our maximum compatibility level */
350 351 352
	new_conn->cc_version = lproto->lp_max_version;

	/* This will pin the stack driver if successful */
353
	rc = ocfs2_stack_driver_get(stack_name);
354 355
	if (rc)
		goto out_free;
356

357
	rc = active_stack->sp_ops->connect(new_conn);
358
	if (rc) {
359
		ocfs2_stack_driver_put();
360 361 362 363 364 365
		goto out_free;
	}

	*conn = new_conn;

out_free:
366
	if (rc)
367 368 369 370 371
		kfree(new_conn);

out:
	return rc;
}
372
EXPORT_SYMBOL_GPL(ocfs2_cluster_connect);
373

374 375 376 377 378 379 380 381 382 383 384 385 386
/* The caller will ensure all nodes have the same cluster stack */
int 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)
{
	char *stack_name = NULL;

	if (cluster_stack_name[0])
		stack_name = cluster_stack_name;
387 388 389
	return ocfs2_cluster_connect(stack_name, NULL, 0, group, grouplen,
				     lproto, recovery_handler, recovery_data,
				     conn);
390 391 392
}
EXPORT_SYMBOL_GPL(ocfs2_cluster_connect_agnostic);

393 394 395
/* If hangup_pending is 0, the stack driver will be dropped */
int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn,
			     int hangup_pending)
396 397 398 399 400
{
	int ret;

	BUG_ON(conn == NULL);

401
	ret = active_stack->sp_ops->disconnect(conn);
402 403

	/* XXX Should we free it anyway? */
404
	if (!ret) {
405
		kfree(conn);
406 407 408
		if (!hangup_pending)
			ocfs2_stack_driver_put();
	}
409 410 411

	return ret;
}
412
EXPORT_SYMBOL_GPL(ocfs2_cluster_disconnect);
413

414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
/*
 * Leave the group for this filesystem.  This is executed by a userspace
 * program (stored in ocfs2_hb_ctl_path).
 */
static void ocfs2_leave_group(const char *group)
{
	int ret;
	char *argv[5], *envp[3];

	argv[0] = ocfs2_hb_ctl_path;
	argv[1] = "-K";
	argv[2] = "-u";
	argv[3] = (char *)group;
	argv[4] = NULL;

	/* minimal command environment taken from cpu_run_sbin_hotplug */
	envp[0] = "HOME=/";
	envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
	envp[2] = NULL;

	ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
	if (ret < 0) {
		printk(KERN_ERR
		       "ocfs2: Error %d running user helper "
		       "\"%s %s %s %s\"\n",
		       ret, argv[0], argv[1], argv[2], argv[3]);
	}
}

/*
 * Hangup is a required post-umount.  ocfs2-tools software expects the
 * filesystem to call "ocfs2_hb_ctl" during unmount.  This happens
 * regardless of whether the DLM got started, so we can't do it
 * in ocfs2_cluster_disconnect().  The ocfs2_leave_group() function does
 * the actual work.
 */
450 451 452 453 454
void ocfs2_cluster_hangup(const char *group, int grouplen)
{
	BUG_ON(group == NULL);
	BUG_ON(group[grouplen] != '\0');

455 456
	ocfs2_leave_group(group);

457 458
	/* cluster_disconnect() was called with hangup_pending==1 */
	ocfs2_stack_driver_put();
459
}
460
EXPORT_SYMBOL_GPL(ocfs2_cluster_hangup);
461

462 463
int ocfs2_cluster_this_node(struct ocfs2_cluster_connection *conn,
			    unsigned int *node)
464
{
465
	return active_stack->sp_ops->this_node(conn, node);
466
}
467
EXPORT_SYMBOL_GPL(ocfs2_cluster_this_node);
468

469

470 471 472 473 474 475 476 477 478 479 480
/*
 * Sysfs bits
 */

static ssize_t ocfs2_max_locking_protocol_show(struct kobject *kobj,
					       struct kobj_attribute *attr,
					       char *buf)
{
	ssize_t ret = 0;

	spin_lock(&ocfs2_stack_lock);
481
	if (locking_max_version.pv_major)
482
		ret = snprintf(buf, PAGE_SIZE, "%u.%u\n",
483 484
			       locking_max_version.pv_major,
			       locking_max_version.pv_minor);
485 486 487 488 489 490
	spin_unlock(&ocfs2_stack_lock);

	return ret;
}

static struct kobj_attribute ocfs2_attr_max_locking_protocol =
491
	__ATTR(max_locking_protocol, S_IRUGO,
492 493 494 495 496
	       ocfs2_max_locking_protocol_show, NULL);

static ssize_t ocfs2_loaded_cluster_plugins_show(struct kobject *kobj,
						 struct kobj_attribute *attr,
						 char *buf)
497
{
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	ssize_t ret = 0, total = 0, remain = PAGE_SIZE;
	struct ocfs2_stack_plugin *p;

	spin_lock(&ocfs2_stack_lock);
	list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
		ret = snprintf(buf, remain, "%s\n",
			       p->sp_name);
		if (ret < 0) {
			total = ret;
			break;
		}
		if (ret == remain) {
			/* snprintf() didn't fit */
			total = -E2BIG;
			break;
		}
		total += ret;
		remain -= ret;
	}
	spin_unlock(&ocfs2_stack_lock);

	return total;
}

static struct kobj_attribute ocfs2_attr_loaded_cluster_plugins =
523
	__ATTR(loaded_cluster_plugins, S_IRUGO,
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
	       ocfs2_loaded_cluster_plugins_show, NULL);

static ssize_t ocfs2_active_cluster_plugin_show(struct kobject *kobj,
						struct kobj_attribute *attr,
						char *buf)
{
	ssize_t ret = 0;

	spin_lock(&ocfs2_stack_lock);
	if (active_stack) {
		ret = snprintf(buf, PAGE_SIZE, "%s\n",
			       active_stack->sp_name);
		if (ret == PAGE_SIZE)
			ret = -E2BIG;
	}
	spin_unlock(&ocfs2_stack_lock);

	return ret;
}

static struct kobj_attribute ocfs2_attr_active_cluster_plugin =
545
	__ATTR(active_cluster_plugin, S_IRUGO,
546 547
	       ocfs2_active_cluster_plugin_show, NULL);

548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
static ssize_t ocfs2_cluster_stack_show(struct kobject *kobj,
					struct kobj_attribute *attr,
					char *buf)
{
	ssize_t ret;
	spin_lock(&ocfs2_stack_lock);
	ret = snprintf(buf, PAGE_SIZE, "%s\n", cluster_stack_name);
	spin_unlock(&ocfs2_stack_lock);

	return ret;
}

static ssize_t ocfs2_cluster_stack_store(struct kobject *kobj,
					 struct kobj_attribute *attr,
					 const char *buf, size_t count)
{
	size_t len = count;
	ssize_t ret;

	if (len == 0)
		return len;

	if (buf[len - 1] == '\n')
		len--;

	if ((len != OCFS2_STACK_LABEL_LEN) ||
	    (strnlen(buf, len) != len))
		return -EINVAL;

	spin_lock(&ocfs2_stack_lock);
	if (active_stack) {
		if (!strncmp(buf, cluster_stack_name, len))
			ret = count;
		else
			ret = -EBUSY;
	} else {
		memcpy(cluster_stack_name, buf, len);
		ret = count;
	}
	spin_unlock(&ocfs2_stack_lock);

	return ret;
}


static struct kobj_attribute ocfs2_attr_cluster_stack =
594
	__ATTR(cluster_stack, S_IRUGO | S_IWUSR,
595 596 597
	       ocfs2_cluster_stack_show,
	       ocfs2_cluster_stack_store);

598 599 600 601 602 603 604 605 606 607 608 609 610


static ssize_t ocfs2_dlm_recover_show(struct kobject *kobj,
					struct kobj_attribute *attr,
					char *buf)
{
	return snprintf(buf, PAGE_SIZE, "1\n");
}

static struct kobj_attribute ocfs2_attr_dlm_recover_support =
	__ATTR(dlm_recover_callback_support, S_IRUGO,
	       ocfs2_dlm_recover_show, NULL);

611 612 613 614
static struct attribute *ocfs2_attrs[] = {
	&ocfs2_attr_max_locking_protocol.attr,
	&ocfs2_attr_loaded_cluster_plugins.attr,
	&ocfs2_attr_active_cluster_plugin.attr,
615
	&ocfs2_attr_cluster_stack.attr,
616
	&ocfs2_attr_dlm_recover_support.attr,
617 618 619
	NULL,
};

620
static const struct attribute_group ocfs2_attr_group = {
621 622 623
	.attrs = ocfs2_attrs,
};

624 625
struct kset *ocfs2_kset;
EXPORT_SYMBOL_GPL(ocfs2_kset);
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643

static void ocfs2_sysfs_exit(void)
{
	kset_unregister(ocfs2_kset);
}

static int ocfs2_sysfs_init(void)
{
	int ret;

	ocfs2_kset = kset_create_and_add("ocfs2", NULL, fs_kobj);
	if (!ocfs2_kset)
		return -ENOMEM;

	ret = sysfs_create_group(&ocfs2_kset->kobj, &ocfs2_attr_group);
	if (ret)
		goto error;

644
	return 0;
645 646 647 648 649 650

error:
	kset_unregister(ocfs2_kset);
	return ret;
}

651 652 653 654 655 656 657 658
/*
 * Sysctl bits
 *
 * The sysctl lives at /proc/sys/fs/ocfs2/nm/hb_ctl_path.  The 'nm' doesn't
 * make as much sense in a multiple cluster stack world, but it's safer
 * and easier to preserve the name.
 */

659
static struct ctl_table ocfs2_nm_table[] = {
660 661 662 663 664
	{
		.procname	= "hb_ctl_path",
		.data		= ocfs2_hb_ctl_path,
		.maxlen		= OCFS2_MAX_HB_CTL_PATH,
		.mode		= 0644,
665
		.proc_handler	= proc_dostring,
666
	},
667
	{ }
668 669
};

670
static struct ctl_table ocfs2_mod_table[] = {
671 672 673 674 675 676 677
	{
		.procname	= "nm",
		.data		= NULL,
		.maxlen		= 0,
		.mode		= 0555,
		.child		= ocfs2_nm_table
	},
678
	{ }
679 680
};

681
static struct ctl_table ocfs2_kern_table[] = {
682 683 684 685 686 687 688
	{
		.procname	= "ocfs2",
		.data		= NULL,
		.maxlen		= 0,
		.mode		= 0555,
		.child		= ocfs2_mod_table
	},
689
	{ }
690 691
};

692
static struct ctl_table ocfs2_root_table[] = {
693 694 695 696 697 698 699
	{
		.procname	= "fs",
		.data		= NULL,
		.maxlen		= 0,
		.mode		= 0555,
		.child		= ocfs2_kern_table
	},
700
	{ }
701 702
};

703
static struct ctl_table_header *ocfs2_table_header;
704 705 706 707 708 709


/*
 * Initialization
 */

710 711
static int __init ocfs2_stack_glue_init(void)
{
712 713
	strcpy(cluster_stack_name, OCFS2_STACK_PLUGIN_O2CB);

714 715 716 717 718 719 720
	ocfs2_table_header = register_sysctl_table(ocfs2_root_table);
	if (!ocfs2_table_header) {
		printk(KERN_ERR
		       "ocfs2 stack glue: unable to register sysctl\n");
		return -ENOMEM; /* or something. */
	}

721
	return ocfs2_sysfs_init();
722
}
723

724 725
static void __exit ocfs2_stack_glue_exit(void)
{
726 727
	memset(&locking_max_version, 0,
	       sizeof(struct ocfs2_protocol_version));
728
	ocfs2_sysfs_exit();
729 730
	if (ocfs2_table_header)
		unregister_sysctl_table(ocfs2_table_header);
731 732
}

733 734 735 736 737
MODULE_AUTHOR("Oracle");
MODULE_DESCRIPTION("ocfs2 cluter stack glue layer");
MODULE_LICENSE("GPL");
module_init(ocfs2_stack_glue_init);
module_exit(ocfs2_stack_glue_exit);