aboutsummaryrefslogtreecommitdiffstats
path: root/fs/gfs2
diff options
context:
space:
mode:
Diffstat (limited to 'fs/gfs2')
-rw-r--r--fs/gfs2/locking/dlm/Makefile2
-rw-r--r--fs/gfs2/locking/dlm/lock_dlm.h12
-rw-r--r--fs/gfs2/locking/dlm/main.c8
-rw-r--r--fs/gfs2/locking/dlm/mount.c21
-rw-r--r--fs/gfs2/locking/dlm/plock.c406
5 files changed, 23 insertions, 426 deletions
diff --git a/fs/gfs2/locking/dlm/Makefile b/fs/gfs2/locking/dlm/Makefile
index 89b93b6b45cf..2609bb6cd013 100644
--- a/fs/gfs2/locking/dlm/Makefile
+++ b/fs/gfs2/locking/dlm/Makefile
@@ -1,3 +1,3 @@
1obj-$(CONFIG_GFS2_FS_LOCKING_DLM) += lock_dlm.o 1obj-$(CONFIG_GFS2_FS_LOCKING_DLM) += lock_dlm.o
2lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o plock.o 2lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o
3 3
diff --git a/fs/gfs2/locking/dlm/lock_dlm.h b/fs/gfs2/locking/dlm/lock_dlm.h
index 58fcf8c5bf39..a243cf69c54e 100644
--- a/fs/gfs2/locking/dlm/lock_dlm.h
+++ b/fs/gfs2/locking/dlm/lock_dlm.h
@@ -25,6 +25,7 @@
25#include <net/sock.h> 25#include <net/sock.h>
26 26
27#include <linux/dlm.h> 27#include <linux/dlm.h>
28#include <linux/dlm_plock.h>
28#include <linux/lm_interface.h> 29#include <linux/lm_interface.h>
29 30
30/* 31/*
@@ -173,17 +174,6 @@ void gdlm_cancel(void *);
173int gdlm_hold_lvb(void *, char **); 174int gdlm_hold_lvb(void *, char **);
174void gdlm_unhold_lvb(void *, char *); 175void gdlm_unhold_lvb(void *, char *);
175 176
176/* plock.c */
177
178int gdlm_plock_init(void);
179void gdlm_plock_exit(void);
180int gdlm_plock(void *, struct lm_lockname *, struct file *, int,
181 struct file_lock *);
182int gdlm_plock_get(void *, struct lm_lockname *, struct file *,
183 struct file_lock *);
184int gdlm_punlock(void *, struct lm_lockname *, struct file *,
185 struct file_lock *);
186
187/* mount.c */ 177/* mount.c */
188 178
189extern const struct lm_lockops gdlm_ops; 179extern const struct lm_lockops gdlm_ops;
diff --git a/fs/gfs2/locking/dlm/main.c b/fs/gfs2/locking/dlm/main.c
index 36a225850bd8..b9a03a7ff801 100644
--- a/fs/gfs2/locking/dlm/main.c
+++ b/fs/gfs2/locking/dlm/main.c
@@ -28,13 +28,6 @@ static int __init init_lock_dlm(void)
28 return error; 28 return error;
29 } 29 }
30 30
31 error = gdlm_plock_init();
32 if (error) {
33 gdlm_sysfs_exit();
34 gfs2_unregister_lockproto(&gdlm_ops);
35 return error;
36 }
37
38 printk(KERN_INFO 31 printk(KERN_INFO
39 "Lock_DLM (built %s %s) installed\n", __DATE__, __TIME__); 32 "Lock_DLM (built %s %s) installed\n", __DATE__, __TIME__);
40 return 0; 33 return 0;
@@ -42,7 +35,6 @@ static int __init init_lock_dlm(void)
42 35
43static void __exit exit_lock_dlm(void) 36static void __exit exit_lock_dlm(void)
44{ 37{
45 gdlm_plock_exit();
46 gdlm_sysfs_exit(); 38 gdlm_sysfs_exit();
47 gfs2_unregister_lockproto(&gdlm_ops); 39 gfs2_unregister_lockproto(&gdlm_ops);
48} 40}
diff --git a/fs/gfs2/locking/dlm/mount.c b/fs/gfs2/locking/dlm/mount.c
index f2efff424224..470bdf650b50 100644
--- a/fs/gfs2/locking/dlm/mount.c
+++ b/fs/gfs2/locking/dlm/mount.c
@@ -236,6 +236,27 @@ static void gdlm_withdraw(void *lockspace)
236 gdlm_kobject_release(ls); 236 gdlm_kobject_release(ls);
237} 237}
238 238
239static int gdlm_plock(void *lockspace, struct lm_lockname *name,
240 struct file *file, int cmd, struct file_lock *fl)
241{
242 struct gdlm_ls *ls = lockspace;
243 return dlm_posix_lock(ls->dlm_lockspace, name->ln_number, file, cmd, fl);
244}
245
246static int gdlm_punlock(void *lockspace, struct lm_lockname *name,
247 struct file *file, struct file_lock *fl)
248{
249 struct gdlm_ls *ls = lockspace;
250 return dlm_posix_unlock(ls->dlm_lockspace, name->ln_number, file, fl);
251}
252
253static int gdlm_plock_get(void *lockspace, struct lm_lockname *name,
254 struct file *file, struct file_lock *fl)
255{
256 struct gdlm_ls *ls = lockspace;
257 return dlm_posix_get(ls->dlm_lockspace, name->ln_number, file, fl);
258}
259
239const struct lm_lockops gdlm_ops = { 260const struct lm_lockops gdlm_ops = {
240 .lm_proto_name = "lock_dlm", 261 .lm_proto_name = "lock_dlm",
241 .lm_mount = gdlm_mount, 262 .lm_mount = gdlm_mount,
diff --git a/fs/gfs2/locking/dlm/plock.c b/fs/gfs2/locking/dlm/plock.c
deleted file mode 100644
index 2ebd374b3143..000000000000
--- a/fs/gfs2/locking/dlm/plock.c
+++ /dev/null
@@ -1,406 +0,0 @@
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
16static spinlock_t ops_lock;
17static struct list_head send_list;
18static struct list_head recv_list;
19static wait_queue_head_t send_wq;
20static wait_queue_head_t recv_wq;
21
22struct plock_op {
23 struct list_head list;
24 int done;
25 struct gdlm_plock_info info;
26};
27
28struct plock_xop {
29 struct plock_op xop;
30 void *callback;
31 void *fl;
32 void *file;
33 struct file_lock flc;
34};
35
36
37static 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
44static 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
61static 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
71int 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 if (fl->fl_lmops && fl->fl_lmops->fl_grant) {
93 /* fl_owner is lockd which doesn't distinguish
94 processes on the nfs client */
95 op->info.owner = (__u64) fl->fl_pid;
96 xop->callback = fl->fl_lmops->fl_grant;
97 locks_init_lock(&xop->flc);
98 locks_copy_lock(&xop->flc, fl);
99 xop->fl = fl;
100 xop->file = file;
101 } else {
102 op->info.owner = (__u64)(long) fl->fl_owner;
103 xop->callback = NULL;
104 }
105
106 send_op(op);
107
108 if (xop->callback == NULL)
109 wait_event(recv_wq, (op->done != 0));
110 else
111 return -EINPROGRESS;
112
113 spin_lock(&ops_lock);
114 if (!list_empty(&op->list)) {
115 printk(KERN_INFO "plock op on list\n");
116 list_del(&op->list);
117 }
118 spin_unlock(&ops_lock);
119
120 rv = op->info.rv;
121
122 if (!rv) {
123 if (posix_lock_file_wait(file, fl) < 0)
124 log_error("gdlm_plock: vfs lock error %x,%llx",
125 name->ln_type,
126 (unsigned long long)name->ln_number);
127 }
128
129 kfree(xop);
130 return rv;
131}
132
133/* Returns failure iff a succesful lock operation should be canceled */
134static int gdlm_plock_callback(struct plock_op *op)
135{
136 struct file *file;
137 struct file_lock *fl;
138 struct file_lock *flc;
139 int (*notify)(void *, void *, int) = NULL;
140 struct plock_xop *xop = (struct plock_xop *)op;
141 int rv = 0;
142
143 spin_lock(&ops_lock);
144 if (!list_empty(&op->list)) {
145 printk(KERN_INFO "plock op on list\n");
146 list_del(&op->list);
147 }
148 spin_unlock(&ops_lock);
149
150 /* check if the following 2 are still valid or make a copy */
151 file = xop->file;
152 flc = &xop->flc;
153 fl = xop->fl;
154 notify = xop->callback;
155
156 if (op->info.rv) {
157 notify(flc, NULL, op->info.rv);
158 goto out;
159 }
160
161 /* got fs lock; bookkeep locally as well: */
162 flc->fl_flags &= ~FL_SLEEP;
163 if (posix_lock_file(file, flc, NULL)) {
164 /*
165 * This can only happen in the case of kmalloc() failure.
166 * The filesystem's own lock is the authoritative lock,
167 * so a failure to get the lock locally is not a disaster.
168 * As long as GFS cannot reliably cancel locks (especially
169 * in a low-memory situation), we're better off ignoring
170 * this failure than trying to recover.
171 */
172 log_error("gdlm_plock: vfs lock error file %p fl %p",
173 file, fl);
174 }
175
176 rv = notify(flc, NULL, 0);
177 if (rv) {
178 /* XXX: We need to cancel the fs lock here: */
179 printk("gfs2 lock granted after lock request failed;"
180 " dangling lock!\n");
181 goto out;
182 }
183
184out:
185 kfree(xop);
186 return rv;
187}
188
189int gdlm_punlock(void *lockspace, struct lm_lockname *name,
190 struct file *file, struct file_lock *fl)
191{
192 struct gdlm_ls *ls = lockspace;
193 struct plock_op *op;
194 int rv;
195
196 op = kzalloc(sizeof(*op), GFP_KERNEL);
197 if (!op)
198 return -ENOMEM;
199
200 if (posix_lock_file_wait(file, fl) < 0)
201 log_error("gdlm_punlock: vfs unlock error %x,%llx",
202 name->ln_type, (unsigned long long)name->ln_number);
203
204 op->info.optype = GDLM_PLOCK_OP_UNLOCK;
205 op->info.pid = fl->fl_pid;
206 op->info.fsid = ls->id;
207 op->info.number = name->ln_number;
208 op->info.start = fl->fl_start;
209 op->info.end = fl->fl_end;
210 if (fl->fl_lmops && fl->fl_lmops->fl_grant)
211 op->info.owner = (__u64) fl->fl_pid;
212 else
213 op->info.owner = (__u64)(long) fl->fl_owner;
214
215 send_op(op);
216 wait_event(recv_wq, (op->done != 0));
217
218 spin_lock(&ops_lock);
219 if (!list_empty(&op->list)) {
220 printk(KERN_INFO "punlock op on list\n");
221 list_del(&op->list);
222 }
223 spin_unlock(&ops_lock);
224
225 rv = op->info.rv;
226
227 if (rv == -ENOENT)
228 rv = 0;
229
230 kfree(op);
231 return rv;
232}
233
234int gdlm_plock_get(void *lockspace, struct lm_lockname *name,
235 struct file *file, struct file_lock *fl)
236{
237 struct gdlm_ls *ls = lockspace;
238 struct plock_op *op;
239 int rv;
240
241 op = kzalloc(sizeof(*op), GFP_KERNEL);
242 if (!op)
243 return -ENOMEM;
244
245 op->info.optype = GDLM_PLOCK_OP_GET;
246 op->info.pid = fl->fl_pid;
247 op->info.ex = (fl->fl_type == F_WRLCK);
248 op->info.fsid = ls->id;
249 op->info.number = name->ln_number;
250 op->info.start = fl->fl_start;
251 op->info.end = fl->fl_end;
252 if (fl->fl_lmops && fl->fl_lmops->fl_grant)
253 op->info.owner = (__u64) fl->fl_pid;
254 else
255 op->info.owner = (__u64)(long) fl->fl_owner;
256
257 send_op(op);
258 wait_event(recv_wq, (op->done != 0));
259
260 spin_lock(&ops_lock);
261 if (!list_empty(&op->list)) {
262 printk(KERN_INFO "plock_get op on list\n");
263 list_del(&op->list);
264 }
265 spin_unlock(&ops_lock);
266
267 /* info.rv from userspace is 1 for conflict, 0 for no-conflict,
268 -ENOENT if there are no locks on the file */
269
270 rv = op->info.rv;
271
272 fl->fl_type = F_UNLCK;
273 if (rv == -ENOENT)
274 rv = 0;
275 else if (rv > 0) {
276 fl->fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK;
277 fl->fl_pid = op->info.pid;
278 fl->fl_start = op->info.start;
279 fl->fl_end = op->info.end;
280 rv = 0;
281 }
282
283 kfree(op);
284 return rv;
285}
286
287/* a read copies out one plock request from the send list */
288static ssize_t dev_read(struct file *file, char __user *u, size_t count,
289 loff_t *ppos)
290{
291 struct gdlm_plock_info info;
292 struct plock_op *op = NULL;
293
294 if (count < sizeof(info))
295 return -EINVAL;
296
297 spin_lock(&ops_lock);
298 if (!list_empty(&send_list)) {
299 op = list_entry(send_list.next, struct plock_op, list);
300 list_move(&op->list, &recv_list);
301 memcpy(&info, &op->info, sizeof(info));
302 }
303 spin_unlock(&ops_lock);
304
305 if (!op)
306 return -EAGAIN;
307
308 if (copy_to_user(u, &info, sizeof(info)))
309 return -EFAULT;
310 return sizeof(info);
311}
312
313/* a write copies in one plock result that should match a plock_op
314 on the recv list */
315static ssize_t dev_write(struct file *file, const char __user *u, size_t count,
316 loff_t *ppos)
317{
318 struct gdlm_plock_info info;
319 struct plock_op *op;
320 int found = 0;
321
322 if (count != sizeof(info))
323 return -EINVAL;
324
325 if (copy_from_user(&info, u, sizeof(info)))
326 return -EFAULT;
327
328 if (check_version(&info))
329 return -EINVAL;
330
331 spin_lock(&ops_lock);
332 list_for_each_entry(op, &recv_list, list) {
333 if (op->info.fsid == info.fsid && op->info.number == info.number &&
334 op->info.owner == info.owner) {
335 list_del_init(&op->list);
336 found = 1;
337 op->done = 1;
338 memcpy(&op->info, &info, sizeof(info));
339 break;
340 }
341 }
342 spin_unlock(&ops_lock);
343
344 if (found) {
345 struct plock_xop *xop;
346 xop = (struct plock_xop *)op;
347 if (xop->callback)
348 count = gdlm_plock_callback(op);
349 else
350 wake_up(&recv_wq);
351 } else
352 printk(KERN_INFO "gdlm dev_write no op %x %llx\n", info.fsid,
353 (unsigned long long)info.number);
354 return count;
355}
356
357static unsigned int dev_poll(struct file *file, poll_table *wait)
358{
359 unsigned int mask = 0;
360
361 poll_wait(file, &send_wq, wait);
362
363 spin_lock(&ops_lock);
364 if (!list_empty(&send_list))
365 mask = POLLIN | POLLRDNORM;
366 spin_unlock(&ops_lock);
367
368 return mask;
369}
370
371static const struct file_operations dev_fops = {
372 .read = dev_read,
373 .write = dev_write,
374 .poll = dev_poll,
375 .owner = THIS_MODULE
376};
377
378static struct miscdevice plock_dev_misc = {
379 .minor = MISC_DYNAMIC_MINOR,
380 .name = GDLM_PLOCK_MISC_NAME,
381 .fops = &dev_fops
382};
383
384int gdlm_plock_init(void)
385{
386 int rv;
387
388 spin_lock_init(&ops_lock);
389 INIT_LIST_HEAD(&send_list);
390 INIT_LIST_HEAD(&recv_list);
391 init_waitqueue_head(&send_wq);
392 init_waitqueue_head(&recv_wq);
393
394 rv = misc_register(&plock_dev_misc);
395 if (rv)
396 printk(KERN_INFO "gdlm_plock_init: misc_register failed %d",
397 rv);
398 return rv;
399}
400
401void gdlm_plock_exit(void)
402{
403 if (misc_deregister(&plock_dev_misc) < 0)
404 printk(KERN_INFO "gdlm_plock_exit: misc_deregister failed");
405}
406
generated by cgit v1.2.2 (git 2.25.0) at 2025-11-08 13:01:38 -0500