blob: 31276bac78f5e813e34c4453efad7ebb3565356b [file] [log] [blame]
Joel Becker8adf0532007-11-28 14:38:40 -08001/* -*- 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>
Joel Becker6427a722008-02-18 19:23:28 -080021#include <linux/fs.h>
22#include <linux/miscdevice.h>
23#include <linux/mutex.h>
Arnd Bergmannb7fdf9f2008-05-20 19:16:28 +020024#include <linux/smp_lock.h>
Joel Becker6427a722008-02-18 19:23:28 -080025#include <linux/reboot.h>
Joel Becker462c7e62008-02-18 19:40:12 -080026#include <asm/uaccess.h>
Joel Becker8adf0532007-11-28 14:38:40 -080027
28#include "stackglue.h"
29
Mark Fasheh53da4932008-07-21 14:29:16 -070030#include <linux/dlm_plock.h>
Joel Becker8adf0532007-11-28 14:38:40 -080031
Joel Becker6427a722008-02-18 19:23:28 -080032/*
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
Joel Beckerde870ef2008-02-18 17:07:09 -080040 * 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 *
Joel Beckerd4b95ee2008-02-20 15:39:44 -080045 * The T01 protocol has three messages. First is the "SETN" message.
Joel Becker3cfd4ab2008-02-20 14:44:34 -080046 * 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 *
Joel Beckerd4b95ee2008-02-20 15:39:44 -080055 * 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
Joel Beckera12630b2008-05-09 18:49:29 -070065 * ocfs2_user_plugin.sp_proto->lp_max_version.pv_major, and the minor number
Joel Beckerd4b95ee2008-02-20 15:39:44 -080066 * must be less than or equal to ...->lp_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:
Joel Beckerde870ef2008-02-18 17:07:09 -080071 *
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.
Joel Becker6427a722008-02-18 19:23:28 -080079 */
80
81/*
Joel Becker462c7e62008-02-18 19:40:12 -080082 * 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
Joel Becker3cfd4ab2008-02-20 14:44:34 -080087
88/* Handshake states */
Joel Becker462c7e62008-02-18 19:40:12 -080089#define OCFS2_CONTROL_HANDSHAKE_INVALID (0)
90#define OCFS2_CONTROL_HANDSHAKE_READ (1)
Joel Becker3cfd4ab2008-02-20 14:44:34 -080091#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
Joel Beckerd4b95ee2008-02-20 15:39:44 -080098#define OCFS2_CONTROL_MESSAGE_SETVERSION_OP "SETV"
99#define OCFS2_CONTROL_MESSAGE_SETVERSION_TOTAL_LEN 11
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800100#define OCFS2_CONTROL_MESSAGE_DOWN_OP "DOWN"
Joel Beckerde870ef2008-02-18 17:07:09 -0800101#define OCFS2_CONTROL_MESSAGE_DOWN_TOTAL_LEN 47
102#define OCFS2_TEXT_UUID_LEN 32
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800103#define OCFS2_CONTROL_MESSAGE_VERNUM_LEN 2
Joel Beckerde870ef2008-02-18 17:07:09 -0800104#define OCFS2_CONTROL_MESSAGE_NODENUM_LEN 8
Joel Becker462c7e62008-02-18 19:40:12 -0800105
106/*
Joel Becker6427a722008-02-18 19:23:28 -0800107 * 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
Joel Becker462c7e62008-02-18 19:40:12 -0800115struct ocfs2_control_private {
116 struct list_head op_list;
117 int op_state;
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800118 int op_this_node;
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800119 struct ocfs2_protocol_version op_proto;
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800120};
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
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800130/* 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
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800140/* 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;
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800153 struct ocfs2_control_message_setv u_setv;
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800154 struct ocfs2_control_message_down u_down;
Joel Becker462c7e62008-02-18 19:40:12 -0800155};
156
Joel Beckera12630b2008-05-09 18:49:29 -0700157static struct ocfs2_stack_plugin ocfs2_user_plugin;
David Teiglandcf4d8d72008-02-20 14:29:27 -0800158
Joel Becker6427a722008-02-18 19:23:28 -0800159static atomic_t ocfs2_control_opened;
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800160static int ocfs2_control_this_node = -1;
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800161static struct ocfs2_protocol_version running_proto;
Joel Becker6427a722008-02-18 19:23:28 -0800162
163static LIST_HEAD(ocfs2_live_connection_list);
Joel Becker462c7e62008-02-18 19:40:12 -0800164static LIST_HEAD(ocfs2_control_private_list);
Joel Becker6427a722008-02-18 19:23:28 -0800165static DEFINE_MUTEX(ocfs2_control_lock);
166
Joel Becker462c7e62008-02-18 19:40:12 -0800167static 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
Joel Becker6427a722008-02-18 19:23:28 -0800180static 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 c;
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
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800246static int ocfs2_control_cfu(void *target, size_t target_len,
247 const char __user *buf, size_t count)
Joel Becker462c7e62008-02-18 19:40:12 -0800248{
249 /* The T01 expects write(2) calls to have exactly one command */
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800250 if ((count != target_len) ||
251 (count > sizeof(union ocfs2_control_message)))
Joel Becker462c7e62008-02-18 19:40:12 -0800252 return -EINVAL;
253
254 if (copy_from_user(target, buf, target_len))
255 return -EFAULT;
256
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800257 return 0;
Joel Becker462c7e62008-02-18 19:40:12 -0800258}
259
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800260static ssize_t ocfs2_control_validate_protocol(struct file *file,
261 const char __user *buf,
262 size_t count)
Joel Becker462c7e62008-02-18 19:40:12 -0800263{
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);
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800269 if (ret)
Joel Becker462c7e62008-02-18 19:40:12 -0800270 return ret;
271
272 if (strncmp(kbuf, OCFS2_CONTROL_PROTO, OCFS2_CONTROL_PROTO_LEN))
273 return -EINVAL;
274
Joel Becker462c7e62008-02-18 19:40:12 -0800275 ocfs2_control_set_handshake_state(file,
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800276 OCFS2_CONTROL_HANDSHAKE_PROTOCOL);
Joel Becker462c7e62008-02-18 19:40:12 -0800277
278 return count;
279}
280
Joel Beckerde870ef2008-02-18 17:07:09 -0800281static 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
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800298/*
299 * Called whenever configuration elements are sent to /dev/ocfs2_control.
300 * If all configuration elements are present, try to set the global
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800301 * 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.
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800304 */
305static int ocfs2_control_install_private(struct file *file)
Joel Beckerde870ef2008-02-18 17:07:09 -0800306{
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800307 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
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800313 mutex_lock(&ocfs2_control_lock);
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800314
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)) {
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800319 rc = -EINVAL;
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800320 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:
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800339 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
David Teiglandcf4d8d72008-02-20 14:29:27 -0800351static 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
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800365static int ocfs2_control_do_setnode_msg(struct file *file,
366 struct ocfs2_control_message_setn *msg)
367{
Joel Beckerde870ef2008-02-18 17:07:09 -0800368 long nodenum;
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800369 char *ptr = NULL;
370 struct ocfs2_control_private *p = file->private_data;
Joel Beckerde870ef2008-02-18 17:07:09 -0800371
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800372 if (ocfs2_control_get_handshake_state(file) !=
373 OCFS2_CONTROL_HANDSHAKE_PROTOCOL)
Joel Beckerde870ef2008-02-18 17:07:09 -0800374 return -EINVAL;
375
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800376 if (strncmp(msg->tag, OCFS2_CONTROL_MESSAGE_SETNODE_OP,
377 OCFS2_CONTROL_MESSAGE_OP_LEN))
Joel Beckerde870ef2008-02-18 17:07:09 -0800378 return -EINVAL;
Joel Beckerde870ef2008-02-18 17:07:09 -0800379
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800380 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
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800396static 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 =
Joel Beckera12630b2008-05-09 18:49:29 -0700403 &ocfs2_user_plugin.sp_proto->lp_max_version;
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800404
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
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800446static 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);
Joel Beckerde870ef2008-02-18 17:07:09 -0800466 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
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800473 ocfs2_control_send_down(msg->uuid, nodenum);
Joel Beckerde870ef2008-02-18 17:07:09 -0800474
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800475 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);
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800498 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);
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800502 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;
Joel Beckerde870ef2008-02-18 17:07:09 -0800511}
Joel Becker6427a722008-02-18 19:23:28 -0800512
513static ssize_t ocfs2_control_write(struct file *file,
514 const char __user *buf,
515 size_t count,
516 loff_t *ppos)
Joel Becker8adf0532007-11-28 14:38:40 -0800517{
Joel Becker462c7e62008-02-18 19:40:12 -0800518 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:
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800526 ret = ocfs2_control_validate_protocol(file, buf,
527 count);
Joel Becker462c7e62008-02-18 19:40:12 -0800528 break;
529
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800530 case OCFS2_CONTROL_HANDSHAKE_PROTOCOL:
Joel Becker462c7e62008-02-18 19:40:12 -0800531 case OCFS2_CONTROL_HANDSHAKE_VALID:
Joel Beckerde870ef2008-02-18 17:07:09 -0800532 ret = ocfs2_control_message(file, buf, count);
Joel Becker462c7e62008-02-18 19:40:12 -0800533 break;
534
535 default:
536 BUG();
537 ret = -EIO;
538 break;
539 }
540
541 return ret;
Joel Becker8adf0532007-11-28 14:38:40 -0800542}
543
Joel Becker462c7e62008-02-18 19:40:12 -0800544/*
545 * This is a naive version. If we ever have a new protocol, we'll expand
546 * it. Probably using seq_file.
547 */
Joel Becker6427a722008-02-18 19:23:28 -0800548static ssize_t ocfs2_control_read(struct file *file,
549 char __user *buf,
550 size_t count,
551 loff_t *ppos)
552{
Akinobu Mita7600c722008-06-09 16:34:23 -0700553 ssize_t ret;
Joel Becker462c7e62008-02-18 19:40:12 -0800554
Akinobu Mita7600c722008-06-09 16:34:23 -0700555 ret = simple_read_from_buffer(buf, count, ppos,
556 OCFS2_CONTROL_PROTO, OCFS2_CONTROL_PROTO_LEN);
Joel Becker462c7e62008-02-18 19:40:12 -0800557
558 /* Have we read the whole protocol list? */
Akinobu Mita7600c722008-06-09 16:34:23 -0700559 if (ret > 0 && *ppos >= OCFS2_CONTROL_PROTO_LEN)
Joel Becker462c7e62008-02-18 19:40:12 -0800560 ocfs2_control_set_handshake_state(file,
561 OCFS2_CONTROL_HANDSHAKE_READ);
562
Akinobu Mita7600c722008-06-09 16:34:23 -0700563 return ret;
Joel Becker6427a722008-02-18 19:23:28 -0800564}
565
566static int ocfs2_control_release(struct inode *inode, struct file *file)
567{
Joel Becker462c7e62008-02-18 19:40:12 -0800568 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
Joel Becker6427a722008-02-18 19:23:28 -0800576 if (atomic_dec_and_test(&ocfs2_control_opened)) {
Joel Becker6427a722008-02-18 19:23:28 -0800577 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 }
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800585 /*
586 * Last valid close clears the node number and resets
587 * the locking protocol version
588 */
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800589 ocfs2_control_this_node = -1;
Joel Beckerd4b95ee2008-02-20 15:39:44 -0800590 running_proto.pv_major = 0;
591 running_proto.pv_major = 0;
Joel Becker6427a722008-02-18 19:23:28 -0800592 }
593
Joel Becker462c7e62008-02-18 19:40:12 -0800594out:
595 list_del_init(&p->op_list);
596 file->private_data = NULL;
597
598 mutex_unlock(&ocfs2_control_lock);
599
600 kfree(p);
601
Joel Becker6427a722008-02-18 19:23:28 -0800602 return 0;
603}
604
605static int ocfs2_control_open(struct inode *inode, struct file *file)
606{
Joel Becker462c7e62008-02-18 19:40:12 -0800607 struct ocfs2_control_private *p;
608
609 p = kzalloc(sizeof(struct ocfs2_control_private), GFP_KERNEL);
610 if (!p)
611 return -ENOMEM;
Joel Becker3cfd4ab2008-02-20 14:44:34 -0800612 p->op_this_node = -1;
Joel Becker462c7e62008-02-18 19:40:12 -0800613
Arnd Bergmannb7fdf9f2008-05-20 19:16:28 +0200614 lock_kernel();
Joel Becker462c7e62008-02-18 19:40:12 -0800615 mutex_lock(&ocfs2_control_lock);
616 file->private_data = p;
617 list_add(&p->op_list, &ocfs2_control_private_list);
618 mutex_unlock(&ocfs2_control_lock);
Arnd Bergmannb7fdf9f2008-05-20 19:16:28 +0200619 unlock_kernel();
Joel Becker6427a722008-02-18 19:23:28 -0800620
621 return 0;
622}
623
624static const struct file_operations ocfs2_control_fops = {
625 .open = ocfs2_control_open,
626 .release = ocfs2_control_release,
627 .read = ocfs2_control_read,
628 .write = ocfs2_control_write,
629 .owner = THIS_MODULE,
630};
631
Adrian Bunk4d8755b2008-04-21 11:49:26 +0300632static struct miscdevice ocfs2_control_device = {
Joel Becker6427a722008-02-18 19:23:28 -0800633 .minor = MISC_DYNAMIC_MINOR,
634 .name = "ocfs2_control",
635 .fops = &ocfs2_control_fops,
636};
637
638static int ocfs2_control_init(void)
639{
640 int rc;
641
642 atomic_set(&ocfs2_control_opened, 0);
643
644 rc = misc_register(&ocfs2_control_device);
645 if (rc)
646 printk(KERN_ERR
647 "ocfs2: Unable to register ocfs2_control device "
648 "(errno %d)\n",
649 -rc);
650
651 return rc;
652}
653
654static void ocfs2_control_exit(void)
655{
656 int rc;
657
658 rc = misc_deregister(&ocfs2_control_device);
659 if (rc)
660 printk(KERN_ERR
661 "ocfs2: Unable to deregister ocfs2_control device "
662 "(errno %d)\n",
663 -rc);
664}
665
David Teiglandcf4d8d72008-02-20 14:29:27 -0800666static void fsdlm_lock_ast_wrapper(void *astarg)
667{
Joel Beckerc0e41332010-01-29 14:46:44 -0800668 struct ocfs2_dlm_lksb *lksb = astarg;
Joel Beckera796d282010-01-28 19:22:39 -0800669 int status = lksb->lksb_fsdlm.sb_status;
David Teiglandcf4d8d72008-02-20 14:29:27 -0800670
Joel Beckera12630b2008-05-09 18:49:29 -0700671 BUG_ON(ocfs2_user_plugin.sp_proto == NULL);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800672
673 /*
674 * For now we're punting on the issue of other non-standard errors
675 * where we can't tell if the unlock_ast or lock_ast should be called.
676 * The main "other error" that's possible is EINVAL which means the
677 * function was called with invalid args, which shouldn't be possible
678 * since the caller here is under our control. Other non-standard
679 * errors probably fall into the same category, or otherwise are fatal
680 * which means we can't carry on anyway.
681 */
682
683 if (status == -DLM_EUNLOCK || status == -DLM_ECANCEL)
Joel Beckera796d282010-01-28 19:22:39 -0800684 ocfs2_user_plugin.sp_proto->lp_unlock_ast(lksb, 0);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800685 else
Joel Beckera796d282010-01-28 19:22:39 -0800686 ocfs2_user_plugin.sp_proto->lp_lock_ast(lksb);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800687}
688
689static void fsdlm_blocking_ast_wrapper(void *astarg, int level)
690{
Joel Beckerc0e41332010-01-29 14:46:44 -0800691 struct ocfs2_dlm_lksb *lksb = astarg;
Joel Beckera796d282010-01-28 19:22:39 -0800692
Joel Beckera12630b2008-05-09 18:49:29 -0700693 BUG_ON(ocfs2_user_plugin.sp_proto == NULL);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800694
Joel Beckera796d282010-01-28 19:22:39 -0800695 ocfs2_user_plugin.sp_proto->lp_blocking_ast(lksb, level);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800696}
697
698static int user_dlm_lock(struct ocfs2_cluster_connection *conn,
699 int mode,
Joel Beckerc0e41332010-01-29 14:46:44 -0800700 struct ocfs2_dlm_lksb *lksb,
David Teiglandcf4d8d72008-02-20 14:29:27 -0800701 u32 flags,
702 void *name,
Joel Beckera796d282010-01-28 19:22:39 -0800703 unsigned int namelen)
David Teiglandcf4d8d72008-02-20 14:29:27 -0800704{
705 int ret;
706
707 if (!lksb->lksb_fsdlm.sb_lvbptr)
708 lksb->lksb_fsdlm.sb_lvbptr = (char *)lksb +
709 sizeof(struct dlm_lksb);
710
711 ret = dlm_lock(conn->cc_lockspace, mode, &lksb->lksb_fsdlm,
712 flags|DLM_LKF_NODLCKWT, name, namelen, 0,
Joel Beckera796d282010-01-28 19:22:39 -0800713 fsdlm_lock_ast_wrapper, lksb,
David Teiglandcf4d8d72008-02-20 14:29:27 -0800714 fsdlm_blocking_ast_wrapper);
715 return ret;
716}
717
718static int user_dlm_unlock(struct ocfs2_cluster_connection *conn,
Joel Beckerc0e41332010-01-29 14:46:44 -0800719 struct ocfs2_dlm_lksb *lksb,
Joel Beckera796d282010-01-28 19:22:39 -0800720 u32 flags)
David Teiglandcf4d8d72008-02-20 14:29:27 -0800721{
722 int ret;
723
724 ret = dlm_unlock(conn->cc_lockspace, lksb->lksb_fsdlm.sb_lkid,
Joel Beckera796d282010-01-28 19:22:39 -0800725 flags, &lksb->lksb_fsdlm, lksb);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800726 return ret;
727}
728
Joel Beckerc0e41332010-01-29 14:46:44 -0800729static int user_dlm_lock_status(struct ocfs2_dlm_lksb *lksb)
David Teiglandcf4d8d72008-02-20 14:29:27 -0800730{
731 return lksb->lksb_fsdlm.sb_status;
732}
733
Joel Beckerc0e41332010-01-29 14:46:44 -0800734static int user_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb)
Joel Becker1c520df2009-06-19 15:14:13 -0700735{
736 int invalid = lksb->lksb_fsdlm.sb_flags & DLM_SBF_VALNOTVALID;
737
738 return !invalid;
739}
740
Joel Beckerc0e41332010-01-29 14:46:44 -0800741static void *user_dlm_lvb(struct ocfs2_dlm_lksb *lksb)
David Teiglandcf4d8d72008-02-20 14:29:27 -0800742{
David Teigland66f502a2008-11-10 16:24:57 -0600743 if (!lksb->lksb_fsdlm.sb_lvbptr)
744 lksb->lksb_fsdlm.sb_lvbptr = (char *)lksb +
745 sizeof(struct dlm_lksb);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800746 return (void *)(lksb->lksb_fsdlm.sb_lvbptr);
747}
748
Joel Beckerc0e41332010-01-29 14:46:44 -0800749static void user_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb)
David Teiglandcf4d8d72008-02-20 14:29:27 -0800750{
751}
752
Mark Fasheh53da4932008-07-21 14:29:16 -0700753static int user_plock(struct ocfs2_cluster_connection *conn,
754 u64 ino,
755 struct file *file,
756 int cmd,
757 struct file_lock *fl)
758{
759 /*
760 * This more or less just demuxes the plock request into any
761 * one of three dlm calls.
762 *
763 * Internally, fs/dlm will pass these to a misc device, which
764 * a userspace daemon will read and write to.
765 *
766 * For now, cancel requests (which happen internally only),
767 * are turned into unlocks. Most of this function taken from
768 * gfs2_lock.
769 */
770
771 if (cmd == F_CANCELLK) {
772 cmd = F_SETLK;
773 fl->fl_type = F_UNLCK;
774 }
775
776 if (IS_GETLK(cmd))
777 return dlm_posix_get(conn->cc_lockspace, ino, file, fl);
778 else if (fl->fl_type == F_UNLCK)
779 return dlm_posix_unlock(conn->cc_lockspace, ino, file, fl);
780 else
781 return dlm_posix_lock(conn->cc_lockspace, ino, file, cmd, fl);
782}
783
David Teiglandcf4d8d72008-02-20 14:29:27 -0800784/*
785 * Compare a requested locking protocol version against the current one.
786 *
787 * If the major numbers are different, they are incompatible.
788 * If the current minor is greater than the request, they are incompatible.
789 * If the current minor is less than or equal to the request, they are
790 * compatible, and the requester should run at the current minor version.
791 */
792static int fs_protocol_compare(struct ocfs2_protocol_version *existing,
793 struct ocfs2_protocol_version *request)
794{
795 if (existing->pv_major != request->pv_major)
796 return 1;
797
798 if (existing->pv_minor > request->pv_minor)
799 return 1;
800
801 if (existing->pv_minor < request->pv_minor)
802 request->pv_minor = existing->pv_minor;
803
804 return 0;
805}
806
807static int user_cluster_connect(struct ocfs2_cluster_connection *conn)
808{
809 dlm_lockspace_t *fsdlm;
Coly Li3a05d792009-12-04 02:02:35 +0800810 struct ocfs2_live_connection *uninitialized_var(control);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800811 int rc = 0;
812
813 BUG_ON(conn == NULL);
814
815 rc = ocfs2_live_connection_new(conn, &control);
816 if (rc)
817 goto out;
818
819 /*
820 * running_proto must have been set before we allowed any mounts
821 * to proceed.
822 */
823 if (fs_protocol_compare(&running_proto, &conn->cc_version)) {
824 printk(KERN_ERR
825 "Unable to mount with fs locking protocol version "
826 "%u.%u because the userspace control daemon has "
827 "negotiated %u.%u\n",
828 conn->cc_version.pv_major, conn->cc_version.pv_minor,
829 running_proto.pv_major, running_proto.pv_minor);
830 rc = -EPROTO;
831 ocfs2_live_connection_drop(control);
832 goto out;
833 }
834
835 rc = dlm_new_lockspace(conn->cc_name, strlen(conn->cc_name),
836 &fsdlm, DLM_LSFL_FS, DLM_LVB_LEN);
837 if (rc) {
838 ocfs2_live_connection_drop(control);
839 goto out;
840 }
841
842 conn->cc_private = control;
843 conn->cc_lockspace = fsdlm;
844out:
845 return rc;
846}
847
Joel Becker2c394502008-05-30 15:58:26 -0700848static int user_cluster_disconnect(struct ocfs2_cluster_connection *conn)
David Teiglandcf4d8d72008-02-20 14:29:27 -0800849{
850 dlm_release_lockspace(conn->cc_lockspace, 2);
851 conn->cc_lockspace = NULL;
852 ocfs2_live_connection_drop(conn->cc_private);
853 conn->cc_private = NULL;
854 return 0;
855}
856
857static int user_cluster_this_node(unsigned int *this_node)
858{
859 int rc;
860
861 rc = ocfs2_control_get_this_node();
862 if (rc < 0)
863 return rc;
864
865 *this_node = rc;
866 return 0;
867}
868
Joel Beckera12630b2008-05-09 18:49:29 -0700869static struct ocfs2_stack_operations ocfs2_user_plugin_ops = {
David Teiglandcf4d8d72008-02-20 14:29:27 -0800870 .connect = user_cluster_connect,
871 .disconnect = user_cluster_disconnect,
872 .this_node = user_cluster_this_node,
873 .dlm_lock = user_dlm_lock,
874 .dlm_unlock = user_dlm_unlock,
875 .lock_status = user_dlm_lock_status,
Joel Becker1c520df2009-06-19 15:14:13 -0700876 .lvb_valid = user_dlm_lvb_valid,
David Teiglandcf4d8d72008-02-20 14:29:27 -0800877 .lock_lvb = user_dlm_lvb,
Mark Fasheh53da4932008-07-21 14:29:16 -0700878 .plock = user_plock,
David Teiglandcf4d8d72008-02-20 14:29:27 -0800879 .dump_lksb = user_dlm_dump_lksb,
880};
881
Joel Beckera12630b2008-05-09 18:49:29 -0700882static struct ocfs2_stack_plugin ocfs2_user_plugin = {
David Teiglandcf4d8d72008-02-20 14:29:27 -0800883 .sp_name = "user",
Joel Beckera12630b2008-05-09 18:49:29 -0700884 .sp_ops = &ocfs2_user_plugin_ops,
David Teiglandcf4d8d72008-02-20 14:29:27 -0800885 .sp_owner = THIS_MODULE,
886};
887
888
Joel Beckera12630b2008-05-09 18:49:29 -0700889static int __init ocfs2_user_plugin_init(void)
Joel Becker6427a722008-02-18 19:23:28 -0800890{
David Teiglandcf4d8d72008-02-20 14:29:27 -0800891 int rc;
892
893 rc = ocfs2_control_init();
894 if (!rc) {
Joel Beckera12630b2008-05-09 18:49:29 -0700895 rc = ocfs2_stack_glue_register(&ocfs2_user_plugin);
David Teiglandcf4d8d72008-02-20 14:29:27 -0800896 if (rc)
897 ocfs2_control_exit();
898 }
899
900 return rc;
Joel Becker6427a722008-02-18 19:23:28 -0800901}
902
Joel Beckera12630b2008-05-09 18:49:29 -0700903static void __exit ocfs2_user_plugin_exit(void)
Joel Becker8adf0532007-11-28 14:38:40 -0800904{
Joel Beckera12630b2008-05-09 18:49:29 -0700905 ocfs2_stack_glue_unregister(&ocfs2_user_plugin);
Joel Becker6427a722008-02-18 19:23:28 -0800906 ocfs2_control_exit();
Joel Becker8adf0532007-11-28 14:38:40 -0800907}
908
909MODULE_AUTHOR("Oracle");
910MODULE_DESCRIPTION("ocfs2 driver for userspace cluster stacks");
911MODULE_LICENSE("GPL");
Joel Beckera12630b2008-05-09 18:49:29 -0700912module_init(ocfs2_user_plugin_init);
913module_exit(ocfs2_user_plugin_exit);