2 * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
3 * Copyright (C) 2004 - 2006 Red Hat, Inc. All rights reserved.
5 * This file is released under the GPL.
10 #include <linux/module.h>
11 #include <linux/vmalloc.h>
12 #include <linux/miscdevice.h>
13 #include <linux/sched/mm.h>
14 #include <linux/init.h>
15 #include <linux/wait.h>
16 #include <linux/slab.h>
17 #include <linux/dm-ioctl.h>
18 #include <linux/hdreg.h>
19 #include <linux/compat.h>
21 #include <linux/uaccess.h>
23 #define DM_MSG_PREFIX "ioctl"
24 #define DM_DRIVER_EMAIL "dm-devel@redhat.com"
26 /*-----------------------------------------------------------------
27 * The ioctl interface needs to be able to look up devices by
29 *---------------------------------------------------------------*/
31 struct list_head name_list
;
32 struct list_head uuid_list
;
36 struct mapped_device
*md
;
37 struct dm_table
*new_map
;
41 * A dummy definition to make RCU happy.
42 * struct dm_table should never be dereferenced in this file.
50 struct dm_target_versions
*vers
, *old_vers
;
56 #define NUM_BUCKETS 64
57 #define MASK_BUCKETS (NUM_BUCKETS - 1)
58 static struct list_head _name_buckets
[NUM_BUCKETS
];
59 static struct list_head _uuid_buckets
[NUM_BUCKETS
];
61 static void dm_hash_remove_all(bool keep_open_devices
, bool mark_deferred
, bool only_deferred
);
64 * Guards access to both hash tables.
66 static DECLARE_RWSEM(_hash_lock
);
69 * Protects use of mdptr to obtain hash cell name and uuid from mapped device.
71 static DEFINE_MUTEX(dm_hash_cells_mutex
);
73 static void init_buckets(struct list_head
*buckets
)
77 for (i
= 0; i
< NUM_BUCKETS
; i
++)
78 INIT_LIST_HEAD(buckets
+ i
);
81 static int dm_hash_init(void)
83 init_buckets(_name_buckets
);
84 init_buckets(_uuid_buckets
);
88 static void dm_hash_exit(void)
90 dm_hash_remove_all(false, false, false);
93 /*-----------------------------------------------------------------
95 * We're not really concerned with the str hash function being
96 * fast since it's only used by the ioctl interface.
97 *---------------------------------------------------------------*/
98 static unsigned int hash_str(const char *str
)
100 const unsigned int hash_mult
= 2654435387U;
104 h
= (h
+ (unsigned int) *str
++) * hash_mult
;
106 return h
& MASK_BUCKETS
;
109 /*-----------------------------------------------------------------
110 * Code for looking up a device by name
111 *---------------------------------------------------------------*/
112 static struct hash_cell
*__get_name_cell(const char *str
)
114 struct hash_cell
*hc
;
115 unsigned int h
= hash_str(str
);
117 list_for_each_entry (hc
, _name_buckets
+ h
, name_list
)
118 if (!strcmp(hc
->name
, str
)) {
126 static struct hash_cell
*__get_uuid_cell(const char *str
)
128 struct hash_cell
*hc
;
129 unsigned int h
= hash_str(str
);
131 list_for_each_entry (hc
, _uuid_buckets
+ h
, uuid_list
)
132 if (!strcmp(hc
->uuid
, str
)) {
140 static struct hash_cell
*__get_dev_cell(uint64_t dev
)
142 struct mapped_device
*md
;
143 struct hash_cell
*hc
;
145 md
= dm_get_md(huge_decode_dev(dev
));
149 hc
= dm_get_mdptr(md
);
158 /*-----------------------------------------------------------------
159 * Inserting, removing and renaming a device.
160 *---------------------------------------------------------------*/
161 static struct hash_cell
*alloc_cell(const char *name
, const char *uuid
,
162 struct mapped_device
*md
)
164 struct hash_cell
*hc
;
166 hc
= kmalloc(sizeof(*hc
), GFP_KERNEL
);
170 hc
->name
= kstrdup(name
, GFP_KERNEL
);
180 hc
->uuid
= kstrdup(uuid
, GFP_KERNEL
);
188 INIT_LIST_HEAD(&hc
->name_list
);
189 INIT_LIST_HEAD(&hc
->uuid_list
);
195 static void free_cell(struct hash_cell
*hc
)
205 * The kdev_t and uuid of a device can never change once it is
206 * initially inserted.
208 static int dm_hash_insert(const char *name
, const char *uuid
, struct mapped_device
*md
)
210 struct hash_cell
*cell
, *hc
;
213 * Allocate the new cells.
215 cell
= alloc_cell(name
, uuid
, md
);
220 * Insert the cell into both hash tables.
222 down_write(&_hash_lock
);
223 hc
= __get_name_cell(name
);
229 list_add(&cell
->name_list
, _name_buckets
+ hash_str(name
));
232 hc
= __get_uuid_cell(uuid
);
234 list_del(&cell
->name_list
);
238 list_add(&cell
->uuid_list
, _uuid_buckets
+ hash_str(uuid
));
241 mutex_lock(&dm_hash_cells_mutex
);
242 dm_set_mdptr(md
, cell
);
243 mutex_unlock(&dm_hash_cells_mutex
);
244 up_write(&_hash_lock
);
249 up_write(&_hash_lock
);
254 static struct dm_table
*__hash_remove(struct hash_cell
*hc
)
256 struct dm_table
*table
;
259 /* remove from the dev hash */
260 list_del(&hc
->uuid_list
);
261 list_del(&hc
->name_list
);
262 mutex_lock(&dm_hash_cells_mutex
);
263 dm_set_mdptr(hc
->md
, NULL
);
264 mutex_unlock(&dm_hash_cells_mutex
);
266 table
= dm_get_live_table(hc
->md
, &srcu_idx
);
268 dm_table_event(table
);
269 dm_put_live_table(hc
->md
, srcu_idx
);
280 static void dm_hash_remove_all(bool keep_open_devices
, bool mark_deferred
, bool only_deferred
)
283 struct hash_cell
*hc
;
284 struct mapped_device
*md
;
290 down_write(&_hash_lock
);
292 for (i
= 0; i
< NUM_BUCKETS
; i
++) {
293 list_for_each_entry(hc
, _name_buckets
+ i
, name_list
) {
297 if (keep_open_devices
&&
298 dm_lock_for_deletion(md
, mark_deferred
, only_deferred
)) {
304 t
= __hash_remove(hc
);
306 up_write(&_hash_lock
);
313 if (likely(keep_open_devices
))
316 dm_destroy_immediate(md
);
319 * Some mapped devices may be using other mapped
320 * devices, so repeat until we make no further
321 * progress. If a new mapped device is created
322 * here it will also get removed.
328 up_write(&_hash_lock
);
331 DMWARN("remove_all left %d open device(s)", dev_skipped
);
335 * Set the uuid of a hash_cell that isn't already set.
337 static void __set_cell_uuid(struct hash_cell
*hc
, char *new_uuid
)
339 mutex_lock(&dm_hash_cells_mutex
);
341 mutex_unlock(&dm_hash_cells_mutex
);
343 list_add(&hc
->uuid_list
, _uuid_buckets
+ hash_str(new_uuid
));
347 * Changes the name of a hash_cell and returns the old name for
348 * the caller to free.
350 static char *__change_cell_name(struct hash_cell
*hc
, char *new_name
)
355 * Rename and move the name cell.
357 list_del(&hc
->name_list
);
360 mutex_lock(&dm_hash_cells_mutex
);
362 mutex_unlock(&dm_hash_cells_mutex
);
364 list_add(&hc
->name_list
, _name_buckets
+ hash_str(new_name
));
369 static struct mapped_device
*dm_hash_rename(struct dm_ioctl
*param
,
372 char *new_data
, *old_name
= NULL
;
373 struct hash_cell
*hc
;
374 struct dm_table
*table
;
375 struct mapped_device
*md
;
376 unsigned change_uuid
= (param
->flags
& DM_UUID_FLAG
) ? 1 : 0;
382 new_data
= kstrdup(new, GFP_KERNEL
);
384 return ERR_PTR(-ENOMEM
);
386 down_write(&_hash_lock
);
392 hc
= __get_uuid_cell(new);
394 hc
= __get_name_cell(new);
397 DMWARN("Unable to change %s on mapped device %s to one that "
398 "already exists: %s",
399 change_uuid
? "uuid" : "name",
402 up_write(&_hash_lock
);
404 return ERR_PTR(-EBUSY
);
408 * Is there such a device as 'old' ?
410 hc
= __get_name_cell(param
->name
);
412 DMWARN("Unable to rename non-existent device, %s to %s%s",
413 param
->name
, change_uuid
? "uuid " : "", new);
414 up_write(&_hash_lock
);
416 return ERR_PTR(-ENXIO
);
420 * Does this device already have a uuid?
422 if (change_uuid
&& hc
->uuid
) {
423 DMWARN("Unable to change uuid of mapped device %s to %s "
424 "because uuid is already set to %s",
425 param
->name
, new, hc
->uuid
);
427 up_write(&_hash_lock
);
429 return ERR_PTR(-EINVAL
);
433 __set_cell_uuid(hc
, new_data
);
435 old_name
= __change_cell_name(hc
, new_data
);
438 * Wake up any dm event waiters.
440 table
= dm_get_live_table(hc
->md
, &srcu_idx
);
442 dm_table_event(table
);
443 dm_put_live_table(hc
->md
, srcu_idx
);
445 if (!dm_kobject_uevent(hc
->md
, KOBJ_CHANGE
, param
->event_nr
))
446 param
->flags
|= DM_UEVENT_GENERATED_FLAG
;
449 up_write(&_hash_lock
);
455 void dm_deferred_remove(void)
457 dm_hash_remove_all(true, false, true);
460 /*-----------------------------------------------------------------
461 * Implementation of the ioctl commands
462 *---------------------------------------------------------------*/
464 * All the ioctl commands get dispatched to functions with this
467 typedef int (*ioctl_fn
)(struct dm_ioctl
*param
, size_t param_size
);
469 static int remove_all(struct dm_ioctl
*param
, size_t param_size
)
471 dm_hash_remove_all(true, !!(param
->flags
& DM_DEFERRED_REMOVE
), false);
472 param
->data_size
= 0;
477 * Round up the ptr to an 8-byte boundary.
480 static inline void *align_ptr(void *ptr
)
482 return (void *) (((size_t) (ptr
+ ALIGN_MASK
)) & ~ALIGN_MASK
);
486 * Retrieves the data payload buffer from an already allocated
489 static void *get_result_buffer(struct dm_ioctl
*param
, size_t param_size
,
492 param
->data_start
= align_ptr(param
+ 1) - (void *) param
;
494 if (param
->data_start
< param_size
)
495 *len
= param_size
- param
->data_start
;
499 return ((void *) param
) + param
->data_start
;
502 static int list_devices(struct dm_ioctl
*param
, size_t param_size
)
505 struct hash_cell
*hc
;
506 size_t len
, needed
= 0;
507 struct gendisk
*disk
;
508 struct dm_name_list
*nl
, *old_nl
= NULL
;
510 down_write(&_hash_lock
);
513 * Loop through all the devices working out how much
516 for (i
= 0; i
< NUM_BUCKETS
; i
++) {
517 list_for_each_entry (hc
, _name_buckets
+ i
, name_list
) {
518 needed
+= sizeof(struct dm_name_list
);
519 needed
+= strlen(hc
->name
) + 1;
520 needed
+= ALIGN_MASK
;
525 * Grab our output buffer.
527 nl
= get_result_buffer(param
, param_size
, &len
);
529 param
->flags
|= DM_BUFFER_FULL_FLAG
;
532 param
->data_size
= param
->data_start
+ needed
;
534 nl
->dev
= 0; /* Flags no data */
537 * Now loop through filling out the names.
539 for (i
= 0; i
< NUM_BUCKETS
; i
++) {
540 list_for_each_entry (hc
, _name_buckets
+ i
, name_list
) {
542 old_nl
->next
= (uint32_t) ((void *) nl
-
544 disk
= dm_disk(hc
->md
);
545 nl
->dev
= huge_encode_dev(disk_devt(disk
));
547 strcpy(nl
->name
, hc
->name
);
550 nl
= align_ptr(((void *) ++nl
) + strlen(hc
->name
) + 1);
555 up_write(&_hash_lock
);
559 static void list_version_get_needed(struct target_type
*tt
, void *needed_param
)
561 size_t *needed
= needed_param
;
563 *needed
+= sizeof(struct dm_target_versions
);
564 *needed
+= strlen(tt
->name
);
565 *needed
+= ALIGN_MASK
;
568 static void list_version_get_info(struct target_type
*tt
, void *param
)
570 struct vers_iter
*info
= param
;
572 /* Check space - it might have changed since the first iteration */
573 if ((char *)info
->vers
+ sizeof(tt
->version
) + strlen(tt
->name
) + 1 >
576 info
->flags
= DM_BUFFER_FULL_FLAG
;
581 info
->old_vers
->next
= (uint32_t) ((void *)info
->vers
-
582 (void *)info
->old_vers
);
583 info
->vers
->version
[0] = tt
->version
[0];
584 info
->vers
->version
[1] = tt
->version
[1];
585 info
->vers
->version
[2] = tt
->version
[2];
586 info
->vers
->next
= 0;
587 strcpy(info
->vers
->name
, tt
->name
);
589 info
->old_vers
= info
->vers
;
590 info
->vers
= align_ptr(((void *) ++info
->vers
) + strlen(tt
->name
) + 1);
593 static int list_versions(struct dm_ioctl
*param
, size_t param_size
)
595 size_t len
, needed
= 0;
596 struct dm_target_versions
*vers
;
597 struct vers_iter iter_info
;
600 * Loop through all the devices working out how much
603 dm_target_iterate(list_version_get_needed
, &needed
);
606 * Grab our output buffer.
608 vers
= get_result_buffer(param
, param_size
, &len
);
610 param
->flags
|= DM_BUFFER_FULL_FLAG
;
613 param
->data_size
= param
->data_start
+ needed
;
615 iter_info
.param_size
= param_size
;
616 iter_info
.old_vers
= NULL
;
617 iter_info
.vers
= vers
;
619 iter_info
.end
= (char *)vers
+len
;
622 * Now loop through filling out the names & versions.
624 dm_target_iterate(list_version_get_info
, &iter_info
);
625 param
->flags
|= iter_info
.flags
;
631 static int check_name(const char *name
)
633 if (strchr(name
, '/')) {
634 DMWARN("invalid device name");
642 * On successful return, the caller must not attempt to acquire
643 * _hash_lock without first calling dm_put_live_table, because dm_table_destroy
644 * waits for this dm_put_live_table and could be called under this lock.
646 static struct dm_table
*dm_get_inactive_table(struct mapped_device
*md
, int *srcu_idx
)
648 struct hash_cell
*hc
;
649 struct dm_table
*table
= NULL
;
651 /* increment rcu count, we don't care about the table pointer */
652 dm_get_live_table(md
, srcu_idx
);
654 down_read(&_hash_lock
);
655 hc
= dm_get_mdptr(md
);
656 if (!hc
|| hc
->md
!= md
) {
657 DMWARN("device has been removed from the dev hash table.");
664 up_read(&_hash_lock
);
669 static struct dm_table
*dm_get_live_or_inactive_table(struct mapped_device
*md
,
670 struct dm_ioctl
*param
,
673 return (param
->flags
& DM_QUERY_INACTIVE_TABLE_FLAG
) ?
674 dm_get_inactive_table(md
, srcu_idx
) : dm_get_live_table(md
, srcu_idx
);
678 * Fills in a dm_ioctl structure, ready for sending back to
681 static void __dev_status(struct mapped_device
*md
, struct dm_ioctl
*param
)
683 struct gendisk
*disk
= dm_disk(md
);
684 struct dm_table
*table
;
687 param
->flags
&= ~(DM_SUSPEND_FLAG
| DM_READONLY_FLAG
|
688 DM_ACTIVE_PRESENT_FLAG
| DM_INTERNAL_SUSPEND_FLAG
);
690 if (dm_suspended_md(md
))
691 param
->flags
|= DM_SUSPEND_FLAG
;
693 if (dm_suspended_internally_md(md
))
694 param
->flags
|= DM_INTERNAL_SUSPEND_FLAG
;
696 if (dm_test_deferred_remove_flag(md
))
697 param
->flags
|= DM_DEFERRED_REMOVE
;
699 param
->dev
= huge_encode_dev(disk_devt(disk
));
702 * Yes, this will be out of date by the time it gets back
703 * to userland, but it is still very useful for
706 param
->open_count
= dm_open_count(md
);
708 param
->event_nr
= dm_get_event_nr(md
);
709 param
->target_count
= 0;
711 table
= dm_get_live_table(md
, &srcu_idx
);
713 if (!(param
->flags
& DM_QUERY_INACTIVE_TABLE_FLAG
)) {
714 if (get_disk_ro(disk
))
715 param
->flags
|= DM_READONLY_FLAG
;
716 param
->target_count
= dm_table_get_num_targets(table
);
719 param
->flags
|= DM_ACTIVE_PRESENT_FLAG
;
721 dm_put_live_table(md
, srcu_idx
);
723 if (param
->flags
& DM_QUERY_INACTIVE_TABLE_FLAG
) {
725 table
= dm_get_inactive_table(md
, &srcu_idx
);
727 if (!(dm_table_get_mode(table
) & FMODE_WRITE
))
728 param
->flags
|= DM_READONLY_FLAG
;
729 param
->target_count
= dm_table_get_num_targets(table
);
731 dm_put_live_table(md
, srcu_idx
);
735 static int dev_create(struct dm_ioctl
*param
, size_t param_size
)
737 int r
, m
= DM_ANY_MINOR
;
738 struct mapped_device
*md
;
740 r
= check_name(param
->name
);
744 if (param
->flags
& DM_PERSISTENT_DEV_FLAG
)
745 m
= MINOR(huge_decode_dev(param
->dev
));
747 r
= dm_create(m
, &md
);
751 r
= dm_hash_insert(param
->name
, *param
->uuid
? param
->uuid
: NULL
, md
);
758 param
->flags
&= ~DM_INACTIVE_PRESENT_FLAG
;
760 __dev_status(md
, param
);
768 * Always use UUID for lookups if it's present, otherwise use name or dev.
770 static struct hash_cell
*__find_device_hash_cell(struct dm_ioctl
*param
)
772 struct hash_cell
*hc
= NULL
;
775 if (*param
->name
|| param
->dev
)
778 hc
= __get_uuid_cell(param
->uuid
);
781 } else if (*param
->name
) {
785 hc
= __get_name_cell(param
->name
);
788 } else if (param
->dev
) {
789 hc
= __get_dev_cell(param
->dev
);
796 * Sneakily write in both the name and the uuid
797 * while we have the cell.
799 strlcpy(param
->name
, hc
->name
, sizeof(param
->name
));
801 strlcpy(param
->uuid
, hc
->uuid
, sizeof(param
->uuid
));
803 param
->uuid
[0] = '\0';
806 param
->flags
|= DM_INACTIVE_PRESENT_FLAG
;
808 param
->flags
&= ~DM_INACTIVE_PRESENT_FLAG
;
813 static struct mapped_device
*find_device(struct dm_ioctl
*param
)
815 struct hash_cell
*hc
;
816 struct mapped_device
*md
= NULL
;
818 down_read(&_hash_lock
);
819 hc
= __find_device_hash_cell(param
);
822 up_read(&_hash_lock
);
827 static int dev_remove(struct dm_ioctl
*param
, size_t param_size
)
829 struct hash_cell
*hc
;
830 struct mapped_device
*md
;
834 down_write(&_hash_lock
);
835 hc
= __find_device_hash_cell(param
);
838 DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
839 up_write(&_hash_lock
);
846 * Ensure the device is not open and nothing further can open it.
848 r
= dm_lock_for_deletion(md
, !!(param
->flags
& DM_DEFERRED_REMOVE
), false);
850 if (r
== -EBUSY
&& param
->flags
& DM_DEFERRED_REMOVE
) {
851 up_write(&_hash_lock
);
855 DMDEBUG_LIMIT("unable to remove open device %s", hc
->name
);
856 up_write(&_hash_lock
);
861 t
= __hash_remove(hc
);
862 up_write(&_hash_lock
);
869 param
->flags
&= ~DM_DEFERRED_REMOVE
;
871 if (!dm_kobject_uevent(md
, KOBJ_REMOVE
, param
->event_nr
))
872 param
->flags
|= DM_UEVENT_GENERATED_FLAG
;
880 * Check a string doesn't overrun the chunk of
881 * memory we copied from userland.
883 static int invalid_str(char *str
, void *end
)
885 while ((void *) str
< end
)
892 static int dev_rename(struct dm_ioctl
*param
, size_t param_size
)
895 char *new_data
= (char *) param
+ param
->data_start
;
896 struct mapped_device
*md
;
897 unsigned change_uuid
= (param
->flags
& DM_UUID_FLAG
) ? 1 : 0;
899 if (new_data
< param
->data
||
900 invalid_str(new_data
, (void *) param
+ param_size
) || !*new_data
||
901 strlen(new_data
) > (change_uuid
? DM_UUID_LEN
- 1 : DM_NAME_LEN
- 1)) {
902 DMWARN("Invalid new mapped device name or uuid string supplied.");
907 r
= check_name(new_data
);
912 md
= dm_hash_rename(param
, new_data
);
916 __dev_status(md
, param
);
922 static int dev_set_geometry(struct dm_ioctl
*param
, size_t param_size
)
925 struct mapped_device
*md
;
926 struct hd_geometry geometry
;
927 unsigned long indata
[4];
928 char *geostr
= (char *) param
+ param
->data_start
;
931 md
= find_device(param
);
935 if (geostr
< param
->data
||
936 invalid_str(geostr
, (void *) param
+ param_size
)) {
937 DMWARN("Invalid geometry supplied.");
941 x
= sscanf(geostr
, "%lu %lu %lu %lu%c", indata
,
942 indata
+ 1, indata
+ 2, indata
+ 3, &dummy
);
945 DMWARN("Unable to interpret geometry settings.");
949 if (indata
[0] > 65535 || indata
[1] > 255 ||
950 indata
[2] > 255 || indata
[3] > ULONG_MAX
) {
951 DMWARN("Geometry exceeds range limits.");
955 geometry
.cylinders
= indata
[0];
956 geometry
.heads
= indata
[1];
957 geometry
.sectors
= indata
[2];
958 geometry
.start
= indata
[3];
960 r
= dm_set_geometry(md
, &geometry
);
962 param
->data_size
= 0;
969 static int do_suspend(struct dm_ioctl
*param
)
972 unsigned suspend_flags
= DM_SUSPEND_LOCKFS_FLAG
;
973 struct mapped_device
*md
;
975 md
= find_device(param
);
979 if (param
->flags
& DM_SKIP_LOCKFS_FLAG
)
980 suspend_flags
&= ~DM_SUSPEND_LOCKFS_FLAG
;
981 if (param
->flags
& DM_NOFLUSH_FLAG
)
982 suspend_flags
|= DM_SUSPEND_NOFLUSH_FLAG
;
984 if (!dm_suspended_md(md
)) {
985 r
= dm_suspend(md
, suspend_flags
);
990 __dev_status(md
, param
);
998 static int do_resume(struct dm_ioctl
*param
)
1001 unsigned suspend_flags
= DM_SUSPEND_LOCKFS_FLAG
;
1002 struct hash_cell
*hc
;
1003 struct mapped_device
*md
;
1004 struct dm_table
*new_map
, *old_map
= NULL
;
1006 down_write(&_hash_lock
);
1008 hc
= __find_device_hash_cell(param
);
1010 DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
1011 up_write(&_hash_lock
);
1017 new_map
= hc
->new_map
;
1019 param
->flags
&= ~DM_INACTIVE_PRESENT_FLAG
;
1021 up_write(&_hash_lock
);
1023 /* Do we need to load a new map ? */
1025 /* Suspend if it isn't already suspended */
1026 if (param
->flags
& DM_SKIP_LOCKFS_FLAG
)
1027 suspend_flags
&= ~DM_SUSPEND_LOCKFS_FLAG
;
1028 if (param
->flags
& DM_NOFLUSH_FLAG
)
1029 suspend_flags
|= DM_SUSPEND_NOFLUSH_FLAG
;
1030 if (!dm_suspended_md(md
))
1031 dm_suspend(md
, suspend_flags
);
1033 old_map
= dm_swap_table(md
, new_map
);
1034 if (IS_ERR(old_map
)) {
1036 dm_table_destroy(new_map
);
1038 return PTR_ERR(old_map
);
1041 if (dm_table_get_mode(new_map
) & FMODE_WRITE
)
1042 set_disk_ro(dm_disk(md
), 0);
1044 set_disk_ro(dm_disk(md
), 1);
1047 if (dm_suspended_md(md
)) {
1049 if (!r
&& !dm_kobject_uevent(md
, KOBJ_CHANGE
, param
->event_nr
))
1050 param
->flags
|= DM_UEVENT_GENERATED_FLAG
;
1054 * Since dm_swap_table synchronizes RCU, nobody should be in
1055 * read-side critical section already.
1058 dm_table_destroy(old_map
);
1061 __dev_status(md
, param
);
1068 * Set or unset the suspension state of a device.
1069 * If the device already is in the requested state we just return its status.
1071 static int dev_suspend(struct dm_ioctl
*param
, size_t param_size
)
1073 if (param
->flags
& DM_SUSPEND_FLAG
)
1074 return do_suspend(param
);
1076 return do_resume(param
);
1080 * Copies device info back to user space, used by
1081 * the create and info ioctls.
1083 static int dev_status(struct dm_ioctl
*param
, size_t param_size
)
1085 struct mapped_device
*md
;
1087 md
= find_device(param
);
1091 __dev_status(md
, param
);
1098 * Build up the status struct for each target
1100 static void retrieve_status(struct dm_table
*table
,
1101 struct dm_ioctl
*param
, size_t param_size
)
1103 unsigned int i
, num_targets
;
1104 struct dm_target_spec
*spec
;
1105 char *outbuf
, *outptr
;
1107 size_t remaining
, len
, used
= 0;
1108 unsigned status_flags
= 0;
1110 outptr
= outbuf
= get_result_buffer(param
, param_size
, &len
);
1112 if (param
->flags
& DM_STATUS_TABLE_FLAG
)
1113 type
= STATUSTYPE_TABLE
;
1115 type
= STATUSTYPE_INFO
;
1117 /* Get all the target info */
1118 num_targets
= dm_table_get_num_targets(table
);
1119 for (i
= 0; i
< num_targets
; i
++) {
1120 struct dm_target
*ti
= dm_table_get_target(table
, i
);
1123 remaining
= len
- (outptr
- outbuf
);
1124 if (remaining
<= sizeof(struct dm_target_spec
)) {
1125 param
->flags
|= DM_BUFFER_FULL_FLAG
;
1129 spec
= (struct dm_target_spec
*) outptr
;
1132 spec
->sector_start
= ti
->begin
;
1133 spec
->length
= ti
->len
;
1134 strncpy(spec
->target_type
, ti
->type
->name
,
1135 sizeof(spec
->target_type
));
1137 outptr
+= sizeof(struct dm_target_spec
);
1138 remaining
= len
- (outptr
- outbuf
);
1139 if (remaining
<= 0) {
1140 param
->flags
|= DM_BUFFER_FULL_FLAG
;
1144 /* Get the status/table string from the target driver */
1145 if (ti
->type
->status
) {
1146 if (param
->flags
& DM_NOFLUSH_FLAG
)
1147 status_flags
|= DM_STATUS_NOFLUSH_FLAG
;
1148 ti
->type
->status(ti
, type
, status_flags
, outptr
, remaining
);
1152 l
= strlen(outptr
) + 1;
1153 if (l
== remaining
) {
1154 param
->flags
|= DM_BUFFER_FULL_FLAG
;
1159 used
= param
->data_start
+ (outptr
- outbuf
);
1161 outptr
= align_ptr(outptr
);
1162 spec
->next
= outptr
- outbuf
;
1166 param
->data_size
= used
;
1168 param
->target_count
= num_targets
;
1172 * Wait for a device to report an event
1174 static int dev_wait(struct dm_ioctl
*param
, size_t param_size
)
1177 struct mapped_device
*md
;
1178 struct dm_table
*table
;
1181 md
= find_device(param
);
1186 * Wait for a notification event
1188 if (dm_wait_event(md
, param
->event_nr
)) {
1194 * The userland program is going to want to know what
1195 * changed to trigger the event, so we may as well tell
1196 * him and save an ioctl.
1198 __dev_status(md
, param
);
1200 table
= dm_get_live_or_inactive_table(md
, param
, &srcu_idx
);
1202 retrieve_status(table
, param
, param_size
);
1203 dm_put_live_table(md
, srcu_idx
);
1211 static inline fmode_t
get_mode(struct dm_ioctl
*param
)
1213 fmode_t mode
= FMODE_READ
| FMODE_WRITE
;
1215 if (param
->flags
& DM_READONLY_FLAG
)
1221 static int next_target(struct dm_target_spec
*last
, uint32_t next
, void *end
,
1222 struct dm_target_spec
**spec
, char **target_params
)
1224 *spec
= (struct dm_target_spec
*) ((unsigned char *) last
+ next
);
1225 *target_params
= (char *) (*spec
+ 1);
1227 if (*spec
< (last
+ 1))
1230 return invalid_str(*target_params
, end
);
1233 static int populate_table(struct dm_table
*table
,
1234 struct dm_ioctl
*param
, size_t param_size
)
1238 struct dm_target_spec
*spec
= (struct dm_target_spec
*) param
;
1239 uint32_t next
= param
->data_start
;
1240 void *end
= (void *) param
+ param_size
;
1241 char *target_params
;
1243 if (!param
->target_count
) {
1244 DMWARN("populate_table: no targets specified");
1248 for (i
= 0; i
< param
->target_count
; i
++) {
1250 r
= next_target(spec
, next
, end
, &spec
, &target_params
);
1252 DMWARN("unable to find target");
1256 r
= dm_table_add_target(table
, spec
->target_type
,
1257 (sector_t
) spec
->sector_start
,
1258 (sector_t
) spec
->length
,
1261 DMWARN("error adding target to table");
1268 return dm_table_complete(table
);
1271 static bool is_valid_type(unsigned cur
, unsigned new)
1274 (cur
== DM_TYPE_BIO_BASED
&& new == DM_TYPE_DAX_BIO_BASED
))
1280 static int table_load(struct dm_ioctl
*param
, size_t param_size
)
1283 struct hash_cell
*hc
;
1284 struct dm_table
*t
, *old_map
= NULL
;
1285 struct mapped_device
*md
;
1286 struct target_type
*immutable_target_type
;
1288 md
= find_device(param
);
1292 r
= dm_table_create(&t
, get_mode(param
), param
->target_count
, md
);
1296 /* Protect md->type and md->queue against concurrent table loads. */
1297 dm_lock_md_type(md
);
1298 r
= populate_table(t
, param
, param_size
);
1300 goto err_unlock_md_type
;
1302 immutable_target_type
= dm_get_immutable_target_type(md
);
1303 if (immutable_target_type
&&
1304 (immutable_target_type
!= dm_table_get_immutable_target_type(t
)) &&
1305 !dm_table_get_wildcard_target(t
)) {
1306 DMWARN("can't replace immutable target type %s",
1307 immutable_target_type
->name
);
1309 goto err_unlock_md_type
;
1312 if (dm_get_md_type(md
) == DM_TYPE_NONE
) {
1313 /* Initial table load: acquire type of table. */
1314 dm_set_md_type(md
, dm_table_get_type(t
));
1316 /* setup md->queue to reflect md's type (may block) */
1317 r
= dm_setup_md_queue(md
, t
);
1319 DMWARN("unable to set up device queue for new table.");
1320 goto err_unlock_md_type
;
1322 } else if (!is_valid_type(dm_get_md_type(md
), dm_table_get_type(t
))) {
1323 DMWARN("can't change device type after initial table load.");
1325 goto err_unlock_md_type
;
1328 dm_unlock_md_type(md
);
1330 /* stage inactive table */
1331 down_write(&_hash_lock
);
1332 hc
= dm_get_mdptr(md
);
1333 if (!hc
|| hc
->md
!= md
) {
1334 DMWARN("device has been removed from the dev hash table.");
1335 up_write(&_hash_lock
);
1337 goto err_destroy_table
;
1341 old_map
= hc
->new_map
;
1343 up_write(&_hash_lock
);
1345 param
->flags
|= DM_INACTIVE_PRESENT_FLAG
;
1346 __dev_status(md
, param
);
1350 dm_table_destroy(old_map
);
1358 dm_unlock_md_type(md
);
1360 dm_table_destroy(t
);
1367 static int table_clear(struct dm_ioctl
*param
, size_t param_size
)
1369 struct hash_cell
*hc
;
1370 struct mapped_device
*md
;
1371 struct dm_table
*old_map
= NULL
;
1373 down_write(&_hash_lock
);
1375 hc
= __find_device_hash_cell(param
);
1377 DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
1378 up_write(&_hash_lock
);
1383 old_map
= hc
->new_map
;
1387 param
->flags
&= ~DM_INACTIVE_PRESENT_FLAG
;
1389 __dev_status(hc
->md
, param
);
1391 up_write(&_hash_lock
);
1394 dm_table_destroy(old_map
);
1402 * Retrieves a list of devices used by a particular dm device.
1404 static void retrieve_deps(struct dm_table
*table
,
1405 struct dm_ioctl
*param
, size_t param_size
)
1407 unsigned int count
= 0;
1408 struct list_head
*tmp
;
1410 struct dm_dev_internal
*dd
;
1411 struct dm_target_deps
*deps
;
1413 deps
= get_result_buffer(param
, param_size
, &len
);
1416 * Count the devices.
1418 list_for_each (tmp
, dm_table_get_devices(table
))
1422 * Check we have enough space.
1424 needed
= sizeof(*deps
) + (sizeof(*deps
->dev
) * count
);
1426 param
->flags
|= DM_BUFFER_FULL_FLAG
;
1431 * Fill in the devices.
1433 deps
->count
= count
;
1435 list_for_each_entry (dd
, dm_table_get_devices(table
), list
)
1436 deps
->dev
[count
++] = huge_encode_dev(dd
->dm_dev
->bdev
->bd_dev
);
1438 param
->data_size
= param
->data_start
+ needed
;
1441 static int table_deps(struct dm_ioctl
*param
, size_t param_size
)
1443 struct mapped_device
*md
;
1444 struct dm_table
*table
;
1447 md
= find_device(param
);
1451 __dev_status(md
, param
);
1453 table
= dm_get_live_or_inactive_table(md
, param
, &srcu_idx
);
1455 retrieve_deps(table
, param
, param_size
);
1456 dm_put_live_table(md
, srcu_idx
);
1464 * Return the status of a device as a text string for each
1467 static int table_status(struct dm_ioctl
*param
, size_t param_size
)
1469 struct mapped_device
*md
;
1470 struct dm_table
*table
;
1473 md
= find_device(param
);
1477 __dev_status(md
, param
);
1479 table
= dm_get_live_or_inactive_table(md
, param
, &srcu_idx
);
1481 retrieve_status(table
, param
, param_size
);
1482 dm_put_live_table(md
, srcu_idx
);
1490 * Process device-mapper dependent messages. Messages prefixed with '@'
1491 * are processed by the DM core. All others are delivered to the target.
1492 * Returns a number <= 1 if message was processed by device mapper.
1493 * Returns 2 if message should be delivered to the target.
1495 static int message_for_md(struct mapped_device
*md
, unsigned argc
, char **argv
,
1496 char *result
, unsigned maxlen
)
1501 return 2; /* no '@' prefix, deliver to target */
1503 if (!strcasecmp(argv
[0], "@cancel_deferred_remove")) {
1505 DMERR("Invalid arguments for @cancel_deferred_remove");
1508 return dm_cancel_deferred_remove(md
);
1511 r
= dm_stats_message(md
, argc
, argv
, result
, maxlen
);
1515 DMERR("Unsupported message sent to DM core: %s", argv
[0]);
1520 * Pass a message to the target that's at the supplied device offset.
1522 static int target_message(struct dm_ioctl
*param
, size_t param_size
)
1526 struct mapped_device
*md
;
1527 struct dm_table
*table
;
1528 struct dm_target
*ti
;
1529 struct dm_target_msg
*tmsg
= (void *) param
+ param
->data_start
;
1531 char *result
= get_result_buffer(param
, param_size
, &maxlen
);
1534 md
= find_device(param
);
1538 if (tmsg
< (struct dm_target_msg
*) param
->data
||
1539 invalid_str(tmsg
->message
, (void *) param
+ param_size
)) {
1540 DMWARN("Invalid target message parameters.");
1545 r
= dm_split_args(&argc
, &argv
, tmsg
->message
);
1547 DMWARN("Failed to split target message parameters");
1552 DMWARN("Empty message received.");
1556 r
= message_for_md(md
, argc
, argv
, result
, maxlen
);
1560 table
= dm_get_live_table(md
, &srcu_idx
);
1564 if (dm_deleting_md(md
)) {
1569 ti
= dm_table_find_target(table
, tmsg
->sector
);
1570 if (!dm_target_is_valid(ti
)) {
1571 DMWARN("Target message sector outside device.");
1573 } else if (ti
->type
->message
)
1574 r
= ti
->type
->message(ti
, argc
, argv
);
1576 DMWARN("Target type does not support messages");
1581 dm_put_live_table(md
, srcu_idx
);
1586 __dev_status(md
, param
);
1589 param
->flags
|= DM_DATA_OUT_FLAG
;
1590 if (dm_message_test_buffer_overflow(result
, maxlen
))
1591 param
->flags
|= DM_BUFFER_FULL_FLAG
;
1593 param
->data_size
= param
->data_start
+ strlen(result
) + 1;
1602 * The ioctl parameter block consists of two parts, a dm_ioctl struct
1603 * followed by a data buffer. This flag is set if the second part,
1604 * which has a variable size, is not used by the function processing
1607 #define IOCTL_FLAGS_NO_PARAMS 1
1609 /*-----------------------------------------------------------------
1610 * Implementation of open/close/ioctl on the special char
1612 *---------------------------------------------------------------*/
1613 static ioctl_fn
lookup_ioctl(unsigned int cmd
, int *ioctl_flags
)
1620 {DM_VERSION_CMD
, 0, NULL
}, /* version is dealt with elsewhere */
1621 {DM_REMOVE_ALL_CMD
, IOCTL_FLAGS_NO_PARAMS
, remove_all
},
1622 {DM_LIST_DEVICES_CMD
, 0, list_devices
},
1624 {DM_DEV_CREATE_CMD
, IOCTL_FLAGS_NO_PARAMS
, dev_create
},
1625 {DM_DEV_REMOVE_CMD
, IOCTL_FLAGS_NO_PARAMS
, dev_remove
},
1626 {DM_DEV_RENAME_CMD
, 0, dev_rename
},
1627 {DM_DEV_SUSPEND_CMD
, IOCTL_FLAGS_NO_PARAMS
, dev_suspend
},
1628 {DM_DEV_STATUS_CMD
, IOCTL_FLAGS_NO_PARAMS
, dev_status
},
1629 {DM_DEV_WAIT_CMD
, 0, dev_wait
},
1631 {DM_TABLE_LOAD_CMD
, 0, table_load
},
1632 {DM_TABLE_CLEAR_CMD
, IOCTL_FLAGS_NO_PARAMS
, table_clear
},
1633 {DM_TABLE_DEPS_CMD
, 0, table_deps
},
1634 {DM_TABLE_STATUS_CMD
, 0, table_status
},
1636 {DM_LIST_VERSIONS_CMD
, 0, list_versions
},
1638 {DM_TARGET_MSG_CMD
, 0, target_message
},
1639 {DM_DEV_SET_GEOMETRY_CMD
, 0, dev_set_geometry
}
1642 if (unlikely(cmd
>= ARRAY_SIZE(_ioctls
)))
1645 *ioctl_flags
= _ioctls
[cmd
].flags
;
1646 return _ioctls
[cmd
].fn
;
1650 * As well as checking the version compatibility this always
1651 * copies the kernel interface version out.
1653 static int check_version(unsigned int cmd
, struct dm_ioctl __user
*user
)
1655 uint32_t version
[3];
1658 if (copy_from_user(version
, user
->version
, sizeof(version
)))
1661 if ((DM_VERSION_MAJOR
!= version
[0]) ||
1662 (DM_VERSION_MINOR
< version
[1])) {
1663 DMWARN("ioctl interface mismatch: "
1664 "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)",
1665 DM_VERSION_MAJOR
, DM_VERSION_MINOR
,
1666 DM_VERSION_PATCHLEVEL
,
1667 version
[0], version
[1], version
[2], cmd
);
1672 * Fill in the kernel version.
1674 version
[0] = DM_VERSION_MAJOR
;
1675 version
[1] = DM_VERSION_MINOR
;
1676 version
[2] = DM_VERSION_PATCHLEVEL
;
1677 if (copy_to_user(user
->version
, version
, sizeof(version
)))
1683 #define DM_PARAMS_MALLOC 0x0001 /* Params allocated with kvmalloc() */
1684 #define DM_WIPE_BUFFER 0x0010 /* Wipe input buffer before returning from ioctl */
1686 static void free_params(struct dm_ioctl
*param
, size_t param_size
, int param_flags
)
1688 if (param_flags
& DM_WIPE_BUFFER
)
1689 memset(param
, 0, param_size
);
1691 if (param_flags
& DM_PARAMS_MALLOC
)
1695 static int copy_params(struct dm_ioctl __user
*user
, struct dm_ioctl
*param_kernel
,
1697 struct dm_ioctl
**param
, int *param_flags
)
1699 struct dm_ioctl
*dmi
;
1701 const size_t minimum_data_size
= offsetof(struct dm_ioctl
, data
);
1703 if (copy_from_user(param_kernel
, user
, minimum_data_size
))
1706 if (param_kernel
->data_size
< minimum_data_size
)
1709 secure_data
= param_kernel
->flags
& DM_SECURE_DATA_FLAG
;
1711 *param_flags
= secure_data
? DM_WIPE_BUFFER
: 0;
1713 if (ioctl_flags
& IOCTL_FLAGS_NO_PARAMS
) {
1715 dmi
->data_size
= minimum_data_size
;
1720 * Try to avoid low memory issues when a device is suspended.
1721 * Use kmalloc() rather than vmalloc() when we can.
1724 if (param_kernel
->data_size
<= KMALLOC_MAX_SIZE
)
1725 dmi
= kmalloc(param_kernel
->data_size
, GFP_NOIO
| __GFP_NORETRY
| __GFP_NOMEMALLOC
| __GFP_NOWARN
);
1729 noio_flag
= memalloc_noio_save();
1730 dmi
= __vmalloc(param_kernel
->data_size
, GFP_NOIO
| __GFP_HIGH
| __GFP_HIGHMEM
, PAGE_KERNEL
);
1731 memalloc_noio_restore(noio_flag
);
1735 if (secure_data
&& clear_user(user
, param_kernel
->data_size
))
1740 *param_flags
|= DM_PARAMS_MALLOC
;
1742 if (copy_from_user(dmi
, user
, param_kernel
->data_size
))
1747 * Abort if something changed the ioctl data while it was being copied.
1749 if (dmi
->data_size
!= param_kernel
->data_size
) {
1750 DMERR("rejecting ioctl: data size modified while processing parameters");
1754 /* Wipe the user buffer so we do not return it to userspace */
1755 if (secure_data
&& clear_user(user
, param_kernel
->data_size
))
1762 free_params(dmi
, param_kernel
->data_size
, *param_flags
);
1767 static int validate_params(uint cmd
, struct dm_ioctl
*param
)
1769 /* Always clear this flag */
1770 param
->flags
&= ~DM_BUFFER_FULL_FLAG
;
1771 param
->flags
&= ~DM_UEVENT_GENERATED_FLAG
;
1772 param
->flags
&= ~DM_SECURE_DATA_FLAG
;
1773 param
->flags
&= ~DM_DATA_OUT_FLAG
;
1775 /* Ignores parameters */
1776 if (cmd
== DM_REMOVE_ALL_CMD
||
1777 cmd
== DM_LIST_DEVICES_CMD
||
1778 cmd
== DM_LIST_VERSIONS_CMD
)
1781 if ((cmd
== DM_DEV_CREATE_CMD
)) {
1782 if (!*param
->name
) {
1783 DMWARN("name not supplied when creating device");
1786 } else if ((*param
->uuid
&& *param
->name
)) {
1787 DMWARN("only supply one of name or uuid, cmd(%u)", cmd
);
1791 /* Ensure strings are terminated */
1792 param
->name
[DM_NAME_LEN
- 1] = '\0';
1793 param
->uuid
[DM_UUID_LEN
- 1] = '\0';
1798 static int ctl_ioctl(uint command
, struct dm_ioctl __user
*user
)
1804 struct dm_ioctl
*uninitialized_var(param
);
1806 size_t input_param_size
;
1807 struct dm_ioctl param_kernel
;
1809 /* only root can play with this */
1810 if (!capable(CAP_SYS_ADMIN
))
1813 if (_IOC_TYPE(command
) != DM_IOCTL
)
1816 cmd
= _IOC_NR(command
);
1819 * Check the interface version passed in. This also
1820 * writes out the kernel's interface version.
1822 r
= check_version(cmd
, user
);
1827 * Nothing more to do for the version command.
1829 if (cmd
== DM_VERSION_CMD
)
1832 fn
= lookup_ioctl(cmd
, &ioctl_flags
);
1834 DMWARN("dm_ctl_ioctl: unknown command 0x%x", command
);
1839 * Copy the parameters into kernel space.
1841 r
= copy_params(user
, ¶m_kernel
, ioctl_flags
, ¶m
, ¶m_flags
);
1846 input_param_size
= param
->data_size
;
1847 r
= validate_params(cmd
, param
);
1851 param
->data_size
= sizeof(*param
);
1852 r
= fn(param
, input_param_size
);
1854 if (unlikely(param
->flags
& DM_BUFFER_FULL_FLAG
) &&
1855 unlikely(ioctl_flags
& IOCTL_FLAGS_NO_PARAMS
))
1856 DMERR("ioctl %d tried to output some data but has IOCTL_FLAGS_NO_PARAMS set", cmd
);
1859 * Copy the results back to userland.
1861 if (!r
&& copy_to_user(user
, param
, param
->data_size
))
1865 free_params(param
, input_param_size
, param_flags
);
1869 static long dm_ctl_ioctl(struct file
*file
, uint command
, ulong u
)
1871 return (long)ctl_ioctl(command
, (struct dm_ioctl __user
*)u
);
1874 #ifdef CONFIG_COMPAT
1875 static long dm_compat_ctl_ioctl(struct file
*file
, uint command
, ulong u
)
1877 return (long)dm_ctl_ioctl(file
, command
, (ulong
) compat_ptr(u
));
1880 #define dm_compat_ctl_ioctl NULL
1883 static const struct file_operations _ctl_fops
= {
1884 .open
= nonseekable_open
,
1885 .unlocked_ioctl
= dm_ctl_ioctl
,
1886 .compat_ioctl
= dm_compat_ctl_ioctl
,
1887 .owner
= THIS_MODULE
,
1888 .llseek
= noop_llseek
,
1891 static struct miscdevice _dm_misc
= {
1892 .minor
= MAPPER_CTRL_MINOR
,
1894 .nodename
= DM_DIR
"/" DM_CONTROL_NODE
,
1898 MODULE_ALIAS_MISCDEV(MAPPER_CTRL_MINOR
);
1899 MODULE_ALIAS("devname:" DM_DIR
"/" DM_CONTROL_NODE
);
1902 * Create misc character device and link to DM_DIR/control.
1904 int __init
dm_interface_init(void)
1912 r
= misc_register(&_dm_misc
);
1914 DMERR("misc_register failed for control device");
1919 DMINFO("%d.%d.%d%s initialised: %s", DM_VERSION_MAJOR
,
1920 DM_VERSION_MINOR
, DM_VERSION_PATCHLEVEL
, DM_VERSION_EXTRA
,
1925 void dm_interface_exit(void)
1927 misc_deregister(&_dm_misc
);
1932 * dm_copy_name_and_uuid - Copy mapped device name & uuid into supplied buffers
1933 * @md: Pointer to mapped_device
1934 * @name: Buffer (size DM_NAME_LEN) for name
1935 * @uuid: Buffer (size DM_UUID_LEN) for uuid or empty string if uuid not defined
1937 int dm_copy_name_and_uuid(struct mapped_device
*md
, char *name
, char *uuid
)
1940 struct hash_cell
*hc
;
1945 mutex_lock(&dm_hash_cells_mutex
);
1946 hc
= dm_get_mdptr(md
);
1947 if (!hc
|| hc
->md
!= md
) {
1953 strcpy(name
, hc
->name
);
1955 strcpy(uuid
, hc
->uuid
? : "");
1958 mutex_unlock(&dm_hash_cells_mutex
);