ocfs2: Start the ocfs2_control handshake.
[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 "stackglue.h"
28
29
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
38  * client writes the version they would like to use.  If the version tag
39  * written is unknown, -EINVAL is returned.  Once the negotiation is
40  * complete, the client can start sending messages.
41  */
42
43 /*
44  * Whether or not the client has done the handshake.
45  * For now, we have just one protocol version.
46  */
47 #define OCFS2_CONTROL_PROTO                     "T01\n"
48 #define OCFS2_CONTROL_PROTO_LEN                 4
49 #define OCFS2_CONTROL_HANDSHAKE_INVALID         (0)
50 #define OCFS2_CONTROL_HANDSHAKE_READ            (1)
51 #define OCFS2_CONTROL_HANDSHAKE_VALID           (2)
52
53 /*
54  * ocfs2_live_connection is refcounted because the filesystem and
55  * miscdevice sides can detach in different order.  Let's just be safe.
56  */
57 struct ocfs2_live_connection {
58         struct list_head                oc_list;
59         struct ocfs2_cluster_connection *oc_conn;
60 };
61
62 struct ocfs2_control_private {
63         struct list_head op_list;
64         int op_state;
65 };
66
67 static atomic_t ocfs2_control_opened;
68
69 static LIST_HEAD(ocfs2_live_connection_list);
70 static LIST_HEAD(ocfs2_control_private_list);
71 static DEFINE_MUTEX(ocfs2_control_lock);
72
73 static inline void ocfs2_control_set_handshake_state(struct file *file,
74                                                      int state)
75 {
76         struct ocfs2_control_private *p = file->private_data;
77         p->op_state = state;
78 }
79
80 static inline int ocfs2_control_get_handshake_state(struct file *file)
81 {
82         struct ocfs2_control_private *p = file->private_data;
83         return p->op_state;
84 }
85
86 static struct ocfs2_live_connection *ocfs2_connection_find(const char *name)
87 {
88         size_t len = strlen(name);
89         struct ocfs2_live_connection *c;
90
91         BUG_ON(!mutex_is_locked(&ocfs2_control_lock));
92
93         list_for_each_entry(c, &ocfs2_live_connection_list, oc_list) {
94                 if ((c->oc_conn->cc_namelen == len) &&
95                     !strncmp(c->oc_conn->cc_name, name, len))
96                         return c;
97         }
98
99         return c;
100 }
101
102 /*
103  * ocfs2_live_connection structures are created underneath the ocfs2
104  * mount path.  Since the VFS prevents multiple calls to
105  * fill_super(), we can't get dupes here.
106  */
107 static int ocfs2_live_connection_new(struct ocfs2_cluster_connection *conn,
108                                      struct ocfs2_live_connection **c_ret)
109 {
110         int rc = 0;
111         struct ocfs2_live_connection *c;
112
113         c = kzalloc(sizeof(struct ocfs2_live_connection), GFP_KERNEL);
114         if (!c)
115                 return -ENOMEM;
116
117         mutex_lock(&ocfs2_control_lock);
118         c->oc_conn = conn;
119
120         if (atomic_read(&ocfs2_control_opened))
121                 list_add(&c->oc_list, &ocfs2_live_connection_list);
122         else {
123                 printk(KERN_ERR
124                        "ocfs2: Userspace control daemon is not present\n");
125                 rc = -ESRCH;
126         }
127
128         mutex_unlock(&ocfs2_control_lock);
129
130         if (!rc)
131                 *c_ret = c;
132         else
133                 kfree(c);
134
135         return rc;
136 }
137
138 /*
139  * This function disconnects the cluster connection from ocfs2_control.
140  * Afterwards, userspace can't affect the cluster connection.
141  */
142 static void ocfs2_live_connection_drop(struct ocfs2_live_connection *c)
143 {
144         mutex_lock(&ocfs2_control_lock);
145         list_del_init(&c->oc_list);
146         c->oc_conn = NULL;
147         mutex_unlock(&ocfs2_control_lock);
148
149         kfree(c);
150 }
151
152 static ssize_t ocfs2_control_cfu(char *target, size_t target_len,
153                                  const char __user *buf, size_t count)
154 {
155         /* The T01 expects write(2) calls to have exactly one command */
156         if (count != target_len)
157                 return -EINVAL;
158
159         if (copy_from_user(target, buf, target_len))
160                 return -EFAULT;
161
162         return count;
163 }
164
165 static ssize_t ocfs2_control_validate_handshake(struct file *file,
166                                                 const char __user *buf,
167                                                 size_t count)
168 {
169         ssize_t ret;
170         char kbuf[OCFS2_CONTROL_PROTO_LEN];
171
172         ret = ocfs2_control_cfu(kbuf, OCFS2_CONTROL_PROTO_LEN,
173                                 buf, count);
174         if (ret != count)
175                 return ret;
176
177         if (strncmp(kbuf, OCFS2_CONTROL_PROTO, OCFS2_CONTROL_PROTO_LEN))
178                 return -EINVAL;
179
180         atomic_inc(&ocfs2_control_opened);
181         ocfs2_control_set_handshake_state(file,
182                                           OCFS2_CONTROL_HANDSHAKE_VALID);
183
184
185         return count;
186 }
187
188
189 static ssize_t ocfs2_control_write(struct file *file,
190                                    const char __user *buf,
191                                    size_t count,
192                                    loff_t *ppos)
193 {
194         ssize_t ret;
195
196         switch (ocfs2_control_get_handshake_state(file)) {
197                 case OCFS2_CONTROL_HANDSHAKE_INVALID:
198                         ret = -EINVAL;
199                         break;
200
201                 case OCFS2_CONTROL_HANDSHAKE_READ:
202                         ret = ocfs2_control_validate_handshake(file, buf,
203                                                                count);
204                         break;
205
206                 case OCFS2_CONTROL_HANDSHAKE_VALID:
207                         ret = count;  /* XXX */
208                         break;
209
210                 default:
211                         BUG();
212                         ret = -EIO;
213                         break;
214         }
215
216         return ret;
217 }
218
219 /*
220  * This is a naive version.  If we ever have a new protocol, we'll expand
221  * it.  Probably using seq_file.
222  */
223 static ssize_t ocfs2_control_read(struct file *file,
224                                   char __user *buf,
225                                   size_t count,
226                                   loff_t *ppos)
227 {
228         char *proto_string = OCFS2_CONTROL_PROTO;
229         size_t to_write = 0;
230
231         if (*ppos >= OCFS2_CONTROL_PROTO_LEN)
232                 return 0;
233
234         to_write = OCFS2_CONTROL_PROTO_LEN - *ppos;
235         if (to_write > count)
236                 to_write = count;
237         if (copy_to_user(buf, proto_string + *ppos, to_write))
238                 return -EFAULT;
239
240         *ppos += to_write;
241
242         /* Have we read the whole protocol list? */
243         if (*ppos >= OCFS2_CONTROL_PROTO_LEN)
244                 ocfs2_control_set_handshake_state(file,
245                                                   OCFS2_CONTROL_HANDSHAKE_READ);
246
247         return to_write;
248 }
249
250 static int ocfs2_control_release(struct inode *inode, struct file *file)
251 {
252         struct ocfs2_control_private *p = file->private_data;
253
254         mutex_lock(&ocfs2_control_lock);
255
256         if (ocfs2_control_get_handshake_state(file) !=
257             OCFS2_CONTROL_HANDSHAKE_VALID)
258                 goto out;
259
260         if (atomic_dec_and_test(&ocfs2_control_opened)) {
261                 if (!list_empty(&ocfs2_live_connection_list)) {
262                         /* XXX: Do bad things! */
263                         printk(KERN_ERR
264                                "ocfs2: Unexpected release of ocfs2_control!\n"
265                                "       Loss of cluster connection requires "
266                                "an emergency restart!\n");
267                         emergency_restart();
268                 }
269         }
270
271 out:
272         list_del_init(&p->op_list);
273         file->private_data = NULL;
274
275         mutex_unlock(&ocfs2_control_lock);
276
277         kfree(p);
278
279         return 0;
280 }
281
282 static int ocfs2_control_open(struct inode *inode, struct file *file)
283 {
284         struct ocfs2_control_private *p;
285
286         p = kzalloc(sizeof(struct ocfs2_control_private), GFP_KERNEL);
287         if (!p)
288                 return -ENOMEM;
289
290         mutex_lock(&ocfs2_control_lock);
291         file->private_data = p;
292         list_add(&p->op_list, &ocfs2_control_private_list);
293         mutex_unlock(&ocfs2_control_lock);
294
295         return 0;
296 }
297
298 static const struct file_operations ocfs2_control_fops = {
299         .open    = ocfs2_control_open,
300         .release = ocfs2_control_release,
301         .read    = ocfs2_control_read,
302         .write   = ocfs2_control_write,
303         .owner   = THIS_MODULE,
304 };
305
306 struct miscdevice ocfs2_control_device = {
307         .minor          = MISC_DYNAMIC_MINOR,
308         .name           = "ocfs2_control",
309         .fops           = &ocfs2_control_fops,
310 };
311
312 static int ocfs2_control_init(void)
313 {
314         int rc;
315
316         atomic_set(&ocfs2_control_opened, 0);
317
318         rc = misc_register(&ocfs2_control_device);
319         if (rc)
320                 printk(KERN_ERR
321                        "ocfs2: Unable to register ocfs2_control device "
322                        "(errno %d)\n",
323                        -rc);
324
325         return rc;
326 }
327
328 static void ocfs2_control_exit(void)
329 {
330         int rc;
331
332         rc = misc_deregister(&ocfs2_control_device);
333         if (rc)
334                 printk(KERN_ERR
335                        "ocfs2: Unable to deregister ocfs2_control device "
336                        "(errno %d)\n",
337                        -rc);
338 }
339
340 static int __init user_stack_init(void)
341 {
342         return ocfs2_control_init();
343 }
344
345 static void __exit user_stack_exit(void)
346 {
347         ocfs2_control_exit();
348 }
349
350 MODULE_AUTHOR("Oracle");
351 MODULE_DESCRIPTION("ocfs2 driver for userspace cluster stacks");
352 MODULE_LICENSE("GPL");
353 module_init(user_stack_init);
354 module_exit(user_stack_exit);