PageRenderTime 31ms CodeModel.GetById 3ms app.highlight 24ms RepoModel.GetById 1ms app.codeStats 0ms

/fs/ocfs2/stack_user.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 908 lines | 610 code | 153 blank | 145 comment | 118 complexity | 6da550a4e08933d6c4161e7d4d739cad MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
  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>
 21#include <linux/fs.h>
 22#include <linux/miscdevice.h>
 23#include <linux/mutex.h>
 24#include <linux/slab.h>
 25#include <linux/reboot.h>
 26#include <asm/uaccess.h>
 27
 28#include "stackglue.h"
 29
 30#include <linux/dlm_plock.h>
 31
 32/*
 33 * The control protocol starts with a handshake.  Until the handshake
 34 * is complete, the control device will fail all write(2)s.
 35 *
 36 * The handshake is simple.  First, the client reads until EOF.  Each line
 37 * of output is a supported protocol tag.  All protocol tags are a single
 38 * character followed by a two hex digit version number.  Currently the
 39 * only things supported is T01, for "Text-base version 0x01".  Next, the
 40 * client writes the version they would like to use, including the newline.
 41 * Thus, the protocol tag is 'T01\n'.  If the version tag written is
 42 * unknown, -EINVAL is returned.  Once the negotiation is complete, the
 43 * client can start sending messages.
 44 *
 45 * The T01 protocol has three messages.  First is the "SETN" message.
 46 * It has the following syntax:
 47 *
 48 *  SETN<space><8-char-hex-nodenum><newline>
 49 *
 50 * This is 14 characters.
 51 *
 52 * The "SETN" message must be the first message following the protocol.
 53 * It tells ocfs2_control the local node number.
 54 *
 55 * Next comes the "SETV" message.  It has the following syntax:
 56 *
 57 *  SETV<space><2-char-hex-major><space><2-char-hex-minor><newline>
 58 *
 59 * This is 11 characters.
 60 *
 61 * The "SETV" message sets the filesystem locking protocol version as
 62 * negotiated by the client.  The client negotiates based on the maximum
 63 * version advertised in /sys/fs/ocfs2/max_locking_protocol.  The major
 64 * number from the "SETV" message must match
 65 * ocfs2_user_plugin.sp_max_proto.pv_major, and the minor number
 66 * must be less than or equal to ...sp_max_version.pv_minor.
 67 *
 68 * Once this information has been set, mounts will be allowed.  From this
 69 * point on, the "DOWN" message can be sent for node down notification.
 70 * It has the following syntax:
 71 *
 72 *  DOWN<space><32-char-cap-hex-uuid><space><8-char-hex-nodenum><newline>
 73 *
 74 * eg:
 75 *
 76 *  DOWN 632A924FDD844190BDA93C0DF6B94899 00000001\n
 77 *
 78 * This is 47 characters.
 79 */
 80
 81/*
 82 * Whether or not the client has done the handshake.
 83 * For now, we have just one protocol version.
 84 */
 85#define OCFS2_CONTROL_PROTO			"T01\n"
 86#define OCFS2_CONTROL_PROTO_LEN			4
 87
 88/* Handshake states */
 89#define OCFS2_CONTROL_HANDSHAKE_INVALID		(0)
 90#define OCFS2_CONTROL_HANDSHAKE_READ		(1)
 91#define OCFS2_CONTROL_HANDSHAKE_PROTOCOL	(2)
 92#define OCFS2_CONTROL_HANDSHAKE_VALID		(3)
 93
 94/* Messages */
 95#define OCFS2_CONTROL_MESSAGE_OP_LEN		4
 96#define OCFS2_CONTROL_MESSAGE_SETNODE_OP	"SETN"
 97#define OCFS2_CONTROL_MESSAGE_SETNODE_TOTAL_LEN	14
 98#define OCFS2_CONTROL_MESSAGE_SETVERSION_OP	"SETV"
 99#define OCFS2_CONTROL_MESSAGE_SETVERSION_TOTAL_LEN	11
