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