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