100#define OCFS2_CONTROL_MESSAGE_DOWN_OP		"DOWN"
101#define OCFS2_CONTROL_MESSAGE_DOWN_TOTAL_LEN	47
102#define OCFS2_TEXT_UUID_LEN			32
103#define OCFS2_CONTROL_MESSAGE_VERNUM_LEN	2
104#define OCFS2_CONTROL_MESSAGE_NODENUM_LEN	8
105
106/*
107 * ocfs2_live_connection is refcounted because the filesystem and
108 * miscdevice sides can detach in different order.  Let's just be safe.
109 */
110struct ocfs2_live_connection {
111	struct list_head		oc_list;
112	struct ocfs2_cluster_connection	*oc_conn;
113};
114
115struct ocfs2_control_private {
116	struct list_head op_list;
117	int op_state;
118	int op_this_node;
119	struct ocfs2_protocol_version op_proto;
120};
121
122/* SETN<space><8-char-hex-nodenum><newline> */
123struct ocfs2_control_message_setn {
124	char	tag[OCFS2_CONTROL_MESSAGE_OP_LEN];
125	char	space;
126	char	nodestr[OCFS2_CONTROL_MESSAGE_NODENUM_LEN];
127	char	newline;
128};
129
130/* SETV<space><2-char-hex-major><space><2-char-hex-minor><newline> */
131struct ocfs2_control_message_setv {
132	char	tag[OCFS2_CONTROL_MESSAGE_OP_LEN];
133	char	space1;
134	char	major[OCFS2_CONTROL_MESSAGE_VERNUM_LEN];
135	char	space2;
136	char	minor[OCFS2_CONTROL_MESSAGE_VERNUM_LEN];
137	char	newline;
138};
139
140/* DOWN<space><32-char-cap-hex-uuid><space><8-char-hex-nodenum><newline> */
141struct ocfs2_control_message_down {
142	char	tag[OCFS2_CONTROL_MESSAGE_OP_LEN];
143	char	space1;
144	char	uuid[OCFS2_TEXT_UUID_LEN];
145	char	space2;
146	char	nodestr[OCFS2_CONTROL_MESSAGE_NODENUM_LEN];
147	char	newline;
148};
149
150union ocfs2_control_message {
151	char					tag[OCFS2_CONTROL_MESSAGE_OP_LEN];
152	struct ocfs2_control_message_setn	u_setn;
153	struct ocfs2_control_message_setv	u_setv;
154	struct ocfs2_control_message_down	u_down;
155};
156
157static struct ocfs2_stack_plugin ocfs2_user_plugin;
158
159static atomic_t ocfs2_control_opened;
160static int ocfs2_control_this_node = -1;
161static struct ocfs2_protocol_version running_proto;
162
163static LIST_HEAD(ocfs2_live_connection_list);
164static LIST_HEAD(ocfs2_control_private_list);
165static DEFINE_MUTEX(ocfs2_control_lock);
166
167static inline void ocfs2_control_set_handshake_state(struct file *file,
168						     int state)
169{
170	struct ocfs2_control_private *p = file->private_data;
171	p->op_state = state;
172}
173
174static inline int ocfs2_control_get_handshake_state(struct file *file)
175{
176	struct ocfs2_control_private *p = file->private_data;
177	return p->op_state;
178}
179
180static struct ocfs2_live_connection *ocfs2_connection_find(const char *name)
181{
182	size_t len = strlen(name);
183	struct ocfs2_live_connection *c;
184
185	BUG_ON(!mutex_is_locked(&ocfs2_control_lock));
186
187	list_for_each_entry(c, &ocfs2_live_connection_list, oc_list) {
188		if ((c->oc_conn->cc_namelen == len) &&
189		    !strncmp(c->oc_conn->cc_name, name, len))
190			return c;
191	}
192
193	return NULL;
194}
195
196/*
197 * ocfs2_live_connection structures are created underneath the ocfs2
198 * mount path.  Since the VFS prevents multiple calls to
199 * fill_super(), we can't get dupes here.
200 */
201static int ocfs2_live_connection_new(struct ocfs2_cluster_connection *conn,
202				     struct ocfs2_live_connection **c_ret)
203{
204	int rc = 0;
205	struct ocfs2_live_connection *c;
206
207	c = kzalloc(sizeof(struct ocfs2_live_connection), GFP_KERNEL);
208	if (!c)
209		return -ENOMEM;
210
211	mutex_lock(&ocfs2_control_lock);
212	c->oc_conn = conn;
213
214	if (atomic_read(&ocfs2_control_opened))
215		list_add(&c->oc_list, &ocfs2_live_connection_list);
216	else {
217		printk(KERN_ERR
218		       "ocfs2: Userspace control daemon is not present\n");
219		rc = -ESRCH;
220	}
221
222	mutex_unlock(&ocfs2_control_lock);
223
224	if (!rc)
225		*c_ret = c;
226	else
227		kfree(c);
228
229	return rc;
230}
231
232/*
233 * This function disconnects the cluster connection from ocfs2_control.
234 * Afterwards, userspace can't affect the cluster connection.
235 */
236static void ocfs2_live_connection_drop(struct ocfs2_live_connection *c)
237{
238	mutex_lock(&ocfs2_control_lock);
239	list_del_init(&c->oc_list);
240	c->oc_conn = NULL;
241	mutex_unlock(&ocfs2_control_lock);
242
243	kfree(c);
244}
245
246static int ocfs2_control_cfu(void *target, size_t target_len,
247			     const char __user *buf, size_t count)
248{
249	/* The T01 expects write(2) calls to have exactly one command */
250	if ((count != target_len) ||
251	    (count > sizeof(union ocfs2_control_message)))
252		return -EINVAL;
253
254	if (copy_from_user(target, buf, target_len))
255		return -EFAULT;
256
257	return 0;
258}
259
260static ssize_t ocfs2_control_validate_protocol(struct file *file,
261					       const char __user *buf,
262					       size_t count)
263{
264	ssize_t ret;
265	char kbuf[OCFS2_CONTROL_PROTO_LEN];
266
267	ret = ocfs2_control_cfu(kbuf, OCFS2_CONTROL_PROTO_LEN,
268				buf, count);
269	if (ret)
270		return ret;
271
272	if (strncmp(kbuf, OCFS2_CONTROL_PROTO, OCFS2_CONTROL_PROTO_LEN))
273		return -EINVAL;
274
275	ocfs2_control_set_handshake_state(file,
276					  OCFS2_CONTROL_HANDSHAKE_PROTOCOL);
277
278	return count;
279}
280
281static void ocfs2_control_send_down(const char *uuid,
282				    int nodenum)
283{
284	struct ocfs2_live_connection *c;
285
286	mutex_lock(&ocfs2_control_lock);
287
288	c = ocfs2_connection_find(uuid);
289	if (c) {
290		BUG_ON(c->oc_conn == NULL);
291		c->oc_conn->cc_recovery_handler(nodenum,
292						c->oc_conn->cc_recovery_data);
293	}
294
295	mutex_unlock(&ocfs2_control_lock);
296}
297
298/*
299 * Called whenever configuration elements are sent to /dev/ocfs2_control.
300 * If all configuration elements are present, try to set the global
301 * values.  If there is a problem, return an error.  Skip any missing
302 * elements, and only bump ocfs2_control_opened when we have all elements
303 * and are successful.
304 */
305static int ocfs2_control_install_private(struct file *file)
306{
307	int rc = 0;
308	int set_p = 1;
309	struct ocfs2_control_private *p = file->private_data;
310
311	BUG_ON(p->op_state != OCFS2_CONTROL_HANDSHAKE_PROTOCOL);
312
313	mutex_lock(&ocfs2_control_lock);
314
315	if (p->op_this_node < 0) {
316		set_p = 0;
317	} else if ((ocfs2_control_this_node >= 0) &&
318		   (ocfs2_control_this_node != p->op_this_node)) {
319		rc = -EINVAL;
320		goto out_unlock;
321	}
322
323	if (!p->op_proto.pv_major) {
324		set_p = 0;
325	} else if (!list_empty(&ocfs2_live_connection_list) &&
326		   ((running_proto.pv_major != p->op_proto.pv_major) ||
327		    (running_proto.pv_minor != p->op_proto.pv_minor))) {
328		rc = -EINVAL;
329		goto out_unlock;
330	}
331
332	if (set_p) {
333		ocfs2_control_this_node = p->op_this_node;
334		running_proto.pv_major = p->op_proto.pv_major;
335		running_proto.pv_minor = p->op_proto.pv_minor;
336	}
337
338out_unlock:
339	mutex_unlock(&ocfs2_control_lock);
340
341	if (!rc && set_p) {
342		/* We set the global values successfully */
343		atomic_inc(&ocfs2_control_opened);
344		ocfs2_control_set_handshake_state(file,
345					OCFS2_CONTROL_HANDSHAKE_VALID);
346	}
347
348	return rc;
349}
350
351static int ocfs2_control_get_this_node(void)
352{
353	int rc;
354
355	mutex_lock(&ocfs2_control_lock);
356	if (ocfs2_control_this_node < 0)
357		rc = -EINVAL;
358	else
359		rc = ocfs2_control_this_node;
360	mutex_unlock(&ocfs2_control_lock);
361
362	return rc;
363}
364
365static int ocfs2_control_do_setnode_msg(struct file *file,
366					struct ocfs2_control_message_setn *msg)
367{
368	long nodenum;
369	char *ptr = NULL;
370	struct ocfs2_control_private *p = file->private_data;
371
372	if (ocfs2_control_get_handshake_state(file) !=
373	    OCFS2_CONTROL_HANDSHAKE_PROTOCOL)
374		return -EINVAL;
375
376	if (strncmp(msg->tag, OCFS2_CONTROL_MESSAGE_SETNODE_OP,
377		    OCFS2_CONTROL_MESSAGE_OP_LEN))
378		return -EINVAL;
379
380	if ((msg->space != ' ') || (msg->newline != '\n'))
381		return -EINVAL;
382	msg->space = msg->newline = '\0';
383
384	nodenum = simple_strtol(msg->nodestr, &ptr, 16);
385	if (!ptr || *ptr)
386		return -EINVAL;
387
388	if ((nodenum == LONG_MIN) || (nodenum == LONG_MAX) ||
389	    (nodenum > INT_MAX) || (nodenum < 0))
390		return -ERANGE;
391	p->op_this_node = nodenum;
392
393	return ocfs2_control_install_private(file);
394}
395
396static int ocfs2_control_do_setversion_msg(struct file *file,
397					   struct ocfs2_control_message_setv *msg)
398 {
399	long major, minor;
400	char *ptr = NULL;
401	struct ocfs2_control_private *p = file->private_data;
402	struct ocfs2_protocol_version *max =
403		&ocfs2_user_plugin.sp_max_proto;
404
405	if (ocfs2_control_get_handshake_state(file) !=
406	    OCFS2_CONTROL_HANDSHAKE_PROTOCOL)
407		return -EINVAL;
408
409	if (strncmp(msg->tag, OCFS2_CONTROL_MESSAGE_SETVERSION_OP,
410		    OCFS2_CONTROL_MESSAGE_OP_LEN))
411		return -EINVAL;
412
413	if ((msg->space1 != ' ') || (msg->space2 != ' ') ||
414	    (msg->newline != '\n'))
415		return -EINVAL;
416	msg->space1 = msg->space2 = msg->newline = '\0';
417
418	major = simple_strtol(msg->major, &ptr, 16);
419	if (!ptr || *ptr)
420		return -EINVAL;
421	minor = simple_strtol(msg->minor, &ptr, 16);
422	if (!ptr || *ptr)
423		return -EINVAL;
424
425	/*
426	 * The major must be between 1 and 255, inclusive.  The minor
427	 * must be between 0 and 255, inclusive.  The version passed in
428	 * must be within the maximum version supported by the filesystem.
429	 */
430	if ((major == LONG_MIN) || (major == LONG_MAX) ||
431	    (major > (u8)-1) || (major < 1))
432		return -ERANGE;
433	if ((minor == LONG_MIN) || (minor == LONG_MAX) ||
434	    (minor > (u8)-1) || (minor < 0))
435		return -ERANGE;
436	if ((major != max->pv_major) ||
437	    (minor > max->pv_minor))
438		return -EINVAL;
439
440	p->op_proto.pv_major = major;
441	p->op_proto.pv_minor = minor;
442
443	return ocfs2_control_install_private(file);
444}
445
446static int ocfs2_control_do_down_msg(struct file *file,
447				     struct ocfs2_control_message_down *msg)
448{
449	long nodenum;
450	char *p = NULL;
451
452	if (ocfs2_control_get_handshake_state(file) !=
453	    OCFS2_CONTROL_HANDSHAKE_VALID)
454		return -EINVAL;
455
456	if (strncmp(msg->tag, OCFS2_CONTROL_MESSAGE_DOWN_OP,
457		    OCFS2_CONTROL_MESSAGE_OP_LEN))
458		return -EINVAL;
459
460	if ((msg->space1 != ' ') || (msg->space2 != ' ') ||
461	    (msg->newline != '\n'))
462		return -EINVAL;
463	msg->space1 = msg->space2 = msg->newline = '\0';
464
465	nodenum = simple_strtol(msg->nodestr, &p, 16);
466	if (!p || *p)
467		return -EINVAL;
468
469	if ((nodenum == LONG_MIN) || (nodenum == LONG_MAX) ||
470	    (nodenum > INT_MAX) || (nodenum < 0))
471		return -ERANGE;
472
473	ocfs2_control_send_down(msg->uuid, nodenum);
474
475	return 0;
476}
477
478static ssize_t ocfs2_control_message(struct file *file,
479				     const char __user *buf,
480				     size_t count)
481{
482	ssize_t ret;
483	union ocfs2_control_message msg;
484
485	/* Try to catch padding issues */
486	WARN_ON(offsetof(struct ocfs2_control_message_down, uuid) !=
487		(sizeof(msg.u_down.tag) + sizeof(msg.u_down.space1)));
488
489	memset(&msg, 0, sizeof(union ocfs2_control_message));
490	ret = ocfs2_control_cfu(&msg, count, buf, count);
491	if (ret)
492		goto out;
493
494	if ((count == OCFS2_CONTROL_MESSAGE_SETNODE_TOTAL_LEN) &&
495	    !strncmp(msg.tag, OCFS2_CONTROL_MESSAGE_SETNODE_OP,
496		     OCFS2_CONTROL_MESSAGE_OP_LEN))
497		ret = ocfs2_control_do_setnode_msg(file, &msg.u_setn);
498	else if ((count == OCFS2_CONTROL_MESSAGE_SETVERSION_TOTAL_LEN) &&
499		 !strncmp(msg.tag, OCFS2_CONTROL_MESSAGE_SETVERSION_OP,
500			  OCFS2_CONTROL_MESSAGE_OP_LEN))
501		ret = ocfs2_control_do_setversion_msg(file, &msg.u_setv);
502	else if ((count == OCFS2_CONTROL_MESSAGE_DOWN_TOTAL_LEN) &&
503		 !strncmp(msg.tag, OCFS2_CONTROL_MESSAGE_DOWN_OP,
504			  OCFS2_CONTROL_MESSAGE_OP_LEN))
505		ret = ocfs2_control_do_down_msg(file, &msg.u_down);
506	else
507		ret = -EINVAL;
508
509out:
510	return ret ? ret : count;
511}
512
513static ssize_t ocfs2_control_write(struct file *file,
514				   const char __user *buf,
515				   size_t count,
516				   loff_t *ppos)
517{
518	ssize_t ret;
519
520	switch (ocfs2_control_get_handshake_state(file)) {
521		case OCFS2_CONTROL_HANDSHAKE_INVALID:
522			ret = -EINVAL;
523			break;
524
525		case OCFS2_CONTROL_HANDSHAKE_READ:
526			ret = ocfs2_control_validate_protocol(file, buf,
527							      count);
528			break;
529
530		case OCFS2_CONTROL_HANDSHAKE_PROTOCOL:
531		case OCFS2_CONTROL_HANDSHAKE_VALID:
532			ret = ocfs2_control_message(file, buf, count);
533			break;
534
535		default:
536			BUG();
537			ret = -EIO;
538			break;
539	}
540
541	return ret;
542}
543
544/*
545 * This is a naive version.  If we ever have a new protocol, we'll expand
546 * it.  Probably using seq_file.
547 */
548static ssize_t ocfs2_control_read(struct file *file,
549				  char __user *buf,
550				  size_t count,
551				  loff_t *ppos)
552{
553	ssize_t ret;
554
555	ret = simple_read_from_buffer(buf, count, ppos,
556			OCFS2_CONTROL_PROTO, OCFS2_CONTROL_PROTO_LEN);
557
558	/* Have we read the whole protocol list? */
559	if (ret > 0 && *ppos >= OCFS2_CONTROL_PROTO_LEN)
560		ocfs2_control_set_handshake_state(file,
561						  OCFS2_CONTROL_HANDSHAKE_READ);
562
563	return ret;
564}
565
566static int ocfs2_control_release(struct inode *inode, struct file *file)
567{
568	struct ocfs2_control_private *p = file->private_data;
569
570	mutex_lock(&ocfs2_control_lock);
571
572	if (ocfs2_control_get_handshake_state(file) !=
573	    OCFS2_CONTROL_HANDSHAKE_VALID)
574		goto out;
575
576	if (atomic_dec_and_test(&ocfs2_control_opened)) {
577		if (!list_empty(&ocfs2_live_connection_list)) {
578			/* XXX: Do bad things! */
579			printk(KERN_ERR
580			       "ocfs2: Unexpected release of ocfs2_control!\n"
581			       "       Loss of cluster connection requires "
582			       "an emergency restart!\n");
583			emergency_restart();
584		}
585		/*
586		 * Last valid close clears the node number and resets
587		 * the locking protocol version
588		 */
589		ocfs2_control_this_node = -1;
590		running_proto.pv_major = 0;
591		running_proto.pv_major = 0;
592	}
593
594out:
595	list_del_init(&p->op_list);
596	file->private_data = NULL;
597
598	mutex_unlock(&ocfs2_control_lock);
599
600	kfree(p);
601
602	return 0;
603}
604
605static int ocfs2_control_open(struct inode *inode, struct file *file)
606{
607	struct ocfs2_control_private *p;
608
609	p = kzalloc(sizeof(struct ocfs2_control_private), GFP_KERNEL);
610	if (!p)
611		return -ENOMEM;
612	p->op_this_node = -1;
613
614	mutex_lock(&ocfs2_control_lock);
615	file->private_data = p;
616	list_add(&p->op_list, &ocfs2_control_private_list);
617	mutex_unlock(&ocfs2_control_lock);
618
619	return 0;
620}
621
622static const struct file_operations ocfs2_control_fops = {
623	.open    = ocfs2_control_open,
624	.release = ocfs2_control_release,
625	.read    = ocfs2_control_read,
626	.write   = ocfs2_control_write,
627	.owner   = THIS_MODULE,
628	.llseek  = default_llseek,
629};
630
631static struct miscdevice ocfs2_control_device = {
632	.minor		= MISC_DYNAMIC_MINOR,
633	.name		= "ocfs2_control",
634	.fops		= &ocfs2_control_fops,
635};
636
637static int ocfs2_control_init(void)
638{
639	int rc;
640
641	atomic_set(&ocfs2_control_opened, 0);
642
643	rc = misc_register(&ocfs2_control_device);
644	if (rc)
645		printk(KERN_ERR
646		       "ocfs2: Unable to register ocfs2_control device "
647		       "(errno %d)\n",
648		       -rc);
649
650	return rc;
651}
652
653static void ocfs2_control_exit(void)
654{
655	int rc;
656
657	rc = misc_deregister(&ocfs2_control_device);
658	if (rc)
659		printk(KERN_ERR
660		       "ocfs2: Unable to deregister ocfs2_control device "
661		       "(errno %d)\n",
662		       -rc);
663}
664
665static void fsdlm_lock_ast_wrapper(void *astarg)
666{
667	struct ocfs2_dlm_lksb *lksb = astarg;
668	int status = lksb->lksb_fsdlm.sb_status;
669
670	/*
671	 * For now we're punting on the issue of other non-standard errors
672	 * where we can't tell if the unlock_ast or lock_ast should be called.
673	 * The main "other error" that's possible is EINVAL which means the
674	 * function was called with invalid args, which shouldn't be possible
675	 * since the caller here is under our control.  Other non-standard
676	 * errors probably fall into the same category, or otherwise are fatal
677	 * which means we can't carry on anyway.
678	 */
679
680	if (status == -DLM_EUNLOCK || status == -DLM_ECANCEL)
681		lksb->lksb_conn->cc_proto->lp_unlock_ast(lksb, 0);
682	else
683		lksb->lksb_conn->cc_proto->lp_lock_ast(lksb);
684}
685
686static void fsdlm_blocking_ast_wrapper(void *astarg, int level)
687{
688	struct ocfs2_dlm_lksb *lksb = astarg;
689
690	lksb->lksb_conn->cc_proto->lp_blocking_ast(lksb, level);
691}
692
693static int user_dlm_lock(struct ocfs2_cluster_connection *conn,
694			 int mode,
695			 struct ocfs2_dlm_lksb *lksb,
696			 u32 flags,
697			 void *name,
698			 unsigned int namelen)
699{
700	int ret;
701
702	if (!lksb->lksb_fsdlm.sb_lvbptr)
703		lksb->lksb_fsdlm.sb_lvbptr = (char *)lksb +
704					     sizeof(struct dlm_lksb);
705
706	ret = dlm_lock(conn->cc_lockspace, mode, &lksb->lksb_fsdlm,
707		       flags|DLM_LKF_NODLCKWT, name, namelen, 0,
708		       fsdlm_lock_ast_wrapper, lksb,
709		       fsdlm_blocking_ast_wrapper);
710	return ret;
711}
712
713static int user_dlm_unlock(struct ocfs2_cluster_connection *conn,
714			   struct ocfs2_dlm_lksb *lksb,
715			   u32 flags)
716{
717	int ret;
718
719	ret = dlm_unlock(conn->cc_lockspace, lksb->lksb_fsdlm.sb_lkid,
720			 flags, &lksb->lksb_fsdlm, lksb);
721	return ret;
722}
723
724static int user_dlm_lock_status(struct ocfs2_dlm_lksb *lksb)
725{
726	return lksb->lksb_fsdlm.sb_status;
727}
728
729static int user_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb)
730{
731	int invalid = lksb->lksb_fsdlm.sb_flags & DLM_SBF_VALNOTVALID;
732
733	return !invalid;
734}
735
736static void *user_dlm_lvb(struct ocfs2_dlm_lksb *lksb)
737{
738	if (!lksb->lksb_fsdlm.sb_lvbptr)
739		lksb->lksb_fsdlm.sb_lvbptr = (char *)lksb +
740					     sizeof(struct dlm_lksb);
741	return (void *)(lksb->lksb_fsdlm.sb_lvbptr);
742}
743
744static void user_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb)
745{
746}
747
748static int user_plock(struct ocfs2_cluster_connection *conn,
749		      u64 ino,
750		      struct file *file,
751		      int cmd,
752		      struct file_lock *fl)
753{
754	/*
755	 * This more or less just demuxes the plock request into any
756	 * one of three dlm calls.
757	 *
758	 * Internally, fs/dlm will pass these to a misc device, which
759	 * a userspace daemon will read and write to.
760	 *
761	 * For now, cancel requests (which happen internally only),
762	 * are turned into unlocks. Most of this function taken from
763	 * gfs2_lock.
764	 */
765
766	if (cmd == F_CANCELLK) {
767		cmd = F_SETLK;
768		fl->fl_type = F_UNLCK;
769	}
770
771	if (IS_GETLK(cmd))
772		return dlm_posix_get(conn->cc_lockspace, ino, file, fl);
773	else if (fl->fl_type == F_UNLCK)
774		return dlm_posix_unlock(conn->cc_lockspace, ino, file, fl);
775	else
776		return dlm_posix_lock(conn->cc_lockspace, ino, file, cmd, fl);
777}
778
779/*
780 * Compare a requested locking protocol version against the current one.
781 *
782 * If the major numbers are different, they are incompatible.
783 * If the current minor is greater than the request, they are incompatible.
784 * If the current minor is less than or equal to the request, they are
785 * compatible, and the requester should run at the current minor version.
786 */
787static int fs_protocol_compare(struct ocfs2_protocol_version *existing,
788			       struct ocfs2_protocol_version *request)
789{
790	if (existing->pv_major != request->pv_major)
791		return 1;
792
793	if (existing->pv_minor > request->pv_minor)
794		return 1;
795
796	if (existing->pv_minor < request->pv_minor)
797		request->pv_minor = existing->pv_minor;
798
799	return 0;
800}
801
802static int user_cluster_connect(struct ocfs2_cluster_connection *conn)
803{
804	dlm_lockspace_t *fsdlm;
805	struct ocfs2_live_connection *uninitialized_var(control);
806	int rc = 0;
807
808	BUG_ON(conn == NULL);
809
810	rc = ocfs2_live_connection_new(conn, &control);
811	if (rc)
812		goto out;
813
814	/*
815	 * running_proto must have been set before we allowed any mounts
816	 * to proceed.
817	 */
818	if (fs_protocol_compare(&running_proto, &conn->cc_version)) {
819		printk(KERN_ERR
820		       "Unable to mount with fs locking protocol version "
821		       "%u.%u because the userspace control daemon has "
822		       "negotiated %u.%u\n",
823		       conn->cc_version.pv_major, conn->cc_version.pv_minor,
824		       running_proto.pv_major, running_proto.pv_minor);
825		rc = -EPROTO;
826		ocfs2_live_connection_drop(control);
827		goto out;
828	}
829
830	rc = dlm_new_lockspace(conn->cc_name, strlen(conn->cc_name),
831			       &fsdlm, DLM_LSFL_FS, DLM_LVB_LEN);
832	if (rc) {
833		ocfs2_live_connection_drop(control);
834		goto out;
835	}
836
837	conn->cc_private = control;
838	conn->cc_lockspace = fsdlm;
839out:
840	return rc;
841}
842
843static int user_cluster_disconnect(struct ocfs2_cluster_connection *conn)
844{
845	dlm_release_lockspace(conn->cc_lockspace, 2);
846	conn->cc_lockspace = NULL;
847	ocfs2_live_connection_drop(conn->cc_private);
848	conn->cc_private = NULL;
849	return 0;
850}
851
852static int user_cluster_this_node(unsigned int *this_node)
853{
854	int rc;
855
856	rc = ocfs2_control_get_this_node();
857	if (rc < 0)
858		return rc;
859
860	*this_node = rc;
861	return 0;
862}
863
864static struct ocfs2_stack_operations ocfs2_user_plugin_ops = {
865	.connect	= user_cluster_connect,
866	.disconnect	= user_cluster_disconnect,
867	.this_node	= user_cluster_this_node,
868	.dlm_lock	= user_dlm_lock,
869	.dlm_unlock	= user_dlm_unlock,
870	.lock_status	= user_dlm_lock_status,
871	.lvb_valid	= user_dlm_lvb_valid,
872	.lock_lvb	= user_dlm_lvb,
873	.plock		= user_plock,
874	.dump_lksb	= user_dlm_dump_lksb,
875};
876
877static struct ocfs2_stack_plugin ocfs2_user_plugin = {
878	.sp_name	= "user",
879	.sp_ops		= &ocfs2_user_plugin_ops,
880	.sp_owner	= THIS_MODULE,
881};
882
883
884static int __init ocfs2_user_plugin_init(void)
885{
886	int rc;
887
888	rc = ocfs2_control_init();
889	if (!rc) {
890		rc = ocfs2_stack_glue_register(&ocfs2_user_plugin);
891		if (rc)
892			ocfs2_control_exit();
893	}
894
895	return rc;
896}
897
898static void __exit ocfs2_user_plugin_exit(void)
899{
900	ocfs2_stack_glue_unregister(&ocfs2_user_plugin);
901	ocfs2_control_exit();
902}
903
904MODULE_AUTHOR("Oracle");
905MODULE_DESCRIPTION("ocfs2 driver for userspace cluster stacks");
906MODULE_LICENSE("GPL");
907module_init(ocfs2_user_plugin_init);
908module_exit(ocfs2_user_plugin_exit);