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