xref: /openbmc/linux/drivers/md/dm-ioctl.c (revision 32981ea5)
1 /*
2  * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
3  * Copyright (C) 2004 - 2006 Red Hat, Inc. All rights reserved.
4  *
5  * This file is released under the GPL.
6  */
7 
8 #include "dm.h"
9 
10 #include <linux/module.h>
11 #include <linux/vmalloc.h>
12 #include <linux/miscdevice.h>
13 #include <linux/init.h>
14 #include <linux/wait.h>
15 #include <linux/slab.h>
16 #include <linux/dm-ioctl.h>
17 #include <linux/hdreg.h>
18 #include <linux/compat.h>
19 
20 #include <asm/uaccess.h>
21 
22 #define DM_MSG_PREFIX "ioctl"
23 #define DM_DRIVER_EMAIL "dm-devel@redhat.com"
24 
25 /*-----------------------------------------------------------------
26  * The ioctl interface needs to be able to look up devices by
27  * name or uuid.
28  *---------------------------------------------------------------*/
29 struct hash_cell {
30 	struct list_head name_list;
31 	struct list_head uuid_list;
32 
33 	char *name;
34 	char *uuid;
35 	struct mapped_device *md;
36 	struct dm_table *new_map;
37 };
38 
39 /*
40  * A dummy definition to make RCU happy.
41  * struct dm_table should never be dereferenced in this file.
42  */
43 struct dm_table {
44 	int undefined__;
45 };
46 
47 struct vers_iter {
48     size_t param_size;
49     struct dm_target_versions *vers, *old_vers;
50     char *end;
51     uint32_t flags;
52 };
53 
54 
55 #define NUM_BUCKETS 64
56 #define MASK_BUCKETS (NUM_BUCKETS - 1)
57 static struct list_head _name_buckets[NUM_BUCKETS];
58 static struct list_head _uuid_buckets[NUM_BUCKETS];
59 
60 static void dm_hash_remove_all(bool keep_open_devices, bool mark_deferred, bool only_deferred);
61 
62 /*
63  * Guards access to both hash tables.
64  */
65 static DECLARE_RWSEM(_hash_lock);
66 
67 /*
68  * Protects use of mdptr to obtain hash cell name and uuid from mapped device.
69  */
70 static DEFINE_MUTEX(dm_hash_cells_mutex);
71 
72 static void init_buckets(struct list_head *buckets)
73 {
74 	unsigned int i;
75 
76 	for (i = 0; i < NUM_BUCKETS; i++)
77 		INIT_LIST_HEAD(buckets + i);
78 }
79 
80 static int dm_hash_init(void)
81 {
82 	init_buckets(_name_buckets);
83 	init_buckets(_uuid_buckets);
84 	return 0;
85 }
86 
87 static void dm_hash_exit(void)
88 {
89 	dm_hash_remove_all(false, false, false);
90 }
91 
92 /*-----------------------------------------------------------------
93  * Hash function:
94  * We're not really concerned with the str hash function being
95  * fast since it's only used by the ioctl interface.
96  *---------------------------------------------------------------*/
97 static unsigned int hash_str(const char *str)
98 {
99 	const unsigned int hash_mult = 2654435387U;
100 	unsigned int h = 0;
101 
102 	while (*str)
103 		h = (h + (unsigned int) *str++) * hash_mult;
104 
105 	return h & MASK_BUCKETS;
106 }
107 
108 /*-----------------------------------------------------------------
109  * Code for looking up a device by name
110  *---------------------------------------------------------------*/
111 static struct hash_cell *__get_name_cell(const char *str)
112 {
113 	struct hash_cell *hc;
114 	unsigned int h = hash_str(str);
115 
116 	list_for_each_entry (hc, _name_buckets + h, name_list)
117 		if (!strcmp(hc->name, str)) {
118 			dm_get(hc->md);
119 			return hc;
120 		}
121 
122 	return NULL;
123 }
124 
125 static struct hash_cell *__get_uuid_cell(const char *str)
126 {
127 	struct hash_cell *hc;
128 	unsigned int h = hash_str(str);
129 
130 	list_for_each_entry (hc, _uuid_buckets + h, uuid_list)
131 		if (!strcmp(hc->uuid, str)) {
132 			dm_get(hc->md);
133 			return hc;
134 		}
135 
136 	return NULL;
137 }
138 
139 static struct hash_cell *__get_dev_cell(uint64_t dev)
140 {
141 	struct mapped_device *md;
142 	struct hash_cell *hc;
143 
144 	md = dm_get_md(huge_decode_dev(dev));
145 	if (!md)
146 		return NULL;
147 
148 	hc = dm_get_mdptr(md);
149 	if (!hc) {
150 		dm_put(md);
151 		return NULL;
152 	}
153 
154 	return hc;
155 }
156 
157 /*-----------------------------------------------------------------
158  * Inserting, removing and renaming a device.
159  *---------------------------------------------------------------*/
160 static struct hash_cell *alloc_cell(const char *name, const char *uuid,
161 				    struct mapped_device *md)
162 {
163 	struct hash_cell *hc;
164 
165 	hc = kmalloc(sizeof(*hc), GFP_KERNEL);
166 	if (!hc)
167 		return NULL;
168 
169 	hc->name = kstrdup(name, GFP_KERNEL);
170 	if (!hc->name) {
171 		kfree(hc);
172 		return NULL;
173 	}
174 
175 	if (!uuid)
176 		hc->uuid = NULL;
177 
178 	else {
179 		hc->uuid = kstrdup(uuid, GFP_KERNEL);
180 		if (!hc->uuid) {
181 			kfree(hc->name);
182 			kfree(hc);
183 			return NULL;
184 		}
185 	}
186 
187 	INIT_LIST_HEAD(&hc->name_list);
188 	INIT_LIST_HEAD(&hc->uuid_list);
189 	hc->md = md;
190 	hc->new_map = NULL;
191 	return hc;
192 }
193 
194 static void free_cell(struct hash_cell *hc)
195 {
196 	if (hc) {
197 		kfree(hc->name);
198 		kfree(hc->uuid);
199 		kfree(hc);
200 	}
201 }
202 
203 /*
204  * The kdev_t and uuid of a device can never change once it is
205  * initially inserted.
206  */
207 static int dm_hash_insert(const char *name, const char *uuid, struct mapped_device *md)
208 {
209 	struct hash_cell *cell, *hc;
210 
211 	/*
212 	 * Allocate the new cells.
213 	 */
214 	cell = alloc_cell(name, uuid, md);
215 	if (!cell)
216 		return -ENOMEM;
217 
218 	/*
219 	 * Insert the cell into both hash tables.
220 	 */
221 	down_write(&_hash_lock);
222 	hc = __get_name_cell(name);
223 	if (hc) {
224 		dm_put(hc->md);
225 		goto bad;
226 	}
227 
228 	list_add(&cell->name_list, _name_buckets + hash_str(name));
229 
230 	if (uuid) {
231 		hc = __get_uuid_cell(uuid);
232 		if (hc) {
233 			list_del(&cell->name_list);
234 			dm_put(hc->md);
235 			goto bad;
236 		}
237 		list_add(&cell->uuid_list, _uuid_buckets + hash_str(uuid));
238 	}
239 	dm_get(md);
240 	mutex_lock(&dm_hash_cells_mutex);
241 	dm_set_mdptr(md, cell);
242 	mutex_unlock(&dm_hash_cells_mutex);
243 	up_write(&_hash_lock);
244 
245 	return 0;
246 
247  bad:
248 	up_write(&_hash_lock);
249 	free_cell(cell);
250 	return -EBUSY;
251 }
252 
253 static struct dm_table *__hash_remove(struct hash_cell *hc)
254 {
255 	struct dm_table *table;
256 	int srcu_idx;
257 
258 	/* remove from the dev hash */
259 	list_del(&hc->uuid_list);
260 	list_del(&hc->name_list);
261 	mutex_lock(&dm_hash_cells_mutex);
262 	dm_set_mdptr(hc->md, NULL);
263 	mutex_unlock(&dm_hash_cells_mutex);
264 
265 	table = dm_get_live_table(hc->md, &srcu_idx);
266 	if (table)
267 		dm_table_event(table);
268 	dm_put_live_table(hc->md, srcu_idx);
269 
270 	table = NULL;
271 	if (hc->new_map)
272 		table = hc->new_map;
273 	dm_put(hc->md);
274 	free_cell(hc);
275 
276 	return table;
277 }
278 
279 static void dm_hash_remove_all(bool keep_open_devices, bool mark_deferred, bool only_deferred)
280 {
281 	int i, dev_skipped;
282 	struct hash_cell *hc;
283 	struct mapped_device *md;
284 	struct dm_table *t;
285 
286 retry:
287 	dev_skipped = 0;
288 
289 	down_write(&_hash_lock);
290 
291 	for (i = 0; i < NUM_BUCKETS; i++) {
292 		list_for_each_entry(hc, _name_buckets + i, name_list) {
293 			md = hc->md;
294 			dm_get(md);
295 
296 			if (keep_open_devices &&
297 			    dm_lock_for_deletion(md, mark_deferred, only_deferred)) {
298 				dm_put(md);
299 				dev_skipped++;
300 				continue;
301 			}
302 
303 			t = __hash_remove(hc);
304 
305 			up_write(&_hash_lock);
306 
307 			if (t) {
308 				dm_sync_table(md);
309 				dm_table_destroy(t);
310 			}
311 			dm_put(md);
312 			if (likely(keep_open_devices))
313 				dm_destroy(md);
314 			else
315 				dm_destroy_immediate(md);
316 
317 			/*
318 			 * Some mapped devices may be using other mapped
319 			 * devices, so repeat until we make no further
320 			 * progress.  If a new mapped device is created
321 			 * here it will also get removed.
322 			 */
323 			goto retry;
324 		}
325 	}
326 
327 	up_write(&_hash_lock);
328 
329 	if (dev_skipped)
330 		DMWARN("remove_all left %d open device(s)", dev_skipped);
331 }
332 
333 /*
334  * Set the uuid of a hash_cell that isn't already set.
335  */
336 static void __set_cell_uuid(struct hash_cell *hc, char *new_uuid)
337 {
338 	mutex_lock(&dm_hash_cells_mutex);
339 	hc->uuid = new_uuid;
340 	mutex_unlock(&dm_hash_cells_mutex);
341 
342 	list_add(&hc->uuid_list, _uuid_buckets + hash_str(new_uuid));
343 }
344 
345 /*
346  * Changes the name of a hash_cell and returns the old name for
347  * the caller to free.
348  */
349 static char *__change_cell_name(struct hash_cell *hc, char *new_name)
350 {
351 	char *old_name;
352 
353 	/*
354 	 * Rename and move the name cell.
355 	 */
356 	list_del(&hc->name_list);
357 	old_name = hc->name;
358 
359 	mutex_lock(&dm_hash_cells_mutex);
360 	hc->name = new_name;
361 	mutex_unlock(&dm_hash_cells_mutex);
362 
363 	list_add(&hc->name_list, _name_buckets + hash_str(new_name));
364 
365 	return old_name;
366 }
367 
368 static struct mapped_device *dm_hash_rename(struct dm_ioctl *param,
369 					    const char *new)
370 {
371 	char *new_data, *old_name = NULL;
372 	struct hash_cell *hc;
373 	struct dm_table *table;
374 	struct mapped_device *md;
375 	unsigned change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0;
376 	int srcu_idx;
377 
378 	/*
379 	 * duplicate new.
380 	 */
381 	new_data = kstrdup(new, GFP_KERNEL);
382 	if (!new_data)
383 		return ERR_PTR(-ENOMEM);
384 
385 	down_write(&_hash_lock);
386 
387 	/*
388 	 * Is new free ?
389 	 */
390 	if (change_uuid)
391 		hc = __get_uuid_cell(new);
392 	else
393 		hc = __get_name_cell(new);
394 
395 	if (hc) {
396 		DMWARN("Unable to change %s on mapped device %s to one that "
397 		       "already exists: %s",
398 		       change_uuid ? "uuid" : "name",
399 		       param->name, new);
400 		dm_put(hc->md);
401 		up_write(&_hash_lock);
402 		kfree(new_data);
403 		return ERR_PTR(-EBUSY);
404 	}
405 
406 	/*
407 	 * Is there such a device as 'old' ?
408 	 */
409 	hc = __get_name_cell(param->name);
410 	if (!hc) {
411 		DMWARN("Unable to rename non-existent device, %s to %s%s",
412 		       param->name, change_uuid ? "uuid " : "", new);
413 		up_write(&_hash_lock);
414 		kfree(new_data);
415 		return ERR_PTR(-ENXIO);
416 	}
417 
418 	/*
419 	 * Does this device already have a uuid?
420 	 */
421 	if (change_uuid && hc->uuid) {
422 		DMWARN("Unable to change uuid of mapped device %s to %s "
423 		       "because uuid is already set to %s",
424 		       param->name, new, hc->uuid);
425 		dm_put(hc->md);
426 		up_write(&_hash_lock);
427 		kfree(new_data);
428 		return ERR_PTR(-EINVAL);
429 	}
430 
431 	if (change_uuid)
432 		__set_cell_uuid(hc, new_data);
433 	else
434 		old_name = __change_cell_name(hc, new_data);
435 
436 	/*
437 	 * Wake up any dm event waiters.
438 	 */
439 	table = dm_get_live_table(hc->md, &srcu_idx);
440 	if (table)
441 		dm_table_event(table);
442 	dm_put_live_table(hc->md, srcu_idx);
443 
444 	if (!dm_kobject_uevent(hc->md, KOBJ_CHANGE, param->event_nr))
445 		param->flags |= DM_UEVENT_GENERATED_FLAG;
446 
447 	md = hc->md;
448 	up_write(&_hash_lock);
449 	kfree(old_name);
450 
451 	return md;
452 }
453 
454 void dm_deferred_remove(void)
455 {
456 	dm_hash_remove_all(true, false, true);
457 }
458 
459 /*-----------------------------------------------------------------
460  * Implementation of the ioctl commands
461  *---------------------------------------------------------------*/
462 /*
463  * All the ioctl commands get dispatched to functions with this
464  * prototype.
465  */
466 typedef int (*ioctl_fn)(struct dm_ioctl *param, size_t param_size);
467 
468 static int remove_all(struct dm_ioctl *param, size_t param_size)
469 {
470 	dm_hash_remove_all(true, !!(param->flags & DM_DEFERRED_REMOVE), false);
471 	param->data_size = 0;
472 	return 0;
473 }
474 
475 /*
476  * Round up the ptr to an 8-byte boundary.
477  */
478 #define ALIGN_MASK 7
479 static inline void *align_ptr(void *ptr)
480 {
481 	return (void *) (((size_t) (ptr + ALIGN_MASK)) & ~ALIGN_MASK);
482 }
483 
484 /*
485  * Retrieves the data payload buffer from an already allocated
486  * struct dm_ioctl.
487  */
488 static void *get_result_buffer(struct dm_ioctl *param, size_t param_size,
489 			       size_t *len)
490 {
491 	param->data_start = align_ptr(param + 1) - (void *) param;
492 
493 	if (param->data_start < param_size)
494 		*len = param_size - param->data_start;
495 	else
496 		*len = 0;
497 
498 	return ((void *) param) + param->data_start;
499 }
500 
501 static int list_devices(struct dm_ioctl *param, size_t param_size)
502 {
503 	unsigned int i;
504 	struct hash_cell *hc;
505 	size_t len, needed = 0;
506 	struct gendisk *disk;
507 	struct dm_name_list *nl, *old_nl = NULL;
508 
509 	down_write(&_hash_lock);
510 
511 	/*
512 	 * Loop through all the devices working out how much
513 	 * space we need.
514 	 */
515 	for (i = 0; i < NUM_BUCKETS; i++) {
516 		list_for_each_entry (hc, _name_buckets + i, name_list) {
517 			needed += sizeof(struct dm_name_list);
518 			needed += strlen(hc->name) + 1;
519 			needed += ALIGN_MASK;
520 		}
521 	}
522 
523 	/*
524 	 * Grab our output buffer.
525 	 */
526 	nl = get_result_buffer(param, param_size, &len);
527 	if (len < needed) {
528 		param->flags |= DM_BUFFER_FULL_FLAG;
529 		goto out;
530 	}
531 	param->data_size = param->data_start + needed;
532 
533 	nl->dev = 0;	/* Flags no data */
534 
535 	/*
536 	 * Now loop through filling out the names.
537 	 */
538 	for (i = 0; i < NUM_BUCKETS; i++) {
539 		list_for_each_entry (hc, _name_buckets + i, name_list) {
540 			if (old_nl)
541 				old_nl->next = (uint32_t) ((void *) nl -
542 							   (void *) old_nl);
543 			disk = dm_disk(hc->md);
544 			nl->dev = huge_encode_dev(disk_devt(disk));
545 			nl->next = 0;
546 			strcpy(nl->name, hc->name);
547 
548 			old_nl = nl;
549 			nl = align_ptr(((void *) ++nl) + strlen(hc->name) + 1);
550 		}
551 	}
552 
553  out:
554 	up_write(&_hash_lock);
555 	return 0;
556 }
557 
558 static void list_version_get_needed(struct target_type *tt, void *needed_param)
559 {
560     size_t *needed = needed_param;
561 
562     *needed += sizeof(struct dm_target_versions);
563     *needed += strlen(tt->name);
564     *needed += ALIGN_MASK;
565 }
566 
567 static void list_version_get_info(struct target_type *tt, void *param)
568 {
569     struct vers_iter *info = param;
570 
571     /* Check space - it might have changed since the first iteration */
572     if ((char *)info->vers + sizeof(tt->version) + strlen(tt->name) + 1 >
573 	info->end) {
574 
575 	info->flags = DM_BUFFER_FULL_FLAG;
576 	return;
577     }
578 
579     if (info->old_vers)
580 	info->old_vers->next = (uint32_t) ((void *)info->vers -
581 					   (void *)info->old_vers);
582     info->vers->version[0] = tt->version[0];
583     info->vers->version[1] = tt->version[1];
584     info->vers->version[2] = tt->version[2];
585     info->vers->next = 0;
586     strcpy(info->vers->name, tt->name);
587 
588     info->old_vers = info->vers;
589     info->vers = align_ptr(((void *) ++info->vers) + strlen(tt->name) + 1);
590 }
591 
592 static int list_versions(struct dm_ioctl *param, size_t param_size)
593 {
594 	size_t len, needed = 0;
595 	struct dm_target_versions *vers;
596 	struct vers_iter iter_info;
597 
598 	/*
599 	 * Loop through all the devices working out how much
600 	 * space we need.
601 	 */
602 	dm_target_iterate(list_version_get_needed, &needed);
603 
604 	/*
605 	 * Grab our output buffer.
606 	 */
607 	vers = get_result_buffer(param, param_size, &len);
608 	if (len < needed) {
609 		param->flags |= DM_BUFFER_FULL_FLAG;
610 		goto out;
611 	}
612 	param->data_size = param->data_start + needed;
613 
614 	iter_info.param_size = param_size;
615 	iter_info.old_vers = NULL;
616 	iter_info.vers = vers;
617 	iter_info.flags = 0;
618 	iter_info.end = (char *)vers+len;
619 
620 	/*
621 	 * Now loop through filling out the names & versions.
622 	 */
623 	dm_target_iterate(list_version_get_info, &iter_info);
624 	param->flags |= iter_info.flags;
625 
626  out:
627 	return 0;
628 }
629 
630 static int check_name(const char *name)
631 {
632 	if (strchr(name, '/')) {
633 		DMWARN("invalid device name");
634 		return -EINVAL;
635 	}
636 
637 	return 0;
638 }
639 
640 /*
641  * On successful return, the caller must not attempt to acquire
642  * _hash_lock without first calling dm_put_live_table, because dm_table_destroy
643  * waits for this dm_put_live_table and could be called under this lock.
644  */
645 static struct dm_table *dm_get_inactive_table(struct mapped_device *md, int *srcu_idx)
646 {
647 	struct hash_cell *hc;
648 	struct dm_table *table = NULL;
649 
650 	/* increment rcu count, we don't care about the table pointer */
651 	dm_get_live_table(md, srcu_idx);
652 
653 	down_read(&_hash_lock);
654 	hc = dm_get_mdptr(md);
655 	if (!hc || hc->md != md) {
656 		DMWARN("device has been removed from the dev hash table.");
657 		goto out;
658 	}
659 
660 	table = hc->new_map;
661 
662 out:
663 	up_read(&_hash_lock);
664 
665 	return table;
666 }
667 
668 static struct dm_table *dm_get_live_or_inactive_table(struct mapped_device *md,
669 						      struct dm_ioctl *param,
670 						      int *srcu_idx)
671 {
672 	return (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) ?
673 		dm_get_inactive_table(md, srcu_idx) : dm_get_live_table(md, srcu_idx);
674 }
675 
676 /*
677  * Fills in a dm_ioctl structure, ready for sending back to
678  * userland.
679  */
680 static void __dev_status(struct mapped_device *md, struct dm_ioctl *param)
681 {
682 	struct gendisk *disk = dm_disk(md);
683 	struct dm_table *table;
684 	int srcu_idx;
685 
686 	param->flags &= ~(DM_SUSPEND_FLAG | DM_READONLY_FLAG |
687 			  DM_ACTIVE_PRESENT_FLAG | DM_INTERNAL_SUSPEND_FLAG);
688 
689 	if (dm_suspended_md(md))
690 		param->flags |= DM_SUSPEND_FLAG;
691 
692 	if (dm_suspended_internally_md(md))
693 		param->flags |= DM_INTERNAL_SUSPEND_FLAG;
694 
695 	if (dm_test_deferred_remove_flag(md))
696 		param->flags |= DM_DEFERRED_REMOVE;
697 
698 	param->dev = huge_encode_dev(disk_devt(disk));
699 
700 	/*
701 	 * Yes, this will be out of date by the time it gets back
702 	 * to userland, but it is still very useful for
703 	 * debugging.
704 	 */
705 	param->open_count = dm_open_count(md);
706 
707 	param->event_nr = dm_get_event_nr(md);
708 	param->target_count = 0;
709 
710 	table = dm_get_live_table(md, &srcu_idx);
711 	if (table) {
712 		if (!(param->flags & DM_QUERY_INACTIVE_TABLE_FLAG)) {
713 			if (get_disk_ro(disk))
714 				param->flags |= DM_READONLY_FLAG;
715 			param->target_count = dm_table_get_num_targets(table);
716 		}
717 
718 		param->flags |= DM_ACTIVE_PRESENT_FLAG;
719 	}
720 	dm_put_live_table(md, srcu_idx);
721 
722 	if (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) {
723 		int srcu_idx;
724 		table = dm_get_inactive_table(md, &srcu_idx);
725 		if (table) {
726 			if (!(dm_table_get_mode(table) & FMODE_WRITE))
727 				param->flags |= DM_READONLY_FLAG;
728 			param->target_count = dm_table_get_num_targets(table);
729 		}
730 		dm_put_live_table(md, srcu_idx);
731 	}
732 }
733 
734 static int dev_create(struct dm_ioctl *param, size_t param_size)
735 {
736 	int r, m = DM_ANY_MINOR;
737 	struct mapped_device *md;
738 
739 	r = check_name(param->name);
740 	if (r)
741 		return r;
742 
743 	if (param->flags & DM_PERSISTENT_DEV_FLAG)
744 		m = MINOR(huge_decode_dev(param->dev));
745 
746 	r = dm_create(m, &md);
747 	if (r)
748 		return r;
749 
750 	r = dm_hash_insert(param->name, *param->uuid ? param->uuid : NULL, md);
751 	if (r) {
752 		dm_put(md);
753 		dm_destroy(md);
754 		return r;
755 	}
756 
757 	param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
758 
759 	__dev_status(md, param);
760 
761 	dm_put(md);
762 
763 	return 0;
764 }
765 
766 /*
767  * Always use UUID for lookups if it's present, otherwise use name or dev.
768  */
769 static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
770 {
771 	struct hash_cell *hc = NULL;
772 
773 	if (*param->uuid) {
774 		if (*param->name || param->dev)
775 			return NULL;
776 
777 		hc = __get_uuid_cell(param->uuid);
778 		if (!hc)
779 			return NULL;
780 	} else if (*param->name) {
781 		if (param->dev)
782 			return NULL;
783 
784 		hc = __get_name_cell(param->name);
785 		if (!hc)
786 			return NULL;
787 	} else if (param->dev) {
788 		hc = __get_dev_cell(param->dev);
789 		if (!hc)
790 			return NULL;
791 	} else
792 		return NULL;
793 
794 	/*
795 	 * Sneakily write in both the name and the uuid
796 	 * while we have the cell.
797 	 */
798 	strlcpy(param->name, hc->name, sizeof(param->name));
799 	if (hc->uuid)
800 		strlcpy(param->uuid, hc->uuid, sizeof(param->uuid));
801 	else
802 		param->uuid[0] = '\0';
803 
804 	if (hc->new_map)
805 		param->flags |= DM_INACTIVE_PRESENT_FLAG;
806 	else
807 		param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
808 
809 	return hc;
810 }
811 
812 static struct mapped_device *find_device(struct dm_ioctl *param)
813 {
814 	struct hash_cell *hc;
815 	struct mapped_device *md = NULL;
816 
817 	down_read(&_hash_lock);
818 	hc = __find_device_hash_cell(param);
819 	if (hc)
820 		md = hc->md;
821 	up_read(&_hash_lock);
822 
823 	return md;
824 }
825 
826 static int dev_remove(struct dm_ioctl *param, size_t param_size)
827 {
828 	struct hash_cell *hc;
829 	struct mapped_device *md;
830 	int r;
831 	struct dm_table *t;
832 
833 	down_write(&_hash_lock);
834 	hc = __find_device_hash_cell(param);
835 
836 	if (!hc) {
837 		DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
838 		up_write(&_hash_lock);
839 		return -ENXIO;
840 	}
841 
842 	md = hc->md;
843 
844 	/*
845 	 * Ensure the device is not open and nothing further can open it.
846 	 */
847 	r = dm_lock_for_deletion(md, !!(param->flags & DM_DEFERRED_REMOVE), false);
848 	if (r) {
849 		if (r == -EBUSY && param->flags & DM_DEFERRED_REMOVE) {
850 			up_write(&_hash_lock);
851 			dm_put(md);
852 			return 0;
853 		}
854 		DMDEBUG_LIMIT("unable to remove open device %s", hc->name);
855 		up_write(&_hash_lock);
856 		dm_put(md);
857 		return r;
858 	}
859 
860 	t = __hash_remove(hc);
861 	up_write(&_hash_lock);
862 
863 	if (t) {
864 		dm_sync_table(md);
865 		dm_table_destroy(t);
866 	}
867 
868 	param->flags &= ~DM_DEFERRED_REMOVE;
869 
870 	if (!dm_kobject_uevent(md, KOBJ_REMOVE, param->event_nr))
871 		param->flags |= DM_UEVENT_GENERATED_FLAG;
872 
873 	dm_put(md);
874 	dm_destroy(md);
875 	return 0;
876 }
877 
878 /*
879  * Check a string doesn't overrun the chunk of
880  * memory we copied from userland.
881  */
882 static int invalid_str(char *str, void *end)
883 {
884 	while ((void *) str < end)
885 		if (!*str++)
886 			return 0;
887 
888 	return -EINVAL;
889 }
890 
891 static int dev_rename(struct dm_ioctl *param, size_t param_size)
892 {
893 	int r;
894 	char *new_data = (char *) param + param->data_start;
895 	struct mapped_device *md;
896 	unsigned change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0;
897 
898 	if (new_data < param->data ||
899 	    invalid_str(new_data, (void *) param + param_size) || !*new_data ||
900 	    strlen(new_data) > (change_uuid ? DM_UUID_LEN - 1 : DM_NAME_LEN - 1)) {
901 		DMWARN("Invalid new mapped device name or uuid string supplied.");
902 		return -EINVAL;
903 	}
904 
905 	if (!change_uuid) {
906 		r = check_name(new_data);
907 		if (r)
908 			return r;
909 	}
910 
911 	md = dm_hash_rename(param, new_data);
912 	if (IS_ERR(md))
913 		return PTR_ERR(md);
914 
915 	__dev_status(md, param);
916 	dm_put(md);
917 
918 	return 0;
919 }
920 
921 static int dev_set_geometry(struct dm_ioctl *param, size_t param_size)
922 {
923 	int r = -EINVAL, x;
924 	struct mapped_device *md;
925 	struct hd_geometry geometry;
926 	unsigned long indata[4];
927 	char *geostr = (char *) param + param->data_start;
928 	char dummy;
929 
930 	md = find_device(param);
931 	if (!md)
932 		return -ENXIO;
933 
934 	if (geostr < param->data ||
935 	    invalid_str(geostr, (void *) param + param_size)) {
936 		DMWARN("Invalid geometry supplied.");
937 		goto out;
938 	}
939 
940 	x = sscanf(geostr, "%lu %lu %lu %lu%c", indata,
941 		   indata + 1, indata + 2, indata + 3, &dummy);
942 
943 	if (x != 4) {
944 		DMWARN("Unable to interpret geometry settings.");
945 		goto out;
946 	}
947 
948 	if (indata[0] > 65535 || indata[1] > 255 ||
949 	    indata[2] > 255 || indata[3] > ULONG_MAX) {
950 		DMWARN("Geometry exceeds range limits.");
951 		goto out;
952 	}
953 
954 	geometry.cylinders = indata[0];
955 	geometry.heads = indata[1];
956 	geometry.sectors = indata[2];
957 	geometry.start = indata[3];
958 
959 	r = dm_set_geometry(md, &geometry);
960 
961 	param->data_size = 0;
962 
963 out:
964 	dm_put(md);
965 	return r;
966 }
967 
968 static int do_suspend(struct dm_ioctl *param)
969 {
970 	int r = 0;
971 	unsigned suspend_flags = DM_SUSPEND_LOCKFS_FLAG;
972 	struct mapped_device *md;
973 
974 	md = find_device(param);
975 	if (!md)
976 		return -ENXIO;
977 
978 	if (param->flags & DM_SKIP_LOCKFS_FLAG)
979 		suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG;
980 	if (param->flags & DM_NOFLUSH_FLAG)
981 		suspend_flags |= DM_SUSPEND_NOFLUSH_FLAG;
982 
983 	if (!dm_suspended_md(md)) {
984 		r = dm_suspend(md, suspend_flags);
985 		if (r)
986 			goto out;
987 	}
988 
989 	__dev_status(md, param);
990 
991 out:
992 	dm_put(md);
993 
994 	return r;
995 }
996 
997 static int do_resume(struct dm_ioctl *param)
998 {
999 	int r = 0;
1000 	unsigned suspend_flags = DM_SUSPEND_LOCKFS_FLAG;
1001 	struct hash_cell *hc;
1002 	struct mapped_device *md;
1003 	struct dm_table *new_map, *old_map = NULL;
1004 
1005 	down_write(&_hash_lock);
1006 
1007 	hc = __find_device_hash_cell(param);
1008 	if (!hc) {
1009 		DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
1010 		up_write(&_hash_lock);
1011 		return -ENXIO;
1012 	}
1013 
1014 	md = hc->md;
1015 
1016 	new_map = hc->new_map;
1017 	hc->new_map = NULL;
1018 	param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1019 
1020 	up_write(&_hash_lock);
1021 
1022 	/* Do we need to load a new map ? */
1023 	if (new_map) {
1024 		/* Suspend if it isn't already suspended */
1025 		if (param->flags & DM_SKIP_LOCKFS_FLAG)
1026 			suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG;
1027 		if (param->flags & DM_NOFLUSH_FLAG)
1028 			suspend_flags |= DM_SUSPEND_NOFLUSH_FLAG;
1029 		if (!dm_suspended_md(md))
1030 			dm_suspend(md, suspend_flags);
1031 
1032 		old_map = dm_swap_table(md, new_map);
1033 		if (IS_ERR(old_map)) {
1034 			dm_sync_table(md);
1035 			dm_table_destroy(new_map);
1036 			dm_put(md);
1037 			return PTR_ERR(old_map);
1038 		}
1039 
1040 		if (dm_table_get_mode(new_map) & FMODE_WRITE)
1041 			set_disk_ro(dm_disk(md), 0);
1042 		else
1043 			set_disk_ro(dm_disk(md), 1);
1044 	}
1045 
1046 	if (dm_suspended_md(md)) {
1047 		r = dm_resume(md);
1048 		if (!r && !dm_kobject_uevent(md, KOBJ_CHANGE, param->event_nr))
1049 			param->flags |= DM_UEVENT_GENERATED_FLAG;
1050 	}
1051 
1052 	/*
1053 	 * Since dm_swap_table synchronizes RCU, nobody should be in
1054 	 * read-side critical section already.
1055 	 */
1056 	if (old_map)
1057 		dm_table_destroy(old_map);
1058 
1059 	if (!r)
1060 		__dev_status(md, param);
1061 
1062 	dm_put(md);
1063 	return r;
1064 }
1065 
1066 /*
1067  * Set or unset the suspension state of a device.
1068  * If the device already is in the requested state we just return its status.
1069  */
1070 static int dev_suspend(struct dm_ioctl *param, size_t param_size)
1071 {
1072 	if (param->flags & DM_SUSPEND_FLAG)
1073 		return do_suspend(param);
1074 
1075 	return do_resume(param);
1076 }
1077 
1078 /*
1079  * Copies device info back to user space, used by
1080  * the create and info ioctls.
1081  */
1082 static int dev_status(struct dm_ioctl *param, size_t param_size)
1083 {
1084 	struct mapped_device *md;
1085 
1086 	md = find_device(param);
1087 	if (!md)
1088 		return -ENXIO;
1089 
1090 	__dev_status(md, param);
1091 	dm_put(md);
1092 
1093 	return 0;
1094 }
1095 
1096 /*
1097  * Build up the status struct for each target
1098  */
1099 static void retrieve_status(struct dm_table *table,
1100 			    struct dm_ioctl *param, size_t param_size)
1101 {
1102 	unsigned int i, num_targets;
1103 	struct dm_target_spec *spec;
1104 	char *outbuf, *outptr;
1105 	status_type_t type;
1106 	size_t remaining, len, used = 0;
1107 	unsigned status_flags = 0;
1108 
1109 	outptr = outbuf = get_result_buffer(param, param_size, &len);
1110 
1111 	if (param->flags & DM_STATUS_TABLE_FLAG)
1112 		type = STATUSTYPE_TABLE;
1113 	else
1114 		type = STATUSTYPE_INFO;
1115 
1116 	/* Get all the target info */
1117 	num_targets = dm_table_get_num_targets(table);
1118 	for (i = 0; i < num_targets; i++) {
1119 		struct dm_target *ti = dm_table_get_target(table, i);
1120 		size_t l;
1121 
1122 		remaining = len - (outptr - outbuf);
1123 		if (remaining <= sizeof(struct dm_target_spec)) {
1124 			param->flags |= DM_BUFFER_FULL_FLAG;
1125 			break;
1126 		}
1127 
1128 		spec = (struct dm_target_spec *) outptr;
1129 
1130 		spec->status = 0;
1131 		spec->sector_start = ti->begin;
1132 		spec->length = ti->len;
1133 		strncpy(spec->target_type, ti->type->name,
1134 			sizeof(spec->target_type));
1135 
1136 		outptr += sizeof(struct dm_target_spec);
1137 		remaining = len - (outptr - outbuf);
1138 		if (remaining <= 0) {
1139 			param->flags |= DM_BUFFER_FULL_FLAG;
1140 			break;
1141 		}
1142 
1143 		/* Get the status/table string from the target driver */
1144 		if (ti->type->status) {
1145 			if (param->flags & DM_NOFLUSH_FLAG)
1146 				status_flags |= DM_STATUS_NOFLUSH_FLAG;
1147 			ti->type->status(ti, type, status_flags, outptr, remaining);
1148 		} else
1149 			outptr[0] = '\0';
1150 
1151 		l = strlen(outptr) + 1;
1152 		if (l == remaining) {
1153 			param->flags |= DM_BUFFER_FULL_FLAG;
1154 			break;
1155 		}
1156 
1157 		outptr += l;
1158 		used = param->data_start + (outptr - outbuf);
1159 
1160 		outptr = align_ptr(outptr);
1161 		spec->next = outptr - outbuf;
1162 	}
1163 
1164 	if (used)
1165 		param->data_size = used;
1166 
1167 	param->target_count = num_targets;
1168 }
1169 
1170 /*
1171  * Wait for a device to report an event
1172  */
1173 static int dev_wait(struct dm_ioctl *param, size_t param_size)
1174 {
1175 	int r = 0;
1176 	struct mapped_device *md;
1177 	struct dm_table *table;
1178 	int srcu_idx;
1179 
1180 	md = find_device(param);
1181 	if (!md)
1182 		return -ENXIO;
1183 
1184 	/*
1185 	 * Wait for a notification event
1186 	 */
1187 	if (dm_wait_event(md, param->event_nr)) {
1188 		r = -ERESTARTSYS;
1189 		goto out;
1190 	}
1191 
1192 	/*
1193 	 * The userland program is going to want to know what
1194 	 * changed to trigger the event, so we may as well tell
1195 	 * him and save an ioctl.
1196 	 */
1197 	__dev_status(md, param);
1198 
1199 	table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1200 	if (table)
1201 		retrieve_status(table, param, param_size);
1202 	dm_put_live_table(md, srcu_idx);
1203 
1204 out:
1205 	dm_put(md);
1206 
1207 	return r;
1208 }
1209 
1210 static inline fmode_t get_mode(struct dm_ioctl *param)
1211 {
1212 	fmode_t mode = FMODE_READ | FMODE_WRITE;
1213 
1214 	if (param->flags & DM_READONLY_FLAG)
1215 		mode = FMODE_READ;
1216 
1217 	return mode;
1218 }
1219 
1220 static int next_target(struct dm_target_spec *last, uint32_t next, void *end,
1221 		       struct dm_target_spec **spec, char **target_params)
1222 {
1223 	*spec = (struct dm_target_spec *) ((unsigned char *) last + next);
1224 	*target_params = (char *) (*spec + 1);
1225 
1226 	if (*spec < (last + 1))
1227 		return -EINVAL;
1228 
1229 	return invalid_str(*target_params, end);
1230 }
1231 
1232 static int populate_table(struct dm_table *table,
1233 			  struct dm_ioctl *param, size_t param_size)
1234 {
1235 	int r;
1236 	unsigned int i = 0;
1237 	struct dm_target_spec *spec = (struct dm_target_spec *) param;
1238 	uint32_t next = param->data_start;
1239 	void *end = (void *) param + param_size;
1240 	char *target_params;
1241 
1242 	if (!param->target_count) {
1243 		DMWARN("populate_table: no targets specified");
1244 		return -EINVAL;
1245 	}
1246 
1247 	for (i = 0; i < param->target_count; i++) {
1248 
1249 		r = next_target(spec, next, end, &spec, &target_params);
1250 		if (r) {
1251 			DMWARN("unable to find target");
1252 			return r;
1253 		}
1254 
1255 		r = dm_table_add_target(table, spec->target_type,
1256 					(sector_t) spec->sector_start,
1257 					(sector_t) spec->length,
1258 					target_params);
1259 		if (r) {
1260 			DMWARN("error adding target to table");
1261 			return r;
1262 		}
1263 
1264 		next = spec->next;
1265 	}
1266 
1267 	return dm_table_complete(table);
1268 }
1269 
1270 static int table_load(struct dm_ioctl *param, size_t param_size)
1271 {
1272 	int r;
1273 	struct hash_cell *hc;
1274 	struct dm_table *t, *old_map = NULL;
1275 	struct mapped_device *md;
1276 	struct target_type *immutable_target_type;
1277 
1278 	md = find_device(param);
1279 	if (!md)
1280 		return -ENXIO;
1281 
1282 	r = dm_table_create(&t, get_mode(param), param->target_count, md);
1283 	if (r)
1284 		goto err;
1285 
1286 	/* Protect md->type and md->queue against concurrent table loads. */
1287 	dm_lock_md_type(md);
1288 	r = populate_table(t, param, param_size);
1289 	if (r)
1290 		goto err_unlock_md_type;
1291 
1292 	immutable_target_type = dm_get_immutable_target_type(md);
1293 	if (immutable_target_type &&
1294 	    (immutable_target_type != dm_table_get_immutable_target_type(t)) &&
1295 	    !dm_table_get_wildcard_target(t)) {
1296 		DMWARN("can't replace immutable target type %s",
1297 		       immutable_target_type->name);
1298 		r = -EINVAL;
1299 		goto err_unlock_md_type;
1300 	}
1301 
1302 	if (dm_get_md_type(md) == DM_TYPE_NONE) {
1303 		/* Initial table load: acquire type of table. */
1304 		dm_set_md_type(md, dm_table_get_type(t));
1305 
1306 		/* setup md->queue to reflect md's type (may block) */
1307 		r = dm_setup_md_queue(md, t);
1308 		if (r) {
1309 			DMWARN("unable to set up device queue for new table.");
1310 			goto err_unlock_md_type;
1311 		}
1312 	} else if (dm_get_md_type(md) != dm_table_get_type(t)) {
1313 		DMWARN("can't change device type after initial table load.");
1314 		r = -EINVAL;
1315 		goto err_unlock_md_type;
1316 	}
1317 
1318 	dm_unlock_md_type(md);
1319 
1320 	/* stage inactive table */
1321 	down_write(&_hash_lock);
1322 	hc = dm_get_mdptr(md);
1323 	if (!hc || hc->md != md) {
1324 		DMWARN("device has been removed from the dev hash table.");
1325 		up_write(&_hash_lock);
1326 		r = -ENXIO;
1327 		goto err_destroy_table;
1328 	}
1329 
1330 	if (hc->new_map)
1331 		old_map = hc->new_map;
1332 	hc->new_map = t;
1333 	up_write(&_hash_lock);
1334 
1335 	param->flags |= DM_INACTIVE_PRESENT_FLAG;
1336 	__dev_status(md, param);
1337 
1338 	if (old_map) {
1339 		dm_sync_table(md);
1340 		dm_table_destroy(old_map);
1341 	}
1342 
1343 	dm_put(md);
1344 
1345 	return 0;
1346 
1347 err_unlock_md_type:
1348 	dm_unlock_md_type(md);
1349 err_destroy_table:
1350 	dm_table_destroy(t);
1351 err:
1352 	dm_put(md);
1353 
1354 	return r;
1355 }
1356 
1357 static int table_clear(struct dm_ioctl *param, size_t param_size)
1358 {
1359 	struct hash_cell *hc;
1360 	struct mapped_device *md;
1361 	struct dm_table *old_map = NULL;
1362 
1363 	down_write(&_hash_lock);
1364 
1365 	hc = __find_device_hash_cell(param);
1366 	if (!hc) {
1367 		DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
1368 		up_write(&_hash_lock);
1369 		return -ENXIO;
1370 	}
1371 
1372 	if (hc->new_map) {
1373 		old_map = hc->new_map;
1374 		hc->new_map = NULL;
1375 	}
1376 
1377 	param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1378 
1379 	__dev_status(hc->md, param);
1380 	md = hc->md;
1381 	up_write(&_hash_lock);
1382 	if (old_map) {
1383 		dm_sync_table(md);
1384 		dm_table_destroy(old_map);
1385 	}
1386 	dm_put(md);
1387 
1388 	return 0;
1389 }
1390 
1391 /*
1392  * Retrieves a list of devices used by a particular dm device.
1393  */
1394 static void retrieve_deps(struct dm_table *table,
1395 			  struct dm_ioctl *param, size_t param_size)
1396 {
1397 	unsigned int count = 0;
1398 	struct list_head *tmp;
1399 	size_t len, needed;
1400 	struct dm_dev_internal *dd;
1401 	struct dm_target_deps *deps;
1402 
1403 	deps = get_result_buffer(param, param_size, &len);
1404 
1405 	/*
1406 	 * Count the devices.
1407 	 */
1408 	list_for_each (tmp, dm_table_get_devices(table))
1409 		count++;
1410 
1411 	/*
1412 	 * Check we have enough space.
1413 	 */
1414 	needed = sizeof(*deps) + (sizeof(*deps->dev) * count);
1415 	if (len < needed) {
1416 		param->flags |= DM_BUFFER_FULL_FLAG;
1417 		return;
1418 	}
1419 
1420 	/*
1421 	 * Fill in the devices.
1422 	 */
1423 	deps->count = count;
1424 	count = 0;
1425 	list_for_each_entry (dd, dm_table_get_devices(table), list)
1426 		deps->dev[count++] = huge_encode_dev(dd->dm_dev->bdev->bd_dev);
1427 
1428 	param->data_size = param->data_start + needed;
1429 }
1430 
1431 static int table_deps(struct dm_ioctl *param, size_t param_size)
1432 {
1433 	struct mapped_device *md;
1434 	struct dm_table *table;
1435 	int srcu_idx;
1436 
1437 	md = find_device(param);
1438 	if (!md)
1439 		return -ENXIO;
1440 
1441 	__dev_status(md, param);
1442 
1443 	table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1444 	if (table)
1445 		retrieve_deps(table, param, param_size);
1446 	dm_put_live_table(md, srcu_idx);
1447 
1448 	dm_put(md);
1449 
1450 	return 0;
1451 }
1452 
1453 /*
1454  * Return the status of a device as a text string for each
1455  * target.
1456  */
1457 static int table_status(struct dm_ioctl *param, size_t param_size)
1458 {
1459 	struct mapped_device *md;
1460 	struct dm_table *table;
1461 	int srcu_idx;
1462 
1463 	md = find_device(param);
1464 	if (!md)
1465 		return -ENXIO;
1466 
1467 	__dev_status(md, param);
1468 
1469 	table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1470 	if (table)
1471 		retrieve_status(table, param, param_size);
1472 	dm_put_live_table(md, srcu_idx);
1473 
1474 	dm_put(md);
1475 
1476 	return 0;
1477 }
1478 
1479 /*
1480  * Process device-mapper dependent messages.  Messages prefixed with '@'
1481  * are processed by the DM core.  All others are delivered to the target.
1482  * Returns a number <= 1 if message was processed by device mapper.
1483  * Returns 2 if message should be delivered to the target.
1484  */
1485 static int message_for_md(struct mapped_device *md, unsigned argc, char **argv,
1486 			  char *result, unsigned maxlen)
1487 {
1488 	int r;
1489 
1490 	if (**argv != '@')
1491 		return 2; /* no '@' prefix, deliver to target */
1492 
1493 	if (!strcasecmp(argv[0], "@cancel_deferred_remove")) {
1494 		if (argc != 1) {
1495 			DMERR("Invalid arguments for @cancel_deferred_remove");
1496 			return -EINVAL;
1497 		}
1498 		return dm_cancel_deferred_remove(md);
1499 	}
1500 
1501 	r = dm_stats_message(md, argc, argv, result, maxlen);
1502 	if (r < 2)
1503 		return r;
1504 
1505 	DMERR("Unsupported message sent to DM core: %s", argv[0]);
1506 	return -EINVAL;
1507 }
1508 
1509 /*
1510  * Pass a message to the target that's at the supplied device offset.
1511  */
1512 static int target_message(struct dm_ioctl *param, size_t param_size)
1513 {
1514 	int r, argc;
1515 	char **argv;
1516 	struct mapped_device *md;
1517 	struct dm_table *table;
1518 	struct dm_target *ti;
1519 	struct dm_target_msg *tmsg = (void *) param + param->data_start;
1520 	size_t maxlen;
1521 	char *result = get_result_buffer(param, param_size, &maxlen);
1522 	int srcu_idx;
1523 
1524 	md = find_device(param);
1525 	if (!md)
1526 		return -ENXIO;
1527 
1528 	if (tmsg < (struct dm_target_msg *) param->data ||
1529 	    invalid_str(tmsg->message, (void *) param + param_size)) {
1530 		DMWARN("Invalid target message parameters.");
1531 		r = -EINVAL;
1532 		goto out;
1533 	}
1534 
1535 	r = dm_split_args(&argc, &argv, tmsg->message);
1536 	if (r) {
1537 		DMWARN("Failed to split target message parameters");
1538 		goto out;
1539 	}
1540 
1541 	if (!argc) {
1542 		DMWARN("Empty message received.");
1543 		goto out_argv;
1544 	}
1545 
1546 	r = message_for_md(md, argc, argv, result, maxlen);
1547 	if (r <= 1)
1548 		goto out_argv;
1549 
1550 	table = dm_get_live_table(md, &srcu_idx);
1551 	if (!table)
1552 		goto out_table;
1553 
1554 	if (dm_deleting_md(md)) {
1555 		r = -ENXIO;
1556 		goto out_table;
1557 	}
1558 
1559 	ti = dm_table_find_target(table, tmsg->sector);
1560 	if (!dm_target_is_valid(ti)) {
1561 		DMWARN("Target message sector outside device.");
1562 		r = -EINVAL;
1563 	} else if (ti->type->message)
1564 		r = ti->type->message(ti, argc, argv);
1565 	else {
1566 		DMWARN("Target type does not support messages");
1567 		r = -EINVAL;
1568 	}
1569 
1570  out_table:
1571 	dm_put_live_table(md, srcu_idx);
1572  out_argv:
1573 	kfree(argv);
1574  out:
1575 	if (r >= 0)
1576 		__dev_status(md, param);
1577 
1578 	if (r == 1) {
1579 		param->flags |= DM_DATA_OUT_FLAG;
1580 		if (dm_message_test_buffer_overflow(result, maxlen))
1581 			param->flags |= DM_BUFFER_FULL_FLAG;
1582 		else
1583 			param->data_size = param->data_start + strlen(result) + 1;
1584 		r = 0;
1585 	}
1586 
1587 	dm_put(md);
1588 	return r;
1589 }
1590 
1591 /*
1592  * The ioctl parameter block consists of two parts, a dm_ioctl struct
1593  * followed by a data buffer.  This flag is set if the second part,
1594  * which has a variable size, is not used by the function processing
1595  * the ioctl.
1596  */
1597 #define IOCTL_FLAGS_NO_PARAMS	1
1598 
1599 /*-----------------------------------------------------------------
1600  * Implementation of open/close/ioctl on the special char
1601  * device.
1602  *---------------------------------------------------------------*/
1603 static ioctl_fn lookup_ioctl(unsigned int cmd, int *ioctl_flags)
1604 {
1605 	static struct {
1606 		int cmd;
1607 		int flags;
1608 		ioctl_fn fn;
1609 	} _ioctls[] = {
1610 		{DM_VERSION_CMD, 0, NULL}, /* version is dealt with elsewhere */
1611 		{DM_REMOVE_ALL_CMD, IOCTL_FLAGS_NO_PARAMS, remove_all},
1612 		{DM_LIST_DEVICES_CMD, 0, list_devices},
1613 
1614 		{DM_DEV_CREATE_CMD, IOCTL_FLAGS_NO_PARAMS, dev_create},
1615 		{DM_DEV_REMOVE_CMD, IOCTL_FLAGS_NO_PARAMS, dev_remove},
1616 		{DM_DEV_RENAME_CMD, 0, dev_rename},
1617 		{DM_DEV_SUSPEND_CMD, IOCTL_FLAGS_NO_PARAMS, dev_suspend},
1618 		{DM_DEV_STATUS_CMD, IOCTL_FLAGS_NO_PARAMS, dev_status},
1619 		{DM_DEV_WAIT_CMD, 0, dev_wait},
1620 
1621 		{DM_TABLE_LOAD_CMD, 0, table_load},
1622 		{DM_TABLE_CLEAR_CMD, IOCTL_FLAGS_NO_PARAMS, table_clear},
1623 		{DM_TABLE_DEPS_CMD, 0, table_deps},
1624 		{DM_TABLE_STATUS_CMD, 0, table_status},
1625 
1626 		{DM_LIST_VERSIONS_CMD, 0, list_versions},
1627 
1628 		{DM_TARGET_MSG_CMD, 0, target_message},
1629 		{DM_DEV_SET_GEOMETRY_CMD, 0, dev_set_geometry}
1630 	};
1631 
1632 	if (unlikely(cmd >= ARRAY_SIZE(_ioctls)))
1633 		return NULL;
1634 
1635 	*ioctl_flags = _ioctls[cmd].flags;
1636 	return _ioctls[cmd].fn;
1637 }
1638 
1639 /*
1640  * As well as checking the version compatibility this always
1641  * copies the kernel interface version out.
1642  */
1643 static int check_version(unsigned int cmd, struct dm_ioctl __user *user)
1644 {
1645 	uint32_t version[3];
1646 	int r = 0;
1647 
1648 	if (copy_from_user(version, user->version, sizeof(version)))
1649 		return -EFAULT;
1650 
1651 	if ((DM_VERSION_MAJOR != version[0]) ||
1652 	    (DM_VERSION_MINOR < version[1])) {
1653 		DMWARN("ioctl interface mismatch: "
1654 		       "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)",
1655 		       DM_VERSION_MAJOR, DM_VERSION_MINOR,
1656 		       DM_VERSION_PATCHLEVEL,
1657 		       version[0], version[1], version[2], cmd);
1658 		r = -EINVAL;
1659 	}
1660 
1661 	/*
1662 	 * Fill in the kernel version.
1663 	 */
1664 	version[0] = DM_VERSION_MAJOR;
1665 	version[1] = DM_VERSION_MINOR;
1666 	version[2] = DM_VERSION_PATCHLEVEL;
1667 	if (copy_to_user(user->version, version, sizeof(version)))
1668 		return -EFAULT;
1669 
1670 	return r;
1671 }
1672 
1673 #define DM_PARAMS_KMALLOC	0x0001	/* Params alloced with kmalloc */
1674 #define DM_PARAMS_VMALLOC	0x0002	/* Params alloced with vmalloc */
1675 #define DM_WIPE_BUFFER		0x0010	/* Wipe input buffer before returning from ioctl */
1676 
1677 static void free_params(struct dm_ioctl *param, size_t param_size, int param_flags)
1678 {
1679 	if (param_flags & DM_WIPE_BUFFER)
1680 		memset(param, 0, param_size);
1681 
1682 	if (param_flags & DM_PARAMS_KMALLOC)
1683 		kfree(param);
1684 	if (param_flags & DM_PARAMS_VMALLOC)
1685 		vfree(param);
1686 }
1687 
1688 static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl *param_kernel,
1689 		       int ioctl_flags,
1690 		       struct dm_ioctl **param, int *param_flags)
1691 {
1692 	struct dm_ioctl *dmi;
1693 	int secure_data;
1694 	const size_t minimum_data_size = sizeof(*param_kernel) - sizeof(param_kernel->data);
1695 
1696 	if (copy_from_user(param_kernel, user, minimum_data_size))
1697 		return -EFAULT;
1698 
1699 	if (param_kernel->data_size < minimum_data_size)
1700 		return -EINVAL;
1701 
1702 	secure_data = param_kernel->flags & DM_SECURE_DATA_FLAG;
1703 
1704 	*param_flags = secure_data ? DM_WIPE_BUFFER : 0;
1705 
1706 	if (ioctl_flags & IOCTL_FLAGS_NO_PARAMS) {
1707 		dmi = param_kernel;
1708 		dmi->data_size = minimum_data_size;
1709 		goto data_copied;
1710 	}
1711 
1712 	/*
1713 	 * Try to avoid low memory issues when a device is suspended.
1714 	 * Use kmalloc() rather than vmalloc() when we can.
1715 	 */
1716 	dmi = NULL;
1717 	if (param_kernel->data_size <= KMALLOC_MAX_SIZE) {
1718 		dmi = kmalloc(param_kernel->data_size, GFP_NOIO | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN);
1719 		if (dmi)
1720 			*param_flags |= DM_PARAMS_KMALLOC;
1721 	}
1722 
1723 	if (!dmi) {
1724 		unsigned noio_flag;
1725 		noio_flag = memalloc_noio_save();
1726 		dmi = __vmalloc(param_kernel->data_size, GFP_NOIO | __GFP_HIGH | __GFP_HIGHMEM, PAGE_KERNEL);
1727 		memalloc_noio_restore(noio_flag);
1728 		if (dmi)
1729 			*param_flags |= DM_PARAMS_VMALLOC;
1730 	}
1731 
1732 	if (!dmi) {
1733 		if (secure_data && clear_user(user, param_kernel->data_size))
1734 			return -EFAULT;
1735 		return -ENOMEM;
1736 	}
1737 
1738 	if (copy_from_user(dmi, user, param_kernel->data_size))
1739 		goto bad;
1740 
1741 data_copied:
1742 	/*
1743 	 * Abort if something changed the ioctl data while it was being copied.
1744 	 */
1745 	if (dmi->data_size != param_kernel->data_size) {
1746 		DMERR("rejecting ioctl: data size modified while processing parameters");
1747 		goto bad;
1748 	}
1749 
1750 	/* Wipe the user buffer so we do not return it to userspace */
1751 	if (secure_data && clear_user(user, param_kernel->data_size))
1752 		goto bad;
1753 
1754 	*param = dmi;
1755 	return 0;
1756 
1757 bad:
1758 	free_params(dmi, param_kernel->data_size, *param_flags);
1759 
1760 	return -EFAULT;
1761 }
1762 
1763 static int validate_params(uint cmd, struct dm_ioctl *param)
1764 {
1765 	/* Always clear this flag */
1766 	param->flags &= ~DM_BUFFER_FULL_FLAG;
1767 	param->flags &= ~DM_UEVENT_GENERATED_FLAG;
1768 	param->flags &= ~DM_SECURE_DATA_FLAG;
1769 	param->flags &= ~DM_DATA_OUT_FLAG;
1770 
1771 	/* Ignores parameters */
1772 	if (cmd == DM_REMOVE_ALL_CMD ||
1773 	    cmd == DM_LIST_DEVICES_CMD ||
1774 	    cmd == DM_LIST_VERSIONS_CMD)
1775 		return 0;
1776 
1777 	if ((cmd == DM_DEV_CREATE_CMD)) {
1778 		if (!*param->name) {
1779 			DMWARN("name not supplied when creating device");
1780 			return -EINVAL;
1781 		}
1782 	} else if ((*param->uuid && *param->name)) {
1783 		DMWARN("only supply one of name or uuid, cmd(%u)", cmd);
1784 		return -EINVAL;
1785 	}
1786 
1787 	/* Ensure strings are terminated */
1788 	param->name[DM_NAME_LEN - 1] = '\0';
1789 	param->uuid[DM_UUID_LEN - 1] = '\0';
1790 
1791 	return 0;
1792 }
1793 
1794 static int ctl_ioctl(uint command, struct dm_ioctl __user *user)
1795 {
1796 	int r = 0;
1797 	int ioctl_flags;
1798 	int param_flags;
1799 	unsigned int cmd;
1800 	struct dm_ioctl *uninitialized_var(param);
1801 	ioctl_fn fn = NULL;
1802 	size_t input_param_size;
1803 	struct dm_ioctl param_kernel;
1804 
1805 	/* only root can play with this */
1806 	if (!capable(CAP_SYS_ADMIN))
1807 		return -EACCES;
1808 
1809 	if (_IOC_TYPE(command) != DM_IOCTL)
1810 		return -ENOTTY;
1811 
1812 	cmd = _IOC_NR(command);
1813 
1814 	/*
1815 	 * Check the interface version passed in.  This also
1816 	 * writes out the kernel's interface version.
1817 	 */
1818 	r = check_version(cmd, user);
1819 	if (r)
1820 		return r;
1821 
1822 	/*
1823 	 * Nothing more to do for the version command.
1824 	 */
1825 	if (cmd == DM_VERSION_CMD)
1826 		return 0;
1827 
1828 	fn = lookup_ioctl(cmd, &ioctl_flags);
1829 	if (!fn) {
1830 		DMWARN("dm_ctl_ioctl: unknown command 0x%x", command);
1831 		return -ENOTTY;
1832 	}
1833 
1834 	/*
1835 	 * Copy the parameters into kernel space.
1836 	 */
1837 	r = copy_params(user, &param_kernel, ioctl_flags, &param, &param_flags);
1838 
1839 	if (r)
1840 		return r;
1841 
1842 	input_param_size = param->data_size;
1843 	r = validate_params(cmd, param);
1844 	if (r)
1845 		goto out;
1846 
1847 	param->data_size = sizeof(*param);
1848 	r = fn(param, input_param_size);
1849 
1850 	if (unlikely(param->flags & DM_BUFFER_FULL_FLAG) &&
1851 	    unlikely(ioctl_flags & IOCTL_FLAGS_NO_PARAMS))
1852 		DMERR("ioctl %d tried to output some data but has IOCTL_FLAGS_NO_PARAMS set", cmd);
1853 
1854 	/*
1855 	 * Copy the results back to userland.
1856 	 */
1857 	if (!r && copy_to_user(user, param, param->data_size))
1858 		r = -EFAULT;
1859 
1860 out:
1861 	free_params(param, input_param_size, param_flags);
1862 	return r;
1863 }
1864 
1865 static long dm_ctl_ioctl(struct file *file, uint command, ulong u)
1866 {
1867 	return (long)ctl_ioctl(command, (struct dm_ioctl __user *)u);
1868 }
1869 
1870 #ifdef CONFIG_COMPAT
1871 static long dm_compat_ctl_ioctl(struct file *file, uint command, ulong u)
1872 {
1873 	return (long)dm_ctl_ioctl(file, command, (ulong) compat_ptr(u));
1874 }
1875 #else
1876 #define dm_compat_ctl_ioctl NULL
1877 #endif
1878 
1879 static const struct file_operations _ctl_fops = {
1880 	.open = nonseekable_open,
1881 	.unlocked_ioctl	 = dm_ctl_ioctl,
1882 	.compat_ioctl = dm_compat_ctl_ioctl,
1883 	.owner	 = THIS_MODULE,
1884 	.llseek  = noop_llseek,
1885 };
1886 
1887 static struct miscdevice _dm_misc = {
1888 	.minor		= MAPPER_CTRL_MINOR,
1889 	.name  		= DM_NAME,
1890 	.nodename	= DM_DIR "/" DM_CONTROL_NODE,
1891 	.fops  		= &_ctl_fops
1892 };
1893 
1894 MODULE_ALIAS_MISCDEV(MAPPER_CTRL_MINOR);
1895 MODULE_ALIAS("devname:" DM_DIR "/" DM_CONTROL_NODE);
1896 
1897 /*
1898  * Create misc character device and link to DM_DIR/control.
1899  */
1900 int __init dm_interface_init(void)
1901 {
1902 	int r;
1903 
1904 	r = dm_hash_init();
1905 	if (r)
1906 		return r;
1907 
1908 	r = misc_register(&_dm_misc);
1909 	if (r) {
1910 		DMERR("misc_register failed for control device");
1911 		dm_hash_exit();
1912 		return r;
1913 	}
1914 
1915 	DMINFO("%d.%d.%d%s initialised: %s", DM_VERSION_MAJOR,
1916 	       DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL, DM_VERSION_EXTRA,
1917 	       DM_DRIVER_EMAIL);
1918 	return 0;
1919 }
1920 
1921 void dm_interface_exit(void)
1922 {
1923 	misc_deregister(&_dm_misc);
1924 	dm_hash_exit();
1925 }
1926 
1927 /**
1928  * dm_copy_name_and_uuid - Copy mapped device name & uuid into supplied buffers
1929  * @md: Pointer to mapped_device
1930  * @name: Buffer (size DM_NAME_LEN) for name
1931  * @uuid: Buffer (size DM_UUID_LEN) for uuid or empty string if uuid not defined
1932  */
1933 int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid)
1934 {
1935 	int r = 0;
1936 	struct hash_cell *hc;
1937 
1938 	if (!md)
1939 		return -ENXIO;
1940 
1941 	mutex_lock(&dm_hash_cells_mutex);
1942 	hc = dm_get_mdptr(md);
1943 	if (!hc || hc->md != md) {
1944 		r = -ENXIO;
1945 		goto out;
1946 	}
1947 
1948 	if (name)
1949 		strcpy(name, hc->name);
1950 	if (uuid)
1951 		strcpy(uuid, hc->uuid ? : "");
1952 
1953 out:
1954 	mutex_unlock(&dm_hash_cells_mutex);
1955 
1956 	return r;
1957 }
1958