?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: hda - Add missing printk argument in previous patch
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / fs / dlm / user.c
bloba4bfd31ac45bec4ad5e1010e0ad6a386a338f18b
1 /*
2 * Copyright (C) 2006-2010 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 v.2.
7 */
8
9 #include <linux/miscdevice.h>
10 #include <linux/init.h>
11 #include <linux/wait.h>
12 #include <linux/module.h>
13 #include <linux/file.h>
14 #include <linux/fs.h>
15 #include <linux/poll.h>
16 #include <linux/signal.h>
17 #include <linux/spinlock.h>
18 #include <linux/dlm.h>
19 #include <linux/dlm_device.h>
20
21 #include "dlm_internal.h"
22 #include "lockspace.h"
23 #include "lock.h"
24 #include "lvb_table.h"
25 #include "user.h"
26
27 static const char name_prefix[] = "dlm";
28 static const struct file_operations device_fops;
29 static atomic_t dlm_monitor_opened;
30 static int dlm_monitor_unused = 1;
31
32 #ifdef CONFIG_COMPAT
33
34 struct dlm_lock_params32 {
35 __u8 mode;
36 __u8 namelen;
37 __u16 unused;
38 __u32 flags;
39 __u32 lkid;
40 __u32 parent;
41 __u64 xid;
42 __u64 timeout;
43 __u32 castparam;
44 __u32 castaddr;
45 __u32 bastparam;
46 __u32 bastaddr;
47 __u32 lksb;
48 char lvb[DLM_USER_LVB_LEN];
49 char name[0];
50 };
51
52 struct dlm_write_request32 {
53 __u32 version[3];
54 __u8 cmd;
55 __u8 is64bit;
56 __u8 unused[2];
57
58 union {
59 struct dlm_lock_params32 lock;
60 struct dlm_lspace_params lspace;
61 struct dlm_purge_params purge;
62 } i;
63 };
64
65 struct dlm_lksb32 {
66 __u32 sb_status;
67 __u32 sb_lkid;
68 __u8 sb_flags;
69 __u32 sb_lvbptr;
70 };
71
72 struct dlm_lock_result32 {
73 __u32 version[3];
74 __u32 length;
75 __u32 user_astaddr;
76 __u32 user_astparam;
77 __u32 user_lksb;
78 struct dlm_lksb32 lksb;
79 __u8 bast_mode;
80 __u8 unused[3];
81 /* Offsets may be zero if no data is present */
82 __u32 lvb_offset;
83 };
84
85 static void compat_input(struct dlm_write_request *kb,
86 struct dlm_write_request32 *kb32,
87 int namelen)
88 {
89 kb->version[0] = kb32->version[0];
90 kb->version[1] = kb32->version[1];
91 kb->version[2] = kb32->version[2];
92
93 kb->cmd = kb32->cmd;
94 kb->is64bit = kb32->is64bit;
95 if (kb->cmd == DLM_USER_CREATE_LOCKSPACE ||
96 kb->cmd == DLM_USER_REMOVE_LOCKSPACE) {
97 kb->i.lspace.flags = kb32->i.lspace.flags;
98 kb->i.lspace.minor = kb32->i.lspace.minor;
99 memcpy(kb->i.lspace.name, kb32->i.lspace.name, namelen);
100 } else if (kb->cmd == DLM_USER_PURGE) {
101 kb->i.purge.nodeid = kb32->i.purge.nodeid;
102 kb->i.purge.pid = kb32->i.purge.pid;
103 } else {
104 kb->i.lock.mode = kb32->i.lock.mode;
105 kb->i.lock.namelen = kb32->i.lock.namelen;
106 kb->i.lock.flags = kb32->i.lock.flags;
107 kb->i.lock.lkid = kb32->i.lock.lkid;
108 kb->i.lock.parent = kb32->i.lock.parent;
109 kb->i.lock.xid = kb32->i.lock.xid;
110 kb->i.lock.timeout = kb32->i.lock.timeout;
111 kb->i.lock.castparam = (void *)(long)kb32->i.lock.castparam;
112 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr;
113 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam;
114 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr;
115 kb->i.lock.lksb = (void *)(long)kb32->i.lock.lksb;
116 memcpy(kb->i.lock.lvb, kb32->i.lock.lvb, DLM_USER_LVB_LEN);
117 memcpy(kb->i.lock.name, kb32->i.lock.name, namelen);
118 }
119 }
120
121 static void compat_output(struct dlm_lock_result *res,
122 struct dlm_lock_result32 *res32)
123 {
124 res32->version[0] = res->version[0];
125 res32->version[1] = res->version[1];
126 res32->version[2] = res->version[2];
127
128 res32->user_astaddr = (__u32)(long)res->user_astaddr;
129 res32->user_astparam = (__u32)(long)res->user_astparam;
130 res32->user_lksb = (__u32)(long)res->user_lksb;
131 res32->bast_mode = res->bast_mode;
132
133 res32->lvb_offset = res->lvb_offset;
134 res32->length = res->length;
135
136 res32->lksb.sb_status = res->lksb.sb_status;
137 res32->lksb.sb_flags = res->lksb.sb_flags;
138 res32->lksb.sb_lkid = res->lksb.sb_lkid;
139 res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr;
140 }
141 #endif
142
143 /* Figure out if this lock is at the end of its life and no longer
144 available for the application to use. The lkb still exists until
145 the final ast is read. A lock becomes EOL in three situations:
146 1. a noqueue request fails with EAGAIN
147 2. an unlock completes with EUNLOCK
148 3. a cancel of a waiting request completes with ECANCEL/EDEADLK
149 An EOL lock needs to be removed from the process's list of locks.
150 And we can't allow any new operation on an EOL lock. This is
151 not related to the lifetime of the lkb struct which is managed
152 entirely by refcount. */
153
154 static int lkb_is_endoflife(struct dlm_lkb *lkb, int sb_status, int type)
155 {
156 switch (sb_status) {
157 case -DLM_EUNLOCK:
158 return 1;
159 case -DLM_ECANCEL:
160 case -ETIMEDOUT:
161 case -EDEADLK:
162 if (lkb->lkb_grmode == DLM_LOCK_IV)
163 return 1;
164 break;
165 case -EAGAIN:
166 if (type == AST_COMP && lkb->lkb_grmode == DLM_LOCK_IV)
167 return 1;
168 break;
169 }
170 return 0;
171 }
172
173 /* we could possibly check if the cancel of an orphan has resulted in the lkb
174 being removed and then remove that lkb from the orphans list and free it */
175
176 void dlm_user_add_ast(struct dlm_lkb *lkb, int type, int mode)
177 {
178 struct dlm_ls *ls;
179 struct dlm_user_args *ua;
180 struct dlm_user_proc *proc;
181 int eol = 0, ast_type;
182
183 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
184 return;
185
186 ls = lkb->lkb_resource->res_ls;
187 mutex_lock(&ls->ls_clear_proc_locks);
188
189 /* If ORPHAN/DEAD flag is set, it means the process is dead so an ast
190 can't be delivered. For ORPHAN's, dlm_clear_proc_locks() freed
191 lkb->ua so we can't try to use it. This second check is necessary
192 for cases where a completion ast is received for an operation that
193 began before clear_proc_locks did its cancel/unlock. */
194
195 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
196 goto out;
197
198 DLM_ASSERT(lkb->lkb_ua, dlm_print_lkb(lkb););
199 ua = lkb->lkb_ua;
200 proc = ua->proc;
201
202 if (type == AST_BAST && ua->bastaddr == NULL)
203 goto out;
204
205 spin_lock(&proc->asts_spin);
206
207 ast_type = lkb->lkb_ast_type;
208 lkb->lkb_ast_type |= type;
209 if (type == AST_BAST)
210 lkb->lkb_bastmode = mode;
211 else
212 lkb->lkb_castmode = mode;
213
214 if (!ast_type) {
215 kref_get(&lkb->lkb_ref);
216 list_add_tail(&lkb->lkb_astqueue, &proc->asts);
217 wake_up_interruptible(&proc->wait);
218 }
219 if (type == AST_COMP && (ast_type & AST_COMP))
220 log_debug(ls, "ast overlap %x status %x %x",
221 lkb->lkb_id, ua->lksb.sb_status, lkb->lkb_flags);
222
223 eol = lkb_is_endoflife(lkb, ua->lksb.sb_status, type);
224 if (eol) {
225 lkb->lkb_ast_type &= ~AST_BAST;
226 lkb->lkb_flags |= DLM_IFL_ENDOFLIFE;
227 }
228
229 /* We want to copy the lvb to userspace when the completion
230 ast is read if the status is 0, the lock has an lvb and
231 lvb_ops says we should. We could probably have set_lvb_lock()
232 set update_user_lvb instead and not need old_mode */
233
234 if ((lkb->lkb_ast_type & AST_COMP) &&
235 (lkb->lkb_lksb->sb_status == 0) &&
236 lkb->lkb_lksb->sb_lvbptr &&
237 dlm_lvb_operations[ua->old_mode + 1][lkb->lkb_grmode + 1])
238 ua->update_user_lvb = 1;
239 else
240 ua->update_user_lvb = 0;
241
242 spin_unlock(&proc->asts_spin);
243
244 if (eol) {
245 spin_lock(&proc->locks_spin);
246 if (!list_empty(&lkb->lkb_ownqueue)) {
247 list_del_init(&lkb->lkb_ownqueue);
248 dlm_put_lkb(lkb);
249 }
250 spin_unlock(&proc->locks_spin);
251 }
252 out:
253 mutex_unlock(&ls->ls_clear_proc_locks);
254 }
255
256 static int device_user_lock(struct dlm_user_proc *proc,
257 struct dlm_lock_params *params)
258 {
259 struct dlm_ls *ls;
260 struct dlm_user_args *ua;
261 int error = -ENOMEM;
262
263 ls = dlm_find_lockspace_local(proc->lockspace);
264 if (!ls)
265 return -ENOENT;
266
267 if (!params->castaddr || !params->lksb) {
268 error = -EINVAL;
269 goto out;
270 }
271
272 ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
273 if (!ua)
274 goto out;
275 ua->proc = proc;
276 ua->user_lksb = params->lksb;
277 ua->castparam = params->castparam;
278 ua->castaddr = params->castaddr;
279 ua->bastparam = params->bastparam;
280 ua->bastaddr = params->bastaddr;
281 ua->xid = params->xid;
282
283 if (params->flags & DLM_LKF_CONVERT)
284 error = dlm_user_convert(ls, ua,
285 params->mode, params->flags,
286 params->lkid, params->lvb,
287 (unsigned long) params->timeout);
288 else {
289 error = dlm_user_request(ls, ua,
290 params->mode, params->flags,
291 params->name, params->namelen,
292 (unsigned long) params->timeout);
293 if (!error)
294 error = ua->lksb.sb_lkid;
295 }
296 out:
297 dlm_put_lockspace(ls);
298 return error;
299 }
300
301 static int device_user_unlock(struct dlm_user_proc *proc,
302 struct dlm_lock_params *params)
303 {
304 struct dlm_ls *ls;
305 struct dlm_user_args *ua;
306 int error = -ENOMEM;
307
308 ls = dlm_find_lockspace_local(proc->lockspace);
309 if (!ls)
310 return -ENOENT;
311
312 ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
313 if (!ua)
314 goto out;
315 ua->proc = proc;
316 ua->user_lksb = params->lksb;
317 ua->castparam = params->castparam;
318 ua->castaddr = params->castaddr;
319
320 if (params->flags & DLM_LKF_CANCEL)
321 error = dlm_user_cancel(ls, ua, params->flags, params->lkid);
322 else
323 error = dlm_user_unlock(ls, ua, params->flags, params->lkid,
324 params->lvb);
325 out:
326 dlm_put_lockspace(ls);
327 return error;
328 }
329
330 static int device_user_deadlock(struct dlm_user_proc *proc,
331 struct dlm_lock_params *params)
332 {
333 struct dlm_ls *ls;
334 int error;
335
336 ls = dlm_find_lockspace_local(proc->lockspace);
337 if (!ls)
338 return -ENOENT;
339
340 error = dlm_user_deadlock(ls, params->flags, params->lkid);
341
342 dlm_put_lockspace(ls);
343 return error;
344 }
345
346 static int dlm_device_register(struct dlm_ls *ls, char *name)
347 {
348 int error, len;
349
350 /* The device is already registered. This happens when the
351 lockspace is created multiple times from userspace. */
352 if (ls->ls_device.name)
353 return 0;
354
355 error = -ENOMEM;
356 len = strlen(name) + strlen(name_prefix) + 2;
357 ls->ls_device.name = kzalloc(len, GFP_NOFS);
358 if (!ls->ls_device.name)
359 goto fail;
360
361 snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix,
362 name);
363 ls->ls_device.fops = &device_fops;
364 ls->ls_device.minor = MISC_DYNAMIC_MINOR;
365
366 error = misc_register(&ls->ls_device);
367 if (error) {
368 kfree(ls->ls_device.name);
369 }
370 fail:
371 return error;
372 }
373
374 int dlm_device_deregister(struct dlm_ls *ls)
375 {
376 int error;
377
378 /* The device is not registered. This happens when the lockspace
379 was never used from userspace, or when device_create_lockspace()
380 calls dlm_release_lockspace() after the register fails. */
381 if (!ls->ls_device.name)
382 return 0;
383
384 error = misc_deregister(&ls->ls_device);
385 if (!error)
386 kfree(ls->ls_device.name);
387 return error;
388 }
389
390 static int device_user_purge(struct dlm_user_proc *proc,
391 struct dlm_purge_params *params)
392 {
393 struct dlm_ls *ls;
394 int error;
395
396 ls = dlm_find_lockspace_local(proc->lockspace);
397 if (!ls)
398 return -ENOENT;
399
400 error = dlm_user_purge(ls, proc, params->nodeid, params->pid);
401
402 dlm_put_lockspace(ls);
403 return error;
404 }
405
406 static int device_create_lockspace(struct dlm_lspace_params *params)
407 {
408 dlm_lockspace_t *lockspace;
409 struct dlm_ls *ls;
410 int error;
411
412 if (!capable(CAP_SYS_ADMIN))
413 return -EPERM;
414
415 error = dlm_new_lockspace(params->name, strlen(params->name),
416 &lockspace, params->flags, DLM_USER_LVB_LEN);
417 if (error)
418 return error;
419
420 ls = dlm_find_lockspace_local(lockspace);
421 if (!ls)
422 return -ENOENT;
423
424 error = dlm_device_register(ls, params->name);
425 dlm_put_lockspace(ls);
426
427 if (error)
428 dlm_release_lockspace(lockspace, 0);
429 else
430 error = ls->ls_device.minor;
431
432 return error;
433 }
434
435 static int device_remove_lockspace(struct dlm_lspace_params *params)
436 {
437 dlm_lockspace_t *lockspace;
438 struct dlm_ls *ls;
439 int error, force = 0;
440
441 if (!capable(CAP_SYS_ADMIN))
442 return -EPERM;
443
444 ls = dlm_find_lockspace_device(params->minor);
445 if (!ls)
446 return -ENOENT;
447
448 if (params->flags & DLM_USER_LSFLG_FORCEFREE)
449 force = 2;
450
451 lockspace = ls->ls_local_handle;
452 dlm_put_lockspace(ls);
453
454 /* The final dlm_release_lockspace waits for references to go to
455 zero, so all processes will need to close their device for the
456 ls before the release will proceed. release also calls the
457 device_deregister above. Converting a positive return value
458 from release to zero means that userspace won't know when its
459 release was the final one, but it shouldn't need to know. */
460
461 error = dlm_release_lockspace(lockspace, force);
462 if (error > 0)
463 error = 0;
464 return error;
465 }
466
467 /* Check the user's version matches ours */
468 static int check_version(struct dlm_write_request *req)
469 {
470 if (req->version[0] != DLM_DEVICE_VERSION_MAJOR ||
471 (req->version[0] == DLM_DEVICE_VERSION_MAJOR &&
472 req->version[1] > DLM_DEVICE_VERSION_MINOR)) {
473
474 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch "
475 "user (%d.%d.%d) kernel (%d.%d.%d)\n",
476 current->comm,
477 task_pid_nr(current),
478 req->version[0],
479 req->version[1],
480 req->version[2],
481 DLM_DEVICE_VERSION_MAJOR,
482 DLM_DEVICE_VERSION_MINOR,
483 DLM_DEVICE_VERSION_PATCH);
484 return -EINVAL;
485 }
486 return 0;
487 }
488
489 /*
490 * device_write
491 *
492 * device_user_lock
493 * dlm_user_request -> request_lock
494 * dlm_user_convert -> convert_lock
495 *
496 * device_user_unlock
497 * dlm_user_unlock -> unlock_lock
498 * dlm_user_cancel -> cancel_lock
499 *
500 * device_create_lockspace
501 * dlm_new_lockspace
502 *
503 * device_remove_lockspace
504 * dlm_release_lockspace
505 */
506
507 /* a write to a lockspace device is a lock or unlock request, a write
508 to the control device is to create/remove a lockspace */
509
510 static ssize_t device_write(struct file *file, const char __user *buf,
511 size_t count, loff_t *ppos)
512 {
513 struct dlm_user_proc *proc = file->private_data;
514 struct dlm_write_request *kbuf;
515 sigset_t tmpsig, allsigs;
516 int error;
517
518 #ifdef CONFIG_COMPAT
519 if (count < sizeof(struct dlm_write_request32))
520 #else
521 if (count < sizeof(struct dlm_write_request))
522 #endif
523 return -EINVAL;
524
525 kbuf = kzalloc(count + 1, GFP_NOFS);
526 if (!kbuf)
527 return -ENOMEM;
528
529 if (copy_from_user(kbuf, buf, count)) {
530 error = -EFAULT;
531 goto out_free;
532 }
533
534 if (check_version(kbuf)) {
535 error = -EBADE;
536 goto out_free;
537 }
538
539 #ifdef CONFIG_COMPAT
540 if (!kbuf->is64bit) {
541 struct dlm_write_request32 *k32buf;
542 int namelen = 0;
543
544 if (count > sizeof(struct dlm_write_request32))
545 namelen = count - sizeof(struct dlm_write_request32);
546
547 k32buf = (struct dlm_write_request32 *)kbuf;
548
549 /* add 1 after namelen so that the name string is terminated */
550 kbuf = kzalloc(sizeof(struct dlm_write_request) + namelen + 1,
551 GFP_NOFS);
552 if (!kbuf) {
553 kfree(k32buf);
554 return -ENOMEM;
555 }
556
557 if (proc)
558 set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags);
559
560 compat_input(kbuf, k32buf, namelen);
561 kfree(k32buf);
562 }
563 #endif
564
565 /* do we really need this? can a write happen after a close? */
566 if ((kbuf->cmd == DLM_USER_LOCK || kbuf->cmd == DLM_USER_UNLOCK) &&
567 (proc && test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))) {
568 error = -EINVAL;
569 goto out_free;
570 }
571
572 sigfillset(&allsigs);
573 sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
574
575 error = -EINVAL;
576
577 switch (kbuf->cmd)
578 {
579 case DLM_USER_LOCK:
580 if (!proc) {
581 log_print("no locking on control device");
582 goto out_sig;
583 }
584 error = device_user_lock(proc, &kbuf->i.lock);
585 break;
586
587 case DLM_USER_UNLOCK:
588 if (!proc) {
589 log_print("no locking on control device");
590 goto out_sig;
591 }
592 error = device_user_unlock(proc, &kbuf->i.lock);
593 break;
594
595 case DLM_USER_DEADLOCK:
596 if (!proc) {
597 log_print("no locking on control device");
598 goto out_sig;
599 }
600 error = device_user_deadlock(proc, &kbuf->i.lock);
601 break;
602
603 case DLM_USER_CREATE_LOCKSPACE:
604 if (proc) {
605 log_print("create/remove only on control device");
606 goto out_sig;
607 }
608 error = device_create_lockspace(&kbuf->i.lspace);
609 break;
610
611 case DLM_USER_REMOVE_LOCKSPACE:
612 if (proc) {
613 log_print("create/remove only on control device");
614 goto out_sig;
615 }
616 error = device_remove_lockspace(&kbuf->i.lspace);
617 break;
618
619 case DLM_USER_PURGE:
620 if (!proc) {
621 log_print("no locking on control device");
622 goto out_sig;
623 }
624 error = device_user_purge(proc, &kbuf->i.purge);
625 break;
626
627 default:
628 log_print("Unknown command passed to DLM device : %d\n",
629 kbuf->cmd);
630 }
631
632 out_sig:
633 sigprocmask(SIG_SETMASK, &tmpsig, NULL);
634 recalc_sigpending();
635 out_free:
636 kfree(kbuf);
637 return error;
638 }
639
640 /* Every process that opens the lockspace device has its own "proc" structure
641 hanging off the open file that's used to keep track of locks owned by the
642 process and asts that need to be delivered to the process. */
643
644 static int device_open(struct inode *inode, struct file *file)
645 {
646 struct dlm_user_proc *proc;
647 struct dlm_ls *ls;
648
649 ls = dlm_find_lockspace_device(iminor(inode));
650 if (!ls)
651 return -ENOENT;
652
653 proc = kzalloc(sizeof(struct dlm_user_proc), GFP_NOFS);
654 if (!proc) {
655 dlm_put_lockspace(ls);
656 return -ENOMEM;
657 }
658
659 proc->lockspace = ls->ls_local_handle;
660 INIT_LIST_HEAD(&proc->asts);
661 INIT_LIST_HEAD(&proc->locks);
662 INIT_LIST_HEAD(&proc->unlocking);
663 spin_lock_init(&proc->asts_spin);
664 spin_lock_init(&proc->locks_spin);
665 init_waitqueue_head(&proc->wait);
666 file->private_data = proc;
667
668 return 0;
669 }
670
671 static int device_close(struct inode *inode, struct file *file)
672 {
673 struct dlm_user_proc *proc = file->private_data;
674 struct dlm_ls *ls;
675 sigset_t tmpsig, allsigs;
676
677 ls = dlm_find_lockspace_local(proc->lockspace);
678 if (!ls)
679 return -ENOENT;
680
681 sigfillset(&allsigs);
682 sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
683
684 set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags);
685
686 dlm_clear_proc_locks(ls, proc);
687
688 /* at this point no more lkb's should exist for this lockspace,
689 so there's no chance of dlm_user_add_ast() being called and
690 looking for lkb->ua->proc */
691
692 kfree(proc);
693 file->private_data = NULL;
694
695 dlm_put_lockspace(ls);
696 dlm_put_lockspace(ls); /* for the find in device_open() */
697
698 /* FIXME: AUTOFREE: if this ls is no longer used do
699 device_remove_lockspace() */
700
701 sigprocmask(SIG_SETMASK, &tmpsig, NULL);
702 recalc_sigpending();
703
704 return 0;
705 }
706
707 static int copy_result_to_user(struct dlm_user_args *ua, int compat, int type,
708 int bmode, char __user *buf, size_t count)
709 {
710 #ifdef CONFIG_COMPAT
711 struct dlm_lock_result32 result32;
712 #endif
713 struct dlm_lock_result result;
714 void *resultptr;
715 int error=0;
716 int len;
717 int struct_len;
718
719 memset(&result, 0, sizeof(struct dlm_lock_result));
720 result.version[0] = DLM_DEVICE_VERSION_MAJOR;
721 result.version[1] = DLM_DEVICE_VERSION_MINOR;
722 result.version[2] = DLM_DEVICE_VERSION_PATCH;
723 memcpy(&result.lksb, &ua->lksb, sizeof(struct dlm_lksb));
724 result.user_lksb = ua->user_lksb;
725
726 /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated
727 in a conversion unless the conversion is successful. See code
728 in dlm_user_convert() for updating ua from ua_tmp. OpenVMS, though,
729 notes that a new blocking AST address and parameter are set even if
730 the conversion fails, so maybe we should just do that. */
731
732 if (type == AST_BAST) {
733 result.user_astaddr = ua->bastaddr;
734 result.user_astparam = ua->bastparam;
735 result.bast_mode = bmode;
736 } else {
737 result.user_astaddr = ua->castaddr;
738 result.user_astparam = ua->castparam;
739 }
740
741 #ifdef CONFIG_COMPAT
742 if (compat)
743 len = sizeof(struct dlm_lock_result32);
744 else
745 #endif
746 len = sizeof(struct dlm_lock_result);
747 struct_len = len;
748
749 /* copy lvb to userspace if there is one, it's been updated, and
750 the user buffer has space for it */
751
752 if (ua->update_user_lvb && ua->lksb.sb_lvbptr &&
753 count >= len + DLM_USER_LVB_LEN) {
754 if (copy_to_user(buf+len, ua->lksb.sb_lvbptr,
755 DLM_USER_LVB_LEN)) {
756 error = -EFAULT;
757 goto out;
758 }
759
760 result.lvb_offset = len;
761 len += DLM_USER_LVB_LEN;
762 }
763
764 result.length = len;
765 resultptr = &result;
766 #ifdef CONFIG_COMPAT
767 if (compat) {
768 compat_output(&result, &result32);
769 resultptr = &result32;
770 }
771 #endif
772
773 if (copy_to_user(buf, resultptr, struct_len))
774 error = -EFAULT;
775 else
776 error = len;
777 out:
778 return error;
779 }
780
781 static int copy_version_to_user(char __user *buf, size_t count)
782 {
783 struct dlm_device_version ver;
784
785 memset(&ver, 0, sizeof(struct dlm_device_version));
786 ver.version[0] = DLM_DEVICE_VERSION_MAJOR;
787 ver.version[1] = DLM_DEVICE_VERSION_MINOR;
788 ver.version[2] = DLM_DEVICE_VERSION_PATCH;
789
790 if (copy_to_user(buf, &ver, sizeof(struct dlm_device_version)))
791 return -EFAULT;
792 return sizeof(struct dlm_device_version);
793 }
794
795 /* a read returns a single ast described in a struct dlm_lock_result */
796
797 static ssize_t device_read(struct file *file, char __user *buf, size_t count,
798 loff_t *ppos)
799 {
800 struct dlm_user_proc *proc = file->private_data;
801 struct dlm_lkb *lkb;
802 DECLARE_WAITQUEUE(wait, current);
803 int error, type=0, bmode=0, removed = 0;
804
805 if (count == sizeof(struct dlm_device_version)) {
806 error = copy_version_to_user(buf, count);
807 return error;
808 }
809
810 if (!proc) {
811 log_print("non-version read from control device %zu", count);
812 return -EINVAL;
813 }
814
815 #ifdef CONFIG_COMPAT
816 if (count < sizeof(struct dlm_lock_result32))
817 #else
818 if (count < sizeof(struct dlm_lock_result))
819 #endif
820 return -EINVAL;
821
822 /* do we really need this? can a read happen after a close? */
823 if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
824 return -EINVAL;
825
826 spin_lock(&proc->asts_spin);
827 if (list_empty(&proc->asts)) {
828 if (file->f_flags & O_NONBLOCK) {
829 spin_unlock(&proc->asts_spin);
830 return -EAGAIN;
831 }
832
833 add_wait_queue(&proc->wait, &wait);
834
835 repeat:
836 set_current_state(TASK_INTERRUPTIBLE);
837 if (list_empty(&proc->asts) && !signal_pending(current)) {
838 spin_unlock(&proc->asts_spin);
839 schedule();
840 spin_lock(&proc->asts_spin);
841 goto repeat;
842 }
843 set_current_state(TASK_RUNNING);
844 remove_wait_queue(&proc->wait, &wait);
845
846 if (signal_pending(current)) {
847 spin_unlock(&proc->asts_spin);
848 return -ERESTARTSYS;
849 }
850 }
851
852 /* there may be both completion and blocking asts to return for
853 the lkb, don't remove lkb from asts list unless no asts remain */
854
855 lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_astqueue);
856
857 if (lkb->lkb_ast_type & AST_COMP) {
858 lkb->lkb_ast_type &= ~AST_COMP;
859 type = AST_COMP;
860 } else if (lkb->lkb_ast_type & AST_BAST) {
861 lkb->lkb_ast_type &= ~AST_BAST;
862 type = AST_BAST;
863 bmode = lkb->lkb_bastmode;
864 }
865
866 if (!lkb->lkb_ast_type) {
867 list_del(&lkb->lkb_astqueue);
868 removed = 1;
869 }
870 spin_unlock(&proc->asts_spin);
871
872 error = copy_result_to_user(lkb->lkb_ua,
873 test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags),
874 type, bmode, buf, count);
875
876 /* removes reference for the proc->asts lists added by
877 dlm_user_add_ast() and may result in the lkb being freed */
878 if (removed)
879 dlm_put_lkb(lkb);
880
881 return error;
882 }
883
884 static unsigned int device_poll(struct file *file, poll_table *wait)
885 {
886 struct dlm_user_proc *proc = file->private_data;
887
888 poll_wait(file, &proc->wait, wait);
889
890 spin_lock(&proc->asts_spin);
891 if (!list_empty(&proc->asts)) {
892 spin_unlock(&proc->asts_spin);
893 return POLLIN | POLLRDNORM;
894 }
895 spin_unlock(&proc->asts_spin);
896 return 0;
897 }
898
899 int dlm_user_daemon_available(void)
900 {
901 /* dlm_controld hasn't started (or, has started, but not
902 properly populated configfs) */
903
904 if (!dlm_our_nodeid())
905 return 0;
906
907 /* This is to deal with versions of dlm_controld that don't
908 know about the monitor device. We assume that if the
909 dlm_controld was started (above), but the monitor device
910 was never opened, that it's an old version. dlm_controld
911 should open the monitor device before populating configfs. */
912
913 if (dlm_monitor_unused)
914 return 1;
915
916 return atomic_read(&dlm_monitor_opened) ? 1 : 0;
917 }
918
919 static int ctl_device_open(struct inode *inode, struct file *file)
920 {
921 file->private_data = NULL;
922 return 0;
923 }
924
925 static int ctl_device_close(struct inode *inode, struct file *file)
926 {
927 return 0;
928 }
929
930 static int monitor_device_open(struct inode *inode, struct file *file)
931 {
932 atomic_inc(&dlm_monitor_opened);
933 dlm_monitor_unused = 0;
934 return 0;
935 }
936
937 static int monitor_device_close(struct inode *inode, struct file *file)
938 {
939 if (atomic_dec_and_test(&dlm_monitor_opened))
940 dlm_stop_lockspaces();
941 return 0;
942 }
943
944 static const struct file_operations device_fops = {
945 .open = device_open,
946 .release = device_close,
947 .read = device_read,
948 .write = device_write,
949 .poll = device_poll,
950 .owner = THIS_MODULE,
951 };
952
953 static const struct file_operations ctl_device_fops = {
954 .open = ctl_device_open,
955 .release = ctl_device_close,
956 .read = device_read,
957 .write = device_write,
958 .owner = THIS_MODULE,
959 };
960
961 static struct miscdevice ctl_device = {
962 .name = "dlm-control",
963 .fops = &ctl_device_fops,
964 .minor = MISC_DYNAMIC_MINOR,
965 };
966
967 static const struct file_operations monitor_device_fops = {
968 .open = monitor_device_open,
969 .release = monitor_device_close,
970 .owner = THIS_MODULE,
971 };
972
973 static struct miscdevice monitor_device = {
974 .name = "dlm-monitor",
975 .fops = &monitor_device_fops,
976 .minor = MISC_DYNAMIC_MINOR,
977 };
978
979 int __init dlm_user_init(void)
980 {
981 int error;
982
983 atomic_set(&dlm_monitor_opened, 0);
984
985 error = misc_register(&ctl_device);
986 if (error) {
987 log_print("misc_register failed for control device");
988 goto out;
989 }
990
991 error = misc_register(&monitor_device);
992 if (error) {
993 log_print("misc_register failed for monitor device");
994 misc_deregister(&ctl_device);
995 }
996 out:
997 return error;
998 }
999
1000 void dlm_user_exit(void)
1001 {
1002 misc_deregister(&ctl_device);
1003 misc_deregister(&monitor_device);
1004 }
1005
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree