2 * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
3 * Copyright (C) 2004 - 2005 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/init.h>
14 #include <linux/wait.h>
15 #include <linux/slab.h>
16 #include <linux/devfs_fs_kernel.h>
17 #include <linux/dm-ioctl.h>
19 #include <asm/uaccess.h>
21 #define DM_DRIVER_EMAIL "dm-devel@redhat.com"
23 /*-----------------------------------------------------------------
24 * The ioctl interface needs to be able to look up devices by
26 *---------------------------------------------------------------*/
28 struct list_head name_list
;
29 struct list_head uuid_list
;
33 struct mapped_device
*md
;
34 struct dm_table
*new_map
;
39 struct dm_target_versions
*vers
, *old_vers
;
45 #define NUM_BUCKETS 64
46 #define MASK_BUCKETS (NUM_BUCKETS - 1)
47 static struct list_head _name_buckets
[NUM_BUCKETS
];
48 static struct list_head _uuid_buckets
[NUM_BUCKETS
];
50 static void dm_hash_remove_all(void);
53 * Guards access to both hash tables.
55 static DECLARE_RWSEM(_hash_lock
);
57 static void init_buckets(struct list_head
*buckets
)
61 for (i
= 0; i
< NUM_BUCKETS
; i
++)
62 INIT_LIST_HEAD(buckets
+ i
);
65 static int dm_hash_init(void)
67 init_buckets(_name_buckets
);
68 init_buckets(_uuid_buckets
);
73 static void dm_hash_exit(void)
79 /*-----------------------------------------------------------------
81 * We're not really concerned with the str hash function being
82 * fast since it's only used by the ioctl interface.
83 *---------------------------------------------------------------*/
84 static unsigned int hash_str(const char *str
)
86 const unsigned int hash_mult
= 2654435387U;
90 h
= (h
+ (unsigned int) *str
++) * hash_mult
;
92 return h
& MASK_BUCKETS
;
95 /*-----------------------------------------------------------------
96 * Code for looking up a device by name
97 *---------------------------------------------------------------*/
98 static struct hash_cell
*__get_name_cell(const char *str
)
100 struct hash_cell
*hc
;
101 unsigned int h
= hash_str(str
);
103 list_for_each_entry (hc
, _name_buckets
+ h
, name_list
)
104 if (!strcmp(hc
->name
, str
))
110 static struct hash_cell
*__get_uuid_cell(const char *str
)
112 struct hash_cell
*hc
;
113 unsigned int h
= hash_str(str
);
115 list_for_each_entry (hc
, _uuid_buckets
+ h
, uuid_list
)
116 if (!strcmp(hc
->uuid
, str
))
122 /*-----------------------------------------------------------------
123 * Inserting, removing and renaming a device.
124 *---------------------------------------------------------------*/
125 static struct hash_cell
*alloc_cell(const char *name
, const char *uuid
,
126 struct mapped_device
*md
)
128 struct hash_cell
*hc
;
130 hc
= kmalloc(sizeof(*hc
), GFP_KERNEL
);
134 hc
->name
= kstrdup(name
, GFP_KERNEL
);
144 hc
->uuid
= kstrdup(uuid
, GFP_KERNEL
);
152 INIT_LIST_HEAD(&hc
->name_list
);
153 INIT_LIST_HEAD(&hc
->uuid_list
);
159 static void free_cell(struct hash_cell
*hc
)
171 static int register_with_devfs(struct hash_cell
*hc
)
173 struct gendisk
*disk
= dm_disk(hc
->md
);
175 devfs_mk_bdev(MKDEV(disk
->major
, disk
->first_minor
),
176 S_IFBLK
| S_IRUSR
| S_IWUSR
| S_IRGRP
,
177 DM_DIR
"/%s", hc
->name
);
181 static int unregister_with_devfs(struct hash_cell
*hc
)
183 devfs_remove(DM_DIR
"/%s", hc
->name
);
188 * The kdev_t and uuid of a device can never change once it is
189 * initially inserted.
191 static int dm_hash_insert(const char *name
, const char *uuid
, struct mapped_device
*md
)
193 struct hash_cell
*cell
;
196 * Allocate the new cells.
198 cell
= alloc_cell(name
, uuid
, md
);
203 * Insert the cell into both hash tables.
205 down_write(&_hash_lock
);
206 if (__get_name_cell(name
))
209 list_add(&cell
->name_list
, _name_buckets
+ hash_str(name
));
212 if (__get_uuid_cell(uuid
)) {
213 list_del(&cell
->name_list
);
216 list_add(&cell
->uuid_list
, _uuid_buckets
+ hash_str(uuid
));
218 register_with_devfs(cell
);
220 dm_set_mdptr(md
, cell
);
221 up_write(&_hash_lock
);
226 up_write(&_hash_lock
);
231 static void __hash_remove(struct hash_cell
*hc
)
233 struct dm_table
*table
;
235 /* remove from the dev hash */
236 list_del(&hc
->uuid_list
);
237 list_del(&hc
->name_list
);
238 unregister_with_devfs(hc
);
239 dm_set_mdptr(hc
->md
, NULL
);
241 table
= dm_get_table(hc
->md
);
243 dm_table_event(table
);
249 dm_table_put(hc
->new_map
);
253 static void dm_hash_remove_all(void)
256 struct hash_cell
*hc
;
257 struct list_head
*tmp
, *n
;
259 down_write(&_hash_lock
);
260 for (i
= 0; i
< NUM_BUCKETS
; i
++) {
261 list_for_each_safe (tmp
, n
, _name_buckets
+ i
) {
262 hc
= list_entry(tmp
, struct hash_cell
, name_list
);
266 up_write(&_hash_lock
);
269 static int dm_hash_rename(const char *old
, const char *new)
271 char *new_name
, *old_name
;
272 struct hash_cell
*hc
;
273 struct dm_table
*table
;
278 new_name
= kstrdup(new, GFP_KERNEL
);
282 down_write(&_hash_lock
);
287 hc
= __get_name_cell(new);
289 DMWARN("asked to rename to an already existing name %s -> %s",
291 up_write(&_hash_lock
);
297 * Is there such a device as 'old' ?
299 hc
= __get_name_cell(old
);
301 DMWARN("asked to rename a non existent device %s -> %s",
303 up_write(&_hash_lock
);
309 * rename and move the name cell.
311 unregister_with_devfs(hc
);
313 list_del(&hc
->name_list
);
316 list_add(&hc
->name_list
, _name_buckets
+ hash_str(new_name
));
318 /* rename the device node in devfs */
319 register_with_devfs(hc
);
322 * Wake up any dm event waiters.
324 table
= dm_get_table(hc
->md
);
326 dm_table_event(table
);
330 up_write(&_hash_lock
);
335 /*-----------------------------------------------------------------
336 * Implementation of the ioctl commands
337 *---------------------------------------------------------------*/
339 * All the ioctl commands get dispatched to functions with this
342 typedef int (*ioctl_fn
)(struct dm_ioctl
*param
, size_t param_size
);
344 static int remove_all(struct dm_ioctl
*param
, size_t param_size
)
346 dm_hash_remove_all();
347 param
->data_size
= 0;
352 * Round up the ptr to an 8-byte boundary.
355 static inline void *align_ptr(void *ptr
)
357 return (void *) (((size_t) (ptr
+ ALIGN_MASK
)) & ~ALIGN_MASK
);
361 * Retrieves the data payload buffer from an already allocated
364 static void *get_result_buffer(struct dm_ioctl
*param
, size_t param_size
,
367 param
->data_start
= align_ptr(param
+ 1) - (void *) param
;
369 if (param
->data_start
< param_size
)
370 *len
= param_size
- param
->data_start
;
374 return ((void *) param
) + param
->data_start
;
377 static int list_devices(struct dm_ioctl
*param
, size_t param_size
)
380 struct hash_cell
*hc
;
381 size_t len
, needed
= 0;
382 struct gendisk
*disk
;
383 struct dm_name_list
*nl
, *old_nl
= NULL
;
385 down_write(&_hash_lock
);
388 * Loop through all the devices working out how much
391 for (i
= 0; i
< NUM_BUCKETS
; i
++) {
392 list_for_each_entry (hc
, _name_buckets
+ i
, name_list
) {
393 needed
+= sizeof(struct dm_name_list
);
394 needed
+= strlen(hc
->name
) + 1;
395 needed
+= ALIGN_MASK
;
400 * Grab our output buffer.
402 nl
= get_result_buffer(param
, param_size
, &len
);
404 param
->flags
|= DM_BUFFER_FULL_FLAG
;
407 param
->data_size
= param
->data_start
+ needed
;
409 nl
->dev
= 0; /* Flags no data */
412 * Now loop through filling out the names.
414 for (i
= 0; i
< NUM_BUCKETS
; i
++) {
415 list_for_each_entry (hc
, _name_buckets
+ i
, name_list
) {
417 old_nl
->next
= (uint32_t) ((void *) nl
-
419 disk
= dm_disk(hc
->md
);
420 nl
->dev
= huge_encode_dev(MKDEV(disk
->major
, disk
->first_minor
));
422 strcpy(nl
->name
, hc
->name
);
425 nl
= align_ptr(((void *) ++nl
) + strlen(hc
->name
) + 1);
430 up_write(&_hash_lock
);
434 static void list_version_get_needed(struct target_type
*tt
, void *needed_param
)
436 size_t *needed
= needed_param
;
438 *needed
+= sizeof(struct dm_target_versions
);
439 *needed
+= strlen(tt
->name
);
440 *needed
+= ALIGN_MASK
;
443 static void list_version_get_info(struct target_type
*tt
, void *param
)
445 struct vers_iter
*info
= param
;
447 /* Check space - it might have changed since the first iteration */
448 if ((char *)info
->vers
+ sizeof(tt
->version
) + strlen(tt
->name
) + 1 >
451 info
->flags
= DM_BUFFER_FULL_FLAG
;
456 info
->old_vers
->next
= (uint32_t) ((void *)info
->vers
-
457 (void *)info
->old_vers
);
458 info
->vers
->version
[0] = tt
->version
[0];
459 info
->vers
->version
[1] = tt
->version
[1];
460 info
->vers
->version
[2] = tt
->version
[2];
461 info
->vers
->next
= 0;
462 strcpy(info
->vers
->name
, tt
->name
);
464 info
->old_vers
= info
->vers
;
465 info
->vers
= align_ptr(((void *) ++info
->vers
) + strlen(tt
->name
) + 1);
468 static int list_versions(struct dm_ioctl
*param
, size_t param_size
)
470 size_t len
, needed
= 0;
471 struct dm_target_versions
*vers
;
472 struct vers_iter iter_info
;
475 * Loop through all the devices working out how much
478 dm_target_iterate(list_version_get_needed
, &needed
);
481 * Grab our output buffer.
483 vers
= get_result_buffer(param
, param_size
, &len
);
485 param
->flags
|= DM_BUFFER_FULL_FLAG
;
488 param
->data_size
= param
->data_start
+ needed
;
490 iter_info
.param_size
= param_size
;
491 iter_info
.old_vers
= NULL
;
492 iter_info
.vers
= vers
;
494 iter_info
.end
= (char *)vers
+len
;
497 * Now loop through filling out the names & versions.
499 dm_target_iterate(list_version_get_info
, &iter_info
);
500 param
->flags
|= iter_info
.flags
;
508 static int check_name(const char *name
)
510 if (strchr(name
, '/')) {
511 DMWARN("invalid device name");
519 * Fills in a dm_ioctl structure, ready for sending back to
522 static int __dev_status(struct mapped_device
*md
, struct dm_ioctl
*param
)
524 struct gendisk
*disk
= dm_disk(md
);
525 struct dm_table
*table
;
526 struct block_device
*bdev
;
528 param
->flags
&= ~(DM_SUSPEND_FLAG
| DM_READONLY_FLAG
|
529 DM_ACTIVE_PRESENT_FLAG
);
531 if (dm_suspended(md
))
532 param
->flags
|= DM_SUSPEND_FLAG
;
534 param
->dev
= huge_encode_dev(MKDEV(disk
->major
, disk
->first_minor
));
536 if (!(param
->flags
& DM_SKIP_BDGET_FLAG
)) {
537 bdev
= bdget_disk(disk
, 0);
542 * Yes, this will be out of date by the time it gets back
543 * to userland, but it is still very useful for
546 param
->open_count
= bdev
->bd_openers
;
549 param
->open_count
= -1;
552 param
->flags
|= DM_READONLY_FLAG
;
554 param
->event_nr
= dm_get_event_nr(md
);
556 table
= dm_get_table(md
);
558 param
->flags
|= DM_ACTIVE_PRESENT_FLAG
;
559 param
->target_count
= dm_table_get_num_targets(table
);
562 param
->target_count
= 0;
567 static int dev_create(struct dm_ioctl
*param
, size_t param_size
)
570 struct mapped_device
*md
;
572 r
= check_name(param
->name
);
576 if (param
->flags
& DM_PERSISTENT_DEV_FLAG
)
577 r
= dm_create_with_minor(MINOR(huge_decode_dev(param
->dev
)), &md
);
584 r
= dm_hash_insert(param
->name
, *param
->uuid
? param
->uuid
: NULL
, md
);
590 param
->flags
&= ~DM_INACTIVE_PRESENT_FLAG
;
592 r
= __dev_status(md
, param
);
599 * Always use UUID for lookups if it's present, otherwise use name or dev.
601 static inline struct hash_cell
*__find_device_hash_cell(struct dm_ioctl
*param
)
604 return __get_uuid_cell(param
->uuid
);
605 else if (*param
->name
)
606 return __get_name_cell(param
->name
);
608 return dm_get_mdptr(huge_decode_dev(param
->dev
));
611 static inline struct mapped_device
*find_device(struct dm_ioctl
*param
)
613 struct hash_cell
*hc
;
614 struct mapped_device
*md
= NULL
;
616 down_read(&_hash_lock
);
617 hc
= __find_device_hash_cell(param
);
623 * Sneakily write in both the name and the uuid
624 * while we have the cell.
626 strncpy(param
->name
, hc
->name
, sizeof(param
->name
));
628 strncpy(param
->uuid
, hc
->uuid
, sizeof(param
->uuid
)-1);
630 param
->uuid
[0] = '\0';
633 param
->flags
|= DM_INACTIVE_PRESENT_FLAG
;
635 param
->flags
&= ~DM_INACTIVE_PRESENT_FLAG
;
637 up_read(&_hash_lock
);
642 static int dev_remove(struct dm_ioctl
*param
, size_t param_size
)
644 struct hash_cell
*hc
;
646 down_write(&_hash_lock
);
647 hc
= __find_device_hash_cell(param
);
650 DMWARN("device doesn't appear to be in the dev hash table.");
651 up_write(&_hash_lock
);
656 up_write(&_hash_lock
);
657 param
->data_size
= 0;
662 * Check a string doesn't overrun the chunk of
663 * memory we copied from userland.
665 static int invalid_str(char *str
, void *end
)
667 while ((void *) str
< end
)
674 static int dev_rename(struct dm_ioctl
*param
, size_t param_size
)
677 char *new_name
= (char *) param
+ param
->data_start
;
679 if (new_name
< (char *) (param
+ 1) ||
680 invalid_str(new_name
, (void *) param
+ param_size
)) {
681 DMWARN("Invalid new logical volume name supplied.");
685 r
= check_name(new_name
);
689 param
->data_size
= 0;
690 return dm_hash_rename(param
->name
, new_name
);
693 static int do_suspend(struct dm_ioctl
*param
)
697 struct mapped_device
*md
;
699 md
= find_device(param
);
703 if (param
->flags
& DM_SKIP_LOCKFS_FLAG
)
706 if (!dm_suspended(md
))
707 r
= dm_suspend(md
, do_lockfs
);
710 r
= __dev_status(md
, param
);
716 static int do_resume(struct dm_ioctl
*param
)
720 struct hash_cell
*hc
;
721 struct mapped_device
*md
;
722 struct dm_table
*new_map
;
724 down_write(&_hash_lock
);
726 hc
= __find_device_hash_cell(param
);
728 DMWARN("device doesn't appear to be in the dev hash table.");
729 up_write(&_hash_lock
);
736 new_map
= hc
->new_map
;
738 param
->flags
&= ~DM_INACTIVE_PRESENT_FLAG
;
740 up_write(&_hash_lock
);
742 /* Do we need to load a new map ? */
744 /* Suspend if it isn't already suspended */
745 if (param
->flags
& DM_SKIP_LOCKFS_FLAG
)
747 if (!dm_suspended(md
))
748 dm_suspend(md
, do_lockfs
);
750 r
= dm_swap_table(md
, new_map
);
753 dm_table_put(new_map
);
757 if (dm_table_get_mode(new_map
) & FMODE_WRITE
)
758 set_disk_ro(dm_disk(md
), 0);
760 set_disk_ro(dm_disk(md
), 1);
762 dm_table_put(new_map
);
765 if (dm_suspended(md
))
769 r
= __dev_status(md
, param
);
776 * Set or unset the suspension state of a device.
777 * If the device already is in the requested state we just return its status.
779 static int dev_suspend(struct dm_ioctl
*param
, size_t param_size
)
781 if (param
->flags
& DM_SUSPEND_FLAG
)
782 return do_suspend(param
);
784 return do_resume(param
);
788 * Copies device info back to user space, used by
789 * the create and info ioctls.
791 static int dev_status(struct dm_ioctl
*param
, size_t param_size
)
794 struct mapped_device
*md
;
796 md
= find_device(param
);
800 r
= __dev_status(md
, param
);
806 * Build up the status struct for each target
808 static void retrieve_status(struct dm_table
*table
,
809 struct dm_ioctl
*param
, size_t param_size
)
811 unsigned int i
, num_targets
;
812 struct dm_target_spec
*spec
;
813 char *outbuf
, *outptr
;
815 size_t remaining
, len
, used
= 0;
817 outptr
= outbuf
= get_result_buffer(param
, param_size
, &len
);
819 if (param
->flags
& DM_STATUS_TABLE_FLAG
)
820 type
= STATUSTYPE_TABLE
;
822 type
= STATUSTYPE_INFO
;
824 /* Get all the target info */
825 num_targets
= dm_table_get_num_targets(table
);
826 for (i
= 0; i
< num_targets
; i
++) {
827 struct dm_target
*ti
= dm_table_get_target(table
, i
);
829 remaining
= len
- (outptr
- outbuf
);
830 if (remaining
<= sizeof(struct dm_target_spec
)) {
831 param
->flags
|= DM_BUFFER_FULL_FLAG
;
835 spec
= (struct dm_target_spec
*) outptr
;
838 spec
->sector_start
= ti
->begin
;
839 spec
->length
= ti
->len
;
840 strncpy(spec
->target_type
, ti
->type
->name
,
841 sizeof(spec
->target_type
));
843 outptr
+= sizeof(struct dm_target_spec
);
844 remaining
= len
- (outptr
- outbuf
);
845 if (remaining
<= 0) {
846 param
->flags
|= DM_BUFFER_FULL_FLAG
;
850 /* Get the status/table string from the target driver */
851 if (ti
->type
->status
) {
852 if (ti
->type
->status(ti
, type
, outptr
, remaining
)) {
853 param
->flags
|= DM_BUFFER_FULL_FLAG
;
859 outptr
+= strlen(outptr
) + 1;
860 used
= param
->data_start
+ (outptr
- outbuf
);
862 outptr
= align_ptr(outptr
);
863 spec
->next
= outptr
- outbuf
;
867 param
->data_size
= used
;
869 param
->target_count
= num_targets
;
873 * Wait for a device to report an event
875 static int dev_wait(struct dm_ioctl
*param
, size_t param_size
)
878 struct mapped_device
*md
;
879 struct dm_table
*table
;
881 md
= find_device(param
);
886 * Wait for a notification event
888 if (dm_wait_event(md
, param
->event_nr
)) {
894 * The userland program is going to want to know what
895 * changed to trigger the event, so we may as well tell
896 * him and save an ioctl.
898 r
= __dev_status(md
, param
);
902 table
= dm_get_table(md
);
904 retrieve_status(table
, param
, param_size
);
913 static inline int get_mode(struct dm_ioctl
*param
)
915 int mode
= FMODE_READ
| FMODE_WRITE
;
917 if (param
->flags
& DM_READONLY_FLAG
)
923 static int next_target(struct dm_target_spec
*last
, uint32_t next
, void *end
,
924 struct dm_target_spec
**spec
, char **target_params
)
926 *spec
= (struct dm_target_spec
*) ((unsigned char *) last
+ next
);
927 *target_params
= (char *) (*spec
+ 1);
929 if (*spec
< (last
+ 1))
932 return invalid_str(*target_params
, end
);
935 static int populate_table(struct dm_table
*table
,
936 struct dm_ioctl
*param
, size_t param_size
)
940 struct dm_target_spec
*spec
= (struct dm_target_spec
*) param
;
941 uint32_t next
= param
->data_start
;
942 void *end
= (void *) param
+ param_size
;
945 if (!param
->target_count
) {
946 DMWARN("populate_table: no targets specified");
950 for (i
= 0; i
< param
->target_count
; i
++) {
952 r
= next_target(spec
, next
, end
, &spec
, &target_params
);
954 DMWARN("unable to find target");
958 r
= dm_table_add_target(table
, spec
->target_type
,
959 (sector_t
) spec
->sector_start
,
960 (sector_t
) spec
->length
,
963 DMWARN("error adding target to table");
970 return dm_table_complete(table
);
973 static int table_load(struct dm_ioctl
*param
, size_t param_size
)
976 struct hash_cell
*hc
;
979 r
= dm_table_create(&t
, get_mode(param
), param
->target_count
);
983 r
= populate_table(t
, param
, param_size
);
989 down_write(&_hash_lock
);
990 hc
= __find_device_hash_cell(param
);
992 DMWARN("device doesn't appear to be in the dev hash table.");
993 up_write(&_hash_lock
);
999 dm_table_put(hc
->new_map
);
1001 param
->flags
|= DM_INACTIVE_PRESENT_FLAG
;
1003 r
= __dev_status(hc
->md
, param
);
1004 up_write(&_hash_lock
);
1008 static int table_clear(struct dm_ioctl
*param
, size_t param_size
)
1011 struct hash_cell
*hc
;
1013 down_write(&_hash_lock
);
1015 hc
= __find_device_hash_cell(param
);
1017 DMWARN("device doesn't appear to be in the dev hash table.");
1018 up_write(&_hash_lock
);
1023 dm_table_put(hc
->new_map
);
1027 param
->flags
&= ~DM_INACTIVE_PRESENT_FLAG
;
1029 r
= __dev_status(hc
->md
, param
);
1030 up_write(&_hash_lock
);
1035 * Retrieves a list of devices used by a particular dm device.
1037 static void retrieve_deps(struct dm_table
*table
,
1038 struct dm_ioctl
*param
, size_t param_size
)
1040 unsigned int count
= 0;
1041 struct list_head
*tmp
;
1044 struct dm_target_deps
*deps
;
1046 deps
= get_result_buffer(param
, param_size
, &len
);
1049 * Count the devices.
1051 list_for_each (tmp
, dm_table_get_devices(table
))
1055 * Check we have enough space.
1057 needed
= sizeof(*deps
) + (sizeof(*deps
->dev
) * count
);
1059 param
->flags
|= DM_BUFFER_FULL_FLAG
;
1064 * Fill in the devices.
1066 deps
->count
= count
;
1068 list_for_each_entry (dd
, dm_table_get_devices(table
), list
)
1069 deps
->dev
[count
++] = huge_encode_dev(dd
->bdev
->bd_dev
);
1071 param
->data_size
= param
->data_start
+ needed
;
1074 static int table_deps(struct dm_ioctl
*param
, size_t param_size
)
1077 struct mapped_device
*md
;
1078 struct dm_table
*table
;
1080 md
= find_device(param
);
1084 r
= __dev_status(md
, param
);
1088 table
= dm_get_table(md
);
1090 retrieve_deps(table
, param
, param_size
);
1091 dm_table_put(table
);
1100 * Return the status of a device as a text string for each
1103 static int table_status(struct dm_ioctl
*param
, size_t param_size
)
1106 struct mapped_device
*md
;
1107 struct dm_table
*table
;
1109 md
= find_device(param
);
1113 r
= __dev_status(md
, param
);
1117 table
= dm_get_table(md
);
1119 retrieve_status(table
, param
, param_size
);
1120 dm_table_put(table
);
1129 * Pass a message to the target that's at the supplied device offset.
1131 static int target_message(struct dm_ioctl
*param
, size_t param_size
)
1135 struct mapped_device
*md
;
1136 struct dm_table
*table
;
1137 struct dm_target
*ti
;
1138 struct dm_target_msg
*tmsg
= (void *) param
+ param
->data_start
;
1140 md
= find_device(param
);
1144 r
= __dev_status(md
, param
);
1148 if (tmsg
< (struct dm_target_msg
*) (param
+ 1) ||
1149 invalid_str(tmsg
->message
, (void *) param
+ param_size
)) {
1150 DMWARN("Invalid target message parameters.");
1155 r
= dm_split_args(&argc
, &argv
, tmsg
->message
);
1157 DMWARN("Failed to split target message parameters");
1161 table
= dm_get_table(md
);
1165 if (tmsg
->sector
>= dm_table_get_size(table
)) {
1166 DMWARN("Target message sector outside device.");
1171 ti
= dm_table_find_target(table
, tmsg
->sector
);
1172 if (ti
->type
->message
)
1173 r
= ti
->type
->message(ti
, argc
, argv
);
1175 DMWARN("Target type does not support messages");
1180 dm_table_put(table
);
1184 param
->data_size
= 0;
1189 /*-----------------------------------------------------------------
1190 * Implementation of open/close/ioctl on the special char
1192 *---------------------------------------------------------------*/
1193 static ioctl_fn
lookup_ioctl(unsigned int cmd
)
1199 {DM_VERSION_CMD
, NULL
}, /* version is dealt with elsewhere */
1200 {DM_REMOVE_ALL_CMD
, remove_all
},
1201 {DM_LIST_DEVICES_CMD
, list_devices
},
1203 {DM_DEV_CREATE_CMD
, dev_create
},
1204 {DM_DEV_REMOVE_CMD
, dev_remove
},
1205 {DM_DEV_RENAME_CMD
, dev_rename
},
1206 {DM_DEV_SUSPEND_CMD
, dev_suspend
},
1207 {DM_DEV_STATUS_CMD
, dev_status
},
1208 {DM_DEV_WAIT_CMD
, dev_wait
},
1210 {DM_TABLE_LOAD_CMD
, table_load
},
1211 {DM_TABLE_CLEAR_CMD
, table_clear
},
1212 {DM_TABLE_DEPS_CMD
, table_deps
},
1213 {DM_TABLE_STATUS_CMD
, table_status
},
1215 {DM_LIST_VERSIONS_CMD
, list_versions
},
1217 {DM_TARGET_MSG_CMD
, target_message
}
1220 return (cmd
>= ARRAY_SIZE(_ioctls
)) ? NULL
: _ioctls
[cmd
].fn
;
1224 * As well as checking the version compatibility this always
1225 * copies the kernel interface version out.
1227 static int check_version(unsigned int cmd
, struct dm_ioctl __user
*user
)
1229 uint32_t version
[3];
1232 if (copy_from_user(version
, user
->version
, sizeof(version
)))
1235 if ((DM_VERSION_MAJOR
!= version
[0]) ||
1236 (DM_VERSION_MINOR
< version
[1])) {
1237 DMWARN("ioctl interface mismatch: "
1238 "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)",
1239 DM_VERSION_MAJOR
, DM_VERSION_MINOR
,
1240 DM_VERSION_PATCHLEVEL
,
1241 version
[0], version
[1], version
[2], cmd
);
1246 * Fill in the kernel version.
1248 version
[0] = DM_VERSION_MAJOR
;
1249 version
[1] = DM_VERSION_MINOR
;
1250 version
[2] = DM_VERSION_PATCHLEVEL
;
1251 if (copy_to_user(user
->version
, version
, sizeof(version
)))
1257 static void free_params(struct dm_ioctl
*param
)
1262 static int copy_params(struct dm_ioctl __user
*user
, struct dm_ioctl
**param
)
1264 struct dm_ioctl tmp
, *dmi
;
1266 if (copy_from_user(&tmp
, user
, sizeof(tmp
)))
1269 if (tmp
.data_size
< sizeof(tmp
))
1272 dmi
= (struct dm_ioctl
*) vmalloc(tmp
.data_size
);
1276 if (copy_from_user(dmi
, user
, tmp
.data_size
)) {
1285 static int validate_params(uint cmd
, struct dm_ioctl
*param
)
1287 /* Always clear this flag */
1288 param
->flags
&= ~DM_BUFFER_FULL_FLAG
;
1290 /* Ignores parameters */
1291 if (cmd
== DM_REMOVE_ALL_CMD
||
1292 cmd
== DM_LIST_DEVICES_CMD
||
1293 cmd
== DM_LIST_VERSIONS_CMD
)
1296 if ((cmd
== DM_DEV_CREATE_CMD
)) {
1297 if (!*param
->name
) {
1298 DMWARN("name not supplied when creating device");
1301 } else if ((*param
->uuid
&& *param
->name
)) {
1302 DMWARN("only supply one of name or uuid, cmd(%u)", cmd
);
1306 /* Ensure strings are terminated */
1307 param
->name
[DM_NAME_LEN
- 1] = '\0';
1308 param
->uuid
[DM_UUID_LEN
- 1] = '\0';
1313 static int ctl_ioctl(struct inode
*inode
, struct file
*file
,
1314 uint command
, ulong u
)
1318 struct dm_ioctl
*param
;
1319 struct dm_ioctl __user
*user
= (struct dm_ioctl __user
*) u
;
1323 /* only root can play with this */
1324 if (!capable(CAP_SYS_ADMIN
))
1327 if (_IOC_TYPE(command
) != DM_IOCTL
)
1330 cmd
= _IOC_NR(command
);
1333 * Check the interface version passed in. This also
1334 * writes out the kernel's interface version.
1336 r
= check_version(cmd
, user
);
1341 * Nothing more to do for the version command.
1343 if (cmd
== DM_VERSION_CMD
)
1346 fn
= lookup_ioctl(cmd
);
1348 DMWARN("dm_ctl_ioctl: unknown command 0x%x", command
);
1353 * Trying to avoid low memory issues when a device is
1356 current
->flags
|= PF_MEMALLOC
;
1359 * Copy the parameters into kernel space.
1361 r
= copy_params(user
, ¶m
);
1363 current
->flags
&= ~PF_MEMALLOC
;
1368 * FIXME: eventually we will remove the PF_MEMALLOC flag
1369 * here. However the tools still do nasty things like
1370 * 'load' while a device is suspended.
1373 r
= validate_params(cmd
, param
);
1377 param_size
= param
->data_size
;
1378 param
->data_size
= sizeof(*param
);
1379 r
= fn(param
, param_size
);
1382 * Copy the results back to userland.
1384 if (!r
&& copy_to_user(user
, param
, param
->data_size
))
1389 current
->flags
&= ~PF_MEMALLOC
;
1393 static struct file_operations _ctl_fops
= {
1395 .owner
= THIS_MODULE
,
1398 static struct miscdevice _dm_misc
= {
1399 .minor
= MISC_DYNAMIC_MINOR
,
1401 .devfs_name
= "mapper/control",
1406 * Create misc character device and link to DM_DIR/control.
1408 int __init
dm_interface_init(void)
1416 r
= misc_register(&_dm_misc
);
1418 DMERR("misc_register failed for control device");
1423 DMINFO("%d.%d.%d%s initialised: %s", DM_VERSION_MAJOR
,
1424 DM_VERSION_MINOR
, DM_VERSION_PATCHLEVEL
, DM_VERSION_EXTRA
,
1429 void dm_interface_exit(void)
1431 if (misc_deregister(&_dm_misc
) < 0)
1432 DMERR("misc_deregister failed for control device");