Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[linux-2.6] / fs / gfs2 / locking / dlm / plock.c
1 /*
2  * Copyright (C) 2005 Red Hat, Inc.  All rights reserved.
3  *
4  * This copyrighted material is made available to anyone wishing to use,
5  * modify, copy, or redistribute it subject to the terms and conditions
6  * of the GNU General Public License version 2.
7  */
8
9 #include <linux/miscdevice.h>
10 #include <linux/lock_dlm_plock.h>
11 #include <linux/poll.h>
12
13 #include "lock_dlm.h"
14
15
16 static spinlock_t ops_lock;
17 static struct list_head send_list;
18 static struct list_head recv_list;
19 static wait_queue_head_t send_wq;
20 static wait_queue_head_t recv_wq;
21
22 struct plock_op {
23         struct list_head list;
24         int done;
25         struct gdlm_plock_info info;
26 };
27
28 struct plock_xop {
29         struct plock_op xop;
30         void *callback;
31         void *fl;
32         void *file;
33         struct file_lock flc;
34 };
35
36
37 static inline void set_version(struct gdlm_plock_info *info)
38 {
39         info->version[0] = GDLM_PLOCK_VERSION_MAJOR;
40         info->version[1] = GDLM_PLOCK_VERSION_MINOR;
41         info->version[2] = GDLM_PLOCK_VERSION_PATCH;
42 }
43
44 static int check_version(struct gdlm_plock_info *info)
45 {
46         if ((GDLM_PLOCK_VERSION_MAJOR != info->version[0]) ||
47             (GDLM_PLOCK_VERSION_MINOR < info->version[1])) {
48                 log_error("plock device version mismatch: "
49                           "kernel (%u.%u.%u), user (%u.%u.%u)",
50                           GDLM_PLOCK_VERSION_MAJOR,
51                           GDLM_PLOCK_VERSION_MINOR,
52                           GDLM_PLOCK_VERSION_PATCH,
53                           info->version[0],
54                           info->version[1],
55                           info->version[2]);
56                 return -EINVAL;
57         }
58         return 0;
59 }
60
61 static void send_op(struct plock_op *op)
62 {
63         set_version(&op->info);
64         INIT_LIST_HEAD(&op->list);
65         spin_lock(&ops_lock);
66         list_add_tail(&op->list, &send_list);
67         spin_unlock(&ops_lock);
68         wake_up(&send_wq);
69 }
70
71 int gdlm_plock(void *lockspace, struct lm_lockname *name,
72                struct file *file, int cmd, struct file_lock *fl)
73 {
74         struct gdlm_ls *ls = lockspace;
75         struct plock_op *op;
76         struct plock_xop *xop;
77         int rv;
78
79         xop = kzalloc(sizeof(*xop), GFP_KERNEL);
80         if (!xop)
81                 return -ENOMEM;
82
83         op = &xop->xop;
84         op->info.optype         = GDLM_PLOCK_OP_LOCK;
85         op->info.pid            = fl->fl_pid;
86         op->info.ex             = (fl->fl_type == F_WRLCK);
87         op->info.wait           = IS_SETLKW(cmd);
88         op->info.fsid           = ls->id;
89         op->info.number         = name->ln_number;
90         op->info.start          = fl->fl_start;
91         op->info.end            = fl->fl_end;
92         op->info.owner          = (__u64)(long) fl->fl_owner;
93         if (fl->fl_lmops && fl->fl_lmops->fl_grant) {
94                 xop->callback   = fl->fl_lmops->fl_grant;
95                 locks_init_lock(&xop->flc);
96                 locks_copy_lock(&xop->flc, fl);
97                 xop->fl         = fl;
98                 xop->file       = file;
99         } else
100                 xop->callback   = NULL;
101
102         send_op(op);
103
104         if (xop->callback == NULL)
105                 wait_event(recv_wq, (op->done != 0));
106         else
107                 return -EINPROGRESS;
108
109         spin_lock(&ops_lock);
110         if (!list_empty(&op->list)) {
111                 printk(KERN_INFO "plock op on list\n");
112                 list_del(&op->list);
113         }
114         spin_unlock(&ops_lock);
115
116         rv = op->info.rv;
117
118         if (!rv) {
119                 if (posix_lock_file_wait(file, fl) < 0)
120                         log_error("gdlm_plock: vfs lock error %x,%llx",
121                                   name->ln_type,
122                                   (unsigned long long)name->ln_number);
123         }
124
125         kfree(xop);
126         return rv;
127 }
128
129 /* Returns failure iff a succesful lock operation should be canceled */
130 static int gdlm_plock_callback(struct plock_op *op)
131 {
132         struct file *file;
133         struct file_lock *fl;
134         struct file_lock *flc;
135         int (*notify)(void *, void *, int) = NULL;
136         struct plock_xop *xop = (struct plock_xop *)op;
137         int rv = 0;
138
139         spin_lock(&ops_lock);
140         if (!list_empty(&op->list)) {
141                 printk(KERN_INFO "plock op on list\n");
142                 list_del(&op->list);
143         }
144         spin_unlock(&ops_lock);
145
146         /* check if the following 2 are still valid or make a copy */
147         file = xop->file;
148         flc = &xop->flc;
149         fl = xop->fl;
150         notify = xop->callback;
151
152         if (op->info.rv) {
153                 notify(flc, NULL, op->info.rv);
154                 goto out;
155         }
156
157         /* got fs lock; bookkeep locally as well: */
158         flc->fl_flags &= ~FL_SLEEP;
159         if (posix_lock_file(file, flc, NULL)) {
160                 /*
161                  * This can only happen in the case of kmalloc() failure.
162                  * The filesystem's own lock is the authoritative lock,
163                  * so a failure to get the lock locally is not a disaster.
164                  * As long as GFS cannot reliably cancel locks (especially
165                  * in a low-memory situation), we're better off ignoring
166                  * this failure than trying to recover.
167                  */
168                 log_error("gdlm_plock: vfs lock error file %p fl %p",
169                                 file, fl);
170         }
171
172         rv = notify(flc, NULL, 0);
173         if (rv) {
174                 /* XXX: We need to cancel the fs lock here: */
175                 printk("gfs2 lock granted after lock request failed;"
176                                                 " dangling lock!\n");
177                 goto out;
178         }
179
180 out:
181         kfree(xop);
182         return rv;
183 }
184
185 int gdlm_punlock(void *lockspace, struct lm_lockname *name,
186                  struct file *file, struct file_lock *fl)
187 {
188         struct gdlm_ls *ls = lockspace;
189         struct plock_op *op;
190         int rv;
191
192         op = kzalloc(sizeof(*op), GFP_KERNEL);
193         if (!op)
194                 return -ENOMEM;
195
196         if (posix_lock_file_wait(file, fl) < 0)
197                 log_error("gdlm_punlock: vfs unlock error %x,%llx",
198                           name->ln_type, (unsigned long long)name->ln_number);
199
200         op->info.optype         = GDLM_PLOCK_OP_UNLOCK;
201         op->info.pid            = fl->fl_pid;
202         op->info.fsid           = ls->id;
203         op->info.number         = name->ln_number;
204         op->info.start          = fl->fl_start;
205         op->info.end            = fl->fl_end;
206         op->info.owner          = (__u64)(long) fl->fl_owner;
207
208         send_op(op);
209         wait_event(recv_wq, (op->done != 0));
210
211         spin_lock(&ops_lock);
212         if (!list_empty(&op->list)) {
213                 printk(KERN_INFO "punlock op on list\n");
214                 list_del(&op->list);
215         }
216         spin_unlock(&ops_lock);
217
218         rv = op->info.rv;
219
220         if (rv == -ENOENT)
221                 rv = 0;
222
223         kfree(op);
224         return rv;
225 }
226
227 int gdlm_plock_get(void *lockspace, struct lm_lockname *name,
228                    struct file *file, struct file_lock *fl)
229 {
230         struct gdlm_ls *ls = lockspace;
231         struct plock_op *op;
232         int rv;
233
234         op = kzalloc(sizeof(*op), GFP_KERNEL);
235         if (!op)
236                 return -ENOMEM;
237
238         op->info.optype         = GDLM_PLOCK_OP_GET;
239         op->info.pid            = fl->fl_pid;
240         op->info.ex             = (fl->fl_type == F_WRLCK);
241         op->info.fsid           = ls->id;
242         op->info.number         = name->ln_number;
243         op->info.start          = fl->fl_start;
244         op->info.end            = fl->fl_end;
245         op->info.owner          = (__u64)(long) fl->fl_owner;
246
247         send_op(op);
248         wait_event(recv_wq, (op->done != 0));
249
250         spin_lock(&ops_lock);
251         if (!list_empty(&op->list)) {
252                 printk(KERN_INFO "plock_get op on list\n");
253                 list_del(&op->list);
254         }
255         spin_unlock(&ops_lock);
256
257         /* info.rv from userspace is 1 for conflict, 0 for no-conflict,
258            -ENOENT if there are no locks on the file */
259
260         rv = op->info.rv;
261
262         fl->fl_type = F_UNLCK;
263         if (rv == -ENOENT)
264                 rv = 0;
265         else if (rv > 0) {
266                 fl->fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK;
267                 fl->fl_pid = op->info.pid;
268                 fl->fl_start = op->info.start;
269                 fl->fl_end = op->info.end;
270                 rv = 0;
271         }
272
273         kfree(op);
274         return rv;
275 }
276
277 /* a read copies out one plock request from the send list */
278 static ssize_t dev_read(struct file *file, char __user *u, size_t count,
279                         loff_t *ppos)
280 {
281         struct gdlm_plock_info info;
282         struct plock_op *op = NULL;
283
284         if (count < sizeof(info))
285                 return -EINVAL;
286
287         spin_lock(&ops_lock);
288         if (!list_empty(&send_list)) {
289                 op = list_entry(send_list.next, struct plock_op, list);
290                 list_move(&op->list, &recv_list);
291                 memcpy(&info, &op->info, sizeof(info));
292         }
293         spin_unlock(&ops_lock);
294
295         if (!op)
296                 return -EAGAIN;
297
298         if (copy_to_user(u, &info, sizeof(info)))
299                 return -EFAULT;
300         return sizeof(info);
301 }
302
303 /* a write copies in one plock result that should match a plock_op
304    on the recv list */
305 static ssize_t dev_write(struct file *file, const char __user *u, size_t count,
306                          loff_t *ppos)
307 {
308         struct gdlm_plock_info info;
309         struct plock_op *op;
310         int found = 0;
311
312         if (count != sizeof(info))
313                 return -EINVAL;
314
315         if (copy_from_user(&info, u, sizeof(info)))
316                 return -EFAULT;
317
318         if (check_version(&info))
319                 return -EINVAL;
320
321         spin_lock(&ops_lock);
322         list_for_each_entry(op, &recv_list, list) {
323                 if (op->info.fsid == info.fsid && op->info.number == info.number &&
324                     op->info.owner == info.owner) {
325                         list_del_init(&op->list);
326                         found = 1;
327                         op->done = 1;
328                         memcpy(&op->info, &info, sizeof(info));
329                         break;
330                 }
331         }
332         spin_unlock(&ops_lock);
333
334         if (found) {
335                 struct plock_xop *xop;
336                 xop = (struct plock_xop *)op;
337                 if (xop->callback)
338                         count = gdlm_plock_callback(op);
339                 else
340                         wake_up(&recv_wq);
341         } else
342                 printk(KERN_INFO "gdlm dev_write no op %x %llx\n", info.fsid,
343                         (unsigned long long)info.number);
344         return count;
345 }
346
347 static unsigned int dev_poll(struct file *file, poll_table *wait)
348 {
349         unsigned int mask = 0;
350
351         poll_wait(file, &send_wq, wait);
352
353         spin_lock(&ops_lock);
354         if (!list_empty(&send_list))
355                 mask = POLLIN | POLLRDNORM;
356         spin_unlock(&ops_lock);
357
358         return mask;
359 }
360
361 static const struct file_operations dev_fops = {
362         .read    = dev_read,
363         .write   = dev_write,
364         .poll    = dev_poll,
365         .owner   = THIS_MODULE
366 };
367
368 static struct miscdevice plock_dev_misc = {
369         .minor = MISC_DYNAMIC_MINOR,
370         .name = GDLM_PLOCK_MISC_NAME,
371         .fops = &dev_fops
372 };
373
374 int gdlm_plock_init(void)
375 {
376         int rv;
377
378         spin_lock_init(&ops_lock);
379         INIT_LIST_HEAD(&send_list);
380         INIT_LIST_HEAD(&recv_list);
381         init_waitqueue_head(&send_wq);
382         init_waitqueue_head(&recv_wq);
383
384         rv = misc_register(&plock_dev_misc);
385         if (rv)
386                 printk(KERN_INFO "gdlm_plock_init: misc_register failed %d",
387                        rv);
388         return rv;
389 }
390
391 void gdlm_plock_exit(void)
392 {
393         if (misc_deregister(&plock_dev_misc) < 0)
394                 printk(KERN_INFO "gdlm_plock_exit: misc_deregister failed");
395 }
396