[deliverable/linux.git] / fs / ocfs2 / stack_user.c

/* -*- mode: c; c-basic-offset: 8; -*-
 * vim: noexpandtab sw=8 ts=8 sts=0:
 *
 * stack_user.c
 *
 * Code which interfaces ocfs2 with fs/dlm and a userspace stack.
 *
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/mutex.h>
#include <linux/reboot.h>
#include <asm/uaccess.h>

#include "stackglue.h"


/*
 * The control protocol starts with a handshake.  Until the handshake
 * is complete, the control device will fail all write(2)s.
 *
 * The handshake is simple.  First, the client reads until EOF.  Each line
 * of output is a supported protocol tag.  All protocol tags are a single
 * character followed by a two hex digit version number.  Currently the
 * only things supported is T01, for "Text-base version 0x01".  Next, the
 * client writes the version they would like to use, including the newline.
 * Thus, the protocol tag is 'T01\n'.  If the version tag written is
 * unknown, -EINVAL is returned.  Once the negotiation is complete, the
 * client can start sending messages.
 *
 * The T01 protocol only has one message, "DOWN".  It has the following
 * syntax:
 *
 *  DOWN<space><32-char-cap-hex-uuid><space><8-char-hex-nodenum><newline>
 *
 * eg:
 *
 *  DOWN 632A924FDD844190BDA93C0DF6B94899 00000001\n
 *
 * This is 47 characters.
 */

/*
 * Whether or not the client has done the handshake.
 * For now, we have just one protocol version.
 */
#define OCFS2_CONTROL_PROTO			"T01\n"
#define OCFS2_CONTROL_PROTO_LEN			4
#define OCFS2_CONTROL_HANDSHAKE_INVALID		(0)
#define OCFS2_CONTROL_HANDSHAKE_READ		(1)
#define OCFS2_CONTROL_HANDSHAKE_VALID		(2)
#define OCFS2_CONTROL_MESSAGE_DOWN		"DOWN"
#define OCFS2_CONTROL_MESSAGE_DOWN_LEN		4
#define OCFS2_CONTROL_MESSAGE_DOWN_TOTAL_LEN	47
#define OCFS2_TEXT_UUID_LEN			32
#define OCFS2_CONTROL_MESSAGE_NODENUM_LEN	8

/*
 * ocfs2_live_connection is refcounted because the filesystem and
 * miscdevice sides can detach in different order.  Let's just be safe.
 */
struct ocfs2_live_connection {
	struct list_head		oc_list;
	struct ocfs2_cluster_connection	*oc_conn;
};

struct ocfs2_control_private {
	struct list_head op_list;
	int op_state;
};

static atomic_t ocfs2_control_opened;

static LIST_HEAD(ocfs2_live_connection_list);
static LIST_HEAD(ocfs2_control_private_list);
static DEFINE_MUTEX(ocfs2_control_lock);

static inline void ocfs2_control_set_handshake_state(struct file *file,
						     int state)
{
	struct ocfs2_control_private *p = file->private_data;
	p->op_state = state;
}

static inline int ocfs2_control_get_handshake_state(struct file *file)
{
	struct ocfs2_control_private *p = file->private_data;
	return p->op_state;
}

static struct ocfs2_live_connection *ocfs2_connection_find(const char *name)
{
	size_t len = strlen(name);
	struct ocfs2_live_connection *c;

	BUG_ON(!mutex_is_locked(&ocfs2_control_lock));

	list_for_each_entry(c, &ocfs2_live_connection_list, oc_list) {
		if ((c->oc_conn->cc_namelen == len) &&
		    !strncmp(c->oc_conn->cc_name, name, len))
			return c;
	}

	return c;
}

/*
 * ocfs2_live_connection structures are created underneath the ocfs2
 * mount path.  Since the VFS prevents multiple calls to
 * fill_super(), we can't get dupes here.
 */
static int ocfs2_live_connection_new(struct ocfs2_cluster_connection *conn,
				     struct ocfs2_live_connection **c_ret)
{
	int rc = 0;
	struct ocfs2_live_connection *c;

	c = kzalloc(sizeof(struct ocfs2_live_connection), GFP_KERNEL);
	if (!c)
		return -ENOMEM;

	mutex_lock(&ocfs2_control_lock);
	c->oc_conn = conn;

	if (atomic_read(&ocfs2_control_opened))
		list_add(&c->oc_list, &ocfs2_live_connection_list);
	else {
		printk(KERN_ERR
		       "ocfs2: Userspace control daemon is not present\n");
		rc = -ESRCH;
	}

	mutex_unlock(&ocfs2_control_lock);

	if (!rc)
		*c_ret = c;
	else
		kfree(c);

	return rc;
}

/*
 * This function disconnects the cluster connection from ocfs2_control.
 * Afterwards, userspace can't affect the cluster connection.
 */
static void ocfs2_live_connection_drop(struct ocfs2_live_connection *c)
{
	mutex_lock(&ocfs2_control_lock);
	list_del_init(&c->oc_list);
	c->oc_conn = NULL;
	mutex_unlock(&ocfs2_control_lock);

	kfree(c);
}

static ssize_t ocfs2_control_cfu(void *target, size_t target_len,
				 const char __user *buf, size_t count)
{
	/* The T01 expects write(2) calls to have exactly one command */
	if (count != target_len)
		return -EINVAL;

	if (copy_from_user(target, buf, target_len))
		return -EFAULT;

	return count;
}

static ssize_t ocfs2_control_validate_handshake(struct file *file,
						const char __user *buf,
						size_t count)
{
	ssize_t ret;
	char kbuf[OCFS2_CONTROL_PROTO_LEN];

	ret = ocfs2_control_cfu(kbuf, OCFS2_CONTROL_PROTO_LEN,
				buf, count);
	if (ret != count)
		return ret;

	if (strncmp(kbuf, OCFS2_CONTROL_PROTO, OCFS2_CONTROL_PROTO_LEN))
		return -EINVAL;

	atomic_inc(&ocfs2_control_opened);
	ocfs2_control_set_handshake_state(file,
					  OCFS2_CONTROL_HANDSHAKE_VALID);


	return count;
}

static void ocfs2_control_send_down(const char *uuid,
				    int nodenum)
{
	struct ocfs2_live_connection *c;

	mutex_lock(&ocfs2_control_lock);

	c = ocfs2_connection_find(uuid);
	if (c) {
		BUG_ON(c->oc_conn == NULL);
		c->oc_conn->cc_recovery_handler(nodenum,
						c->oc_conn->cc_recovery_data);
	}

	mutex_unlock(&ocfs2_control_lock);
}

/* DOWN<space><32-char-cap-hex-uuid><space><8-char-hex-nodenum><newline> */
struct ocfs2_control_message_down {
	char	tag[OCFS2_CONTROL_MESSAGE_DOWN_LEN];
	char	space1;
	char	uuid[OCFS2_TEXT_UUID_LEN];
	char	space2;
	char	nodestr[OCFS2_CONTROL_MESSAGE_NODENUM_LEN];
	char	newline;
};

static ssize_t ocfs2_control_message(struct file *file,
				     const char __user *buf,
				     size_t count)
{
	ssize_t ret;
	char *p = NULL;
	long nodenum;
	struct ocfs2_control_message_down msg;

	/* Try to catch padding issues */
	WARN_ON(offsetof(struct ocfs2_control_message_down, uuid) !=
		(sizeof(msg.tag) + sizeof(msg.space1)));

	memset(&msg, 0, sizeof(struct ocfs2_control_message_down));
	ret = ocfs2_control_cfu(&msg, OCFS2_CONTROL_MESSAGE_DOWN_TOTAL_LEN,
				buf, count);
	if (ret != count)
		return ret;

	if (strncmp(msg.tag, OCFS2_CONTROL_MESSAGE_DOWN,
		    strlen(OCFS2_CONTROL_MESSAGE_DOWN)))
		return -EINVAL;

	if ((msg.space1 != ' ') || (msg.space2 != ' ') ||
	    (msg.newline != '\n'))
		return -EINVAL;
	msg.space1 = msg.space2 = msg.newline = '\0';

	nodenum = simple_strtol(msg.nodestr, &p, 16);
	if (!p || *p)
		return -EINVAL;

	if ((nodenum == LONG_MIN) || (nodenum == LONG_MAX) ||
	    (nodenum > INT_MAX) || (nodenum < 0))
		return -ERANGE;

	ocfs2_control_send_down(msg.uuid, nodenum);

	return count;
}

static ssize_t ocfs2_control_write(struct file *file,
				   const char __user *buf,
				   size_t count,
				   loff_t *ppos)
{
	ssize_t ret;

	switch (ocfs2_control_get_handshake_state(file)) {
		case OCFS2_CONTROL_HANDSHAKE_INVALID:
			ret = -EINVAL;
			break;

		case OCFS2_CONTROL_HANDSHAKE_READ:
			ret = ocfs2_control_validate_handshake(file, buf,
							       count);
			break;

		case OCFS2_CONTROL_HANDSHAKE_VALID:
			ret = ocfs2_control_message(file, buf, count);
			break;

		default:
			BUG();
			ret = -EIO;
			break;
	}

	return ret;
}

/*
 * This is a naive version.  If we ever have a new protocol, we'll expand
 * it.  Probably using seq_file.
 */
static ssize_t ocfs2_control_read(struct file *file,
				  char __user *buf,
				  size_t count,
				  loff_t *ppos)
{
	char *proto_string = OCFS2_CONTROL_PROTO;
	size_t to_write = 0;

	if (*ppos >= OCFS2_CONTROL_PROTO_LEN)
		return 0;

	to_write = OCFS2_CONTROL_PROTO_LEN - *ppos;
	if (to_write > count)
		to_write = count;
	if (copy_to_user(buf, proto_string + *ppos, to_write))
		return -EFAULT;

	*ppos += to_write;

	/* Have we read the whole protocol list? */
	if (*ppos >= OCFS2_CONTROL_PROTO_LEN)
		ocfs2_control_set_handshake_state(file,
						  OCFS2_CONTROL_HANDSHAKE_READ);

	return to_write;
}

static int ocfs2_control_release(struct inode *inode, struct file *file)
{
	struct ocfs2_control_private *p = file->private_data;

	mutex_lock(&ocfs2_control_lock);

	if (ocfs2_control_get_handshake_state(file) !=
	    OCFS2_CONTROL_HANDSHAKE_VALID)
		goto out;

	if (atomic_dec_and_test(&ocfs2_control_opened)) {
		if (!list_empty(&ocfs2_live_connection_list)) {
			/* XXX: Do bad things! */
			printk(KERN_ERR
			       "ocfs2: Unexpected release of ocfs2_control!\n"
			       "       Loss of cluster connection requires "
			       "an emergency restart!\n");
			emergency_restart();
		}
	}

out:
	list_del_init(&p->op_list);
	file->private_data = NULL;

	mutex_unlock(&ocfs2_control_lock);

	kfree(p);

	return 0;
}

static int ocfs2_control_open(struct inode *inode, struct file *file)
{
	struct ocfs2_control_private *p;

	p = kzalloc(sizeof(struct ocfs2_control_private), GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	mutex_lock(&ocfs2_control_lock);
	file->private_data = p;
	list_add(&p->op_list, &ocfs2_control_private_list);
	mutex_unlock(&ocfs2_control_lock);

	return 0;
}

static const struct file_operations ocfs2_control_fops = {
	.open    = ocfs2_control_open,
	.release = ocfs2_control_release,
	.read    = ocfs2_control_read,
	.write   = ocfs2_control_write,
	.owner   = THIS_MODULE,
};

struct miscdevice ocfs2_control_device = {
	.minor		= MISC_DYNAMIC_MINOR,
	.name		= "ocfs2_control",
	.fops		= &ocfs2_control_fops,
};

static int ocfs2_control_init(void)
{
	int rc;

	atomic_set(&ocfs2_control_opened, 0);

	rc = misc_register(&ocfs2_control_device);
	if (rc)
		printk(KERN_ERR
		       "ocfs2: Unable to register ocfs2_control device "
		       "(errno %d)\n",
		       -rc);

	return rc;
}

static void ocfs2_control_exit(void)
{
	int rc;

	rc = misc_deregister(&ocfs2_control_device);
	if (rc)
		printk(KERN_ERR
		       "ocfs2: Unable to deregister ocfs2_control device "
		       "(errno %d)\n",
		       -rc);
}

static int __init user_stack_init(void)
{
	return ocfs2_control_init();
}

static void __exit user_stack_exit(void)
{
	ocfs2_control_exit();
}

MODULE_AUTHOR("Oracle");
MODULE_DESCRIPTION("ocfs2 driver for userspace cluster stacks");
MODULE_LICENSE("GPL");
module_init(user_stack_init);
module_exit(user_stack_exit);
Commit	Line	Data
8adf0536 JB	1	/* -- mode: c; c-basic-offset: 8; --
	2	* vim: noexpandtab sw=8 ts=8 sts=0:
	3	*
	4	* stack_user.c
	5	*
	6	* Code which interfaces ocfs2 with fs/dlm and a userspace stack.
	7	*
	8	* Copyright (C) 2007 Oracle. All rights reserved.
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public
	12	* License as published by the Free Software Foundation, version 2.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*/
	19
	20	#include <linux/module.h>
6427a727 JB	21	#include <linux/fs.h>
	22	#include <linux/miscdevice.h>
	23	#include <linux/mutex.h>
	24	#include <linux/reboot.h>
462c7e6a	25	#include <asm/uaccess.h>
8adf0536 JB	26
	27	#include "stackglue.h"
	28
	29
6427a727 JB	30	/*
	31	* The control protocol starts with a handshake. Until the handshake
	32	* is complete, the control device will fail all write(2)s.
	33	*
	34	* The handshake is simple. First, the client reads until EOF. Each line
	35	* of output is a supported protocol tag. All protocol tags are a single
	36	* character followed by a two hex digit version number. Currently the
	37	* only things supported is T01, for "Text-base version 0x01". Next, the
de870ef0 JB	38	* client writes the version they would like to use, including the newline.
	39	* Thus, the protocol tag is 'T01\n'. If the version tag written is
	40	* unknown, -EINVAL is returned. Once the negotiation is complete, the
	41	* client can start sending messages.
	42	*
	43	* The T01 protocol only has one message, "DOWN". It has the following
	44	* syntax:
	45	*
	46	* DOWN<space><32-char-cap-hex-uuid><space><8-char-hex-nodenum><newline>
	47	*
	48	* eg:
	49	*
	50	* DOWN 632A924FDD844190BDA93C0DF6B94899 00000001\n
	51	*
	52	* This is 47 characters.
6427a727 JB	53	*/
6427a727 JB	54
462c7e6a JB	55	/*
	56	* Whether or not the client has done the handshake.
	57	* For now, we have just one protocol version.
	58	*/
	59	#define OCFS2_CONTROL_PROTO "T01\n"
	60	#define OCFS2_CONTROL_PROTO_LEN 4
	61	#define OCFS2_CONTROL_HANDSHAKE_INVALID (0)
	62	#define OCFS2_CONTROL_HANDSHAKE_READ (1)
	63	#define OCFS2_CONTROL_HANDSHAKE_VALID (2)
de870ef0 JB	64	#define OCFS2_CONTROL_MESSAGE_DOWN "DOWN"
	65	#define OCFS2_CONTROL_MESSAGE_DOWN_LEN 4
	66	#define OCFS2_CONTROL_MESSAGE_DOWN_TOTAL_LEN 47
	67	#define OCFS2_TEXT_UUID_LEN 32
	68	#define OCFS2_CONTROL_MESSAGE_NODENUM_LEN 8
462c7e6a	69
6427a727 JB	70	/*
	71	* ocfs2_live_connection is refcounted because the filesystem and
	72	* miscdevice sides can detach in different order. Let's just be safe.
	73	*/
	74	struct ocfs2_live_connection {
	75	struct list_head oc_list;
	76	struct ocfs2_cluster_connection *oc_conn;
	77	};
	78
462c7e6a JB	79	struct ocfs2_control_private {
	80	struct list_head op_list;
	81	int op_state;
	82	};
	83
6427a727 JB	84	static atomic_t ocfs2_control_opened;
	85
	86	static LIST_HEAD(ocfs2_live_connection_list);
462c7e6a	87	static LIST_HEAD(ocfs2_control_private_list);
6427a727 JB	88	static DEFINE_MUTEX(ocfs2_control_lock);
6427a727 JB	89
462c7e6a JB	90	static inline void ocfs2_control_set_handshake_state(struct file *file,
	91	int state)
	92	{
	93	struct ocfs2_control_private *p = file->private_data;
	94	p->op_state = state;
	95	}
	96
	97	static inline int ocfs2_control_get_handshake_state(struct file *file)
	98	{
	99	struct ocfs2_control_private *p = file->private_data;
	100	return p->op_state;
	101	}
	102
6427a727 JB	103	static struct ocfs2_live_connection ocfs2_connection_find(const char name)
	104	{
	105	size_t len = strlen(name);
	106	struct ocfs2_live_connection *c;
	107
	108	BUG_ON(!mutex_is_locked(&ocfs2_control_lock));
	109
	110	list_for_each_entry(c, &ocfs2_live_connection_list, oc_list) {
	111	if ((c->oc_conn->cc_namelen == len) &&
	112	!strncmp(c->oc_conn->cc_name, name, len))
	113	return c;
	114	}
	115
	116	return c;
	117	}
	118
	119	/*
	120	* ocfs2_live_connection structures are created underneath the ocfs2
	121	* mount path. Since the VFS prevents multiple calls to
	122	* fill_super(), we can't get dupes here.
	123	*/
	124	static int ocfs2_live_connection_new(struct ocfs2_cluster_connection *conn,
	125	struct ocfs2_live_connection **c_ret)
	126	{
	127	int rc = 0;
	128	struct ocfs2_live_connection *c;
	129
	130	c = kzalloc(sizeof(struct ocfs2_live_connection), GFP_KERNEL);
	131	if (!c)
	132	return -ENOMEM;
	133
	134	mutex_lock(&ocfs2_control_lock);
	135	c->oc_conn = conn;
	136
	137	if (atomic_read(&ocfs2_control_opened))
	138	list_add(&c->oc_list, &ocfs2_live_connection_list);
	139	else {
	140	printk(KERN_ERR
	141	"ocfs2: Userspace control daemon is not present\n");
	142	rc = -ESRCH;
	143	}
	144
	145	mutex_unlock(&ocfs2_control_lock);
	146
	147	if (!rc)
	148	*c_ret = c;
	149	else
	150	kfree(c);
	151
	152	return rc;
	153	}
	154
	155	/*
	156	* This function disconnects the cluster connection from ocfs2_control.
	157	* Afterwards, userspace can't affect the cluster connection.
	158	*/
	159	static void ocfs2_live_connection_drop(struct ocfs2_live_connection *c)
	160	{
	161	mutex_lock(&ocfs2_control_lock);
	162	list_del_init(&c->oc_list);
	163	c->oc_conn = NULL;
	164	mutex_unlock(&ocfs2_control_lock);
	165
	166	kfree(c);
167	}
168
de870ef0	169	static ssize_t ocfs2_control_cfu(void *target, size_t target_len,
462c7e6a JB	170	const char __user *buf, size_t count)
	171	{
	172	/* The T01 expects write(2) calls to have exactly one command */
	173	if (count != target_len)
	174	return -EINVAL;
	175
	176	if (copy_from_user(target, buf, target_len))
	177	return -EFAULT;
	178
	179	return count;
	180	}
	181
	182	static ssize_t ocfs2_control_validate_handshake(struct file *file,
	183	const char __user *buf,
	184	size_t count)
	185	{
	186	ssize_t ret;
	187	char kbuf[OCFS2_CONTROL_PROTO_LEN];
	188
	189	ret = ocfs2_control_cfu(kbuf, OCFS2_CONTROL_PROTO_LEN,
	190	buf, count);
	191	if (ret != count)
	192	return ret;
	193
	194	if (strncmp(kbuf, OCFS2_CONTROL_PROTO, OCFS2_CONTROL_PROTO_LEN))
	195	return -EINVAL;
	196
	197	atomic_inc(&ocfs2_control_opened);
	198	ocfs2_control_set_handshake_state(file,
	199	OCFS2_CONTROL_HANDSHAKE_VALID);
	200
	201
	202	return count;
	203	}
	204
de870ef0 JB	205	static void ocfs2_control_send_down(const char *uuid,
	206	int nodenum)
	207	{
	208	struct ocfs2_live_connection *c;
	209
	210	mutex_lock(&ocfs2_control_lock);
	211
	212	c = ocfs2_connection_find(uuid);
	213	if (c) {
	214	BUG_ON(c->oc_conn == NULL);
	215	c->oc_conn->cc_recovery_handler(nodenum,
	216	c->oc_conn->cc_recovery_data);
	217	}
	218
	219	mutex_unlock(&ocfs2_control_lock);
	220	}
	221
	222	/* DOWN<space><32-char-cap-hex-uuid><space><8-char-hex-nodenum><newline> */
	223	struct ocfs2_control_message_down {
	224	char tag[OCFS2_CONTROL_MESSAGE_DOWN_LEN];
	225	char space1;
	226	char uuid[OCFS2_TEXT_UUID_LEN];
	227	char space2;
	228	char nodestr[OCFS2_CONTROL_MESSAGE_NODENUM_LEN];
	229	char newline;
	230	};
	231
	232	static ssize_t ocfs2_control_message(struct file *file,
	233	const char __user *buf,
	234	size_t count)
	235	{
	236	ssize_t ret;
	237	char *p = NULL;
	238	long nodenum;
	239	struct ocfs2_control_message_down msg;
	240
	241	/* Try to catch padding issues */
	242	WARN_ON(offsetof(struct ocfs2_control_message_down, uuid) !=
	243	(sizeof(msg.tag) + sizeof(msg.space1)));
	244
	245	memset(&msg, 0, sizeof(struct ocfs2_control_message_down));
	246	ret = ocfs2_control_cfu(&msg, OCFS2_CONTROL_MESSAGE_DOWN_TOTAL_LEN,
	247	buf, count);
	248	if (ret != count)
	249	return ret;
	250
	251	if (strncmp(msg.tag, OCFS2_CONTROL_MESSAGE_DOWN,
	252	strlen(OCFS2_CONTROL_MESSAGE_DOWN)))
	253	return -EINVAL;
	254
	255	if ((msg.space1 != ' ') \|\| (msg.space2 != ' ') \|\|
	256	(msg.newline != '\n'))
	257	return -EINVAL;
	258	msg.space1 = msg.space2 = msg.newline = '\0';
	259
	260	nodenum = simple_strtol(msg.nodestr, &p, 16);
	261	if (!p \|\| *p)
	262	return -EINVAL;
	263
	264	if ((nodenum == LONG_MIN) \|\| (nodenum == LONG_MAX) \|\|
	265	(nodenum > INT_MAX) \|\| (nodenum < 0))
	266	return -ERANGE;
	267
	268	ocfs2_control_send_down(msg.uuid, nodenum);
269
270	return count;
271	}
6427a727 JB	272
	273	static ssize_t ocfs2_control_write(struct file *file,
	274	const char __user *buf,
	275	size_t count,
	276	loff_t *ppos)
8adf0536	277	{
462c7e6a JB	278	ssize_t ret;
	279
	280	switch (ocfs2_control_get_handshake_state(file)) {
	281	case OCFS2_CONTROL_HANDSHAKE_INVALID:
	282	ret = -EINVAL;
	283	break;
	284
	285	case OCFS2_CONTROL_HANDSHAKE_READ:
	286	ret = ocfs2_control_validate_handshake(file, buf,
	287	count);
	288	break;
	289
	290	case OCFS2_CONTROL_HANDSHAKE_VALID:
de870ef0	291	ret = ocfs2_control_message(file, buf, count);
462c7e6a JB	292	break;
	293
	294	default:
	295	BUG();
	296	ret = -EIO;
	297	break;
	298	}
	299
	300	return ret;
8adf0536 JB	301	}
8adf0536 JB	302
462c7e6a JB	303	/*
	304	* This is a naive version. If we ever have a new protocol, we'll expand
	305	* it. Probably using seq_file.
	306	*/
6427a727 JB	307	static ssize_t ocfs2_control_read(struct file *file,
	308	char __user *buf,
	309	size_t count,
	310	loff_t *ppos)
	311	{
462c7e6a JB	312	char *proto_string = OCFS2_CONTROL_PROTO;
	313	size_t to_write = 0;
	314
	315	if (*ppos >= OCFS2_CONTROL_PROTO_LEN)
	316	return 0;
	317
	318	to_write = OCFS2_CONTROL_PROTO_LEN - *ppos;
	319	if (to_write > count)
	320	to_write = count;
	321	if (copy_to_user(buf, proto_string + *ppos, to_write))
	322	return -EFAULT;
	323
	324	*ppos += to_write;
	325
	326	/* Have we read the whole protocol list? */
	327	if (*ppos >= OCFS2_CONTROL_PROTO_LEN)
	328	ocfs2_control_set_handshake_state(file,
	329	OCFS2_CONTROL_HANDSHAKE_READ);
	330
	331	return to_write;
6427a727 JB	332	}
	333
	334	static int ocfs2_control_release(struct inode inode, struct file file)
	335	{
462c7e6a JB	336	struct ocfs2_control_private *p = file->private_data;
	337
	338	mutex_lock(&ocfs2_control_lock);
	339
	340	if (ocfs2_control_get_handshake_state(file) !=
	341	OCFS2_CONTROL_HANDSHAKE_VALID)
	342	goto out;
	343
6427a727	344	if (atomic_dec_and_test(&ocfs2_control_opened)) {
6427a727 JB	345	if (!list_empty(&ocfs2_live_connection_list)) {
	346	/* XXX: Do bad things! */
	347	printk(KERN_ERR
	348	"ocfs2: Unexpected release of ocfs2_control!\n"
	349	" Loss of cluster connection requires "
	350	"an emergency restart!\n");
	351	emergency_restart();
	352	}
6427a727 JB	353	}
6427a727 JB	354
462c7e6a JB	355	out:
	356	list_del_init(&p->op_list);
	357	file->private_data = NULL;
	358
	359	mutex_unlock(&ocfs2_control_lock);
	360
	361	kfree(p);
	362
6427a727 JB	363	return 0;
	364	}
	365
	366	static int ocfs2_control_open(struct inode inode, struct file file)
	367	{
462c7e6a JB	368	struct ocfs2_control_private *p;
	369
	370	p = kzalloc(sizeof(struct ocfs2_control_private), GFP_KERNEL);
	371	if (!p)
	372	return -ENOMEM;
	373
	374	mutex_lock(&ocfs2_control_lock);
	375	file->private_data = p;
	376	list_add(&p->op_list, &ocfs2_control_private_list);
	377	mutex_unlock(&ocfs2_control_lock);
6427a727 JB	378
	379	return 0;
	380	}
	381
	382	static const struct file_operations ocfs2_control_fops = {
	383	.open = ocfs2_control_open,
	384	.release = ocfs2_control_release,
	385	.read = ocfs2_control_read,
	386	.write = ocfs2_control_write,
	387	.owner = THIS_MODULE,
	388	};
	389
	390	struct miscdevice ocfs2_control_device = {
	391	.minor = MISC_DYNAMIC_MINOR,
	392	.name = "ocfs2_control",
	393	.fops = &ocfs2_control_fops,
	394	};
	395
	396	static int ocfs2_control_init(void)
	397	{
	398	int rc;
	399
	400	atomic_set(&ocfs2_control_opened, 0);
	401
	402	rc = misc_register(&ocfs2_control_device);
	403	if (rc)
	404	printk(KERN_ERR
	405	"ocfs2: Unable to register ocfs2_control device "
	406	"(errno %d)\n",
	407	-rc);
	408
	409	return rc;
	410	}
	411
	412	static void ocfs2_control_exit(void)
	413	{
	414	int rc;
	415
	416	rc = misc_deregister(&ocfs2_control_device);
	417	if (rc)
	418	printk(KERN_ERR
	419	"ocfs2: Unable to deregister ocfs2_control device "
	420	"(errno %d)\n",
	421	-rc);
	422	}
	423
	424	static int __init user_stack_init(void)
	425	{
	426	return ocfs2_control_init();
	427	}
	428
8adf0536 JB	429	static void __exit user_stack_exit(void)
8adf0536 JB	430	{
6427a727	431	ocfs2_control_exit();
8adf0536 JB	432	}
	433
	434	MODULE_AUTHOR("Oracle");
	435	MODULE_DESCRIPTION("ocfs2 driver for userspace cluster stacks");
	436	MODULE_LICENSE("GPL");
	437	module_init(user_stack_init);
	438	module_exit(user_stack_exit);