1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85#define OCFS2_CONTROL_PROTO "T01\n"
86#define OCFS2_CONTROL_PROTO_LEN 4
87
88
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
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
108
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
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
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
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
198
199
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
234
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
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
300
301
302
303
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
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
427
428
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
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
546
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
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
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
587
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
672
673
674
675
676
677
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
756
757
758
759
760
761
762
763
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
781
782
783
784
785
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
816
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, NULL, DLM_LSFL_FS, DLM_LVB_LEN,
831 NULL, NULL, NULL, &fsdlm);
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);
909