Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
0003  * Copyright (C) 2004 - 2006 Red Hat, Inc. All rights reserved.
0004  *
0005  * This file is released under the GPL.
0006  */
0007 
0008 #include "dm-core.h"
0009 #include "dm-ima.h"
0010 #include <linux/module.h>
0011 #include <linux/vmalloc.h>
0012 #include <linux/miscdevice.h>
0013 #include <linux/sched/mm.h>
0014 #include <linux/init.h>
0015 #include <linux/wait.h>
0016 #include <linux/slab.h>
0017 #include <linux/rbtree.h>
0018 #include <linux/dm-ioctl.h>
0019 #include <linux/hdreg.h>
0020 #include <linux/compat.h>
0021 #include <linux/nospec.h>
0022 
0023 #include <linux/uaccess.h>
0024 #include <linux/ima.h>
0025 
0026 #define DM_MSG_PREFIX "ioctl"
0027 #define DM_DRIVER_EMAIL "dm-devel@redhat.com"
0028 
0029 struct dm_file {
0030     /*
0031      * poll will wait until the global event number is greater than
0032      * this value.
0033      */
0034     volatile unsigned global_event_nr;
0035 };
0036 
0037 /*-----------------------------------------------------------------
0038  * The ioctl interface needs to be able to look up devices by
0039  * name or uuid.
0040  *---------------------------------------------------------------*/
0041 struct hash_cell {
0042     struct rb_node name_node;
0043     struct rb_node uuid_node;
0044     bool name_set;
0045     bool uuid_set;
0046 
0047     char *name;
0048     char *uuid;
0049     struct mapped_device *md;
0050     struct dm_table *new_map;
0051 };
0052 
0053 struct vers_iter {
0054     size_t param_size;
0055     struct dm_target_versions *vers, *old_vers;
0056     char *end;
0057     uint32_t flags;
0058 };
0059 
0060 
0061 static struct rb_root name_rb_tree = RB_ROOT;
0062 static struct rb_root uuid_rb_tree = RB_ROOT;
0063 
0064 static void dm_hash_remove_all(bool keep_open_devices, bool mark_deferred, bool only_deferred);
0065 
0066 /*
0067  * Guards access to both hash tables.
0068  */
0069 static DECLARE_RWSEM(_hash_lock);
0070 
0071 /*
0072  * Protects use of mdptr to obtain hash cell name and uuid from mapped device.
0073  */
0074 static DEFINE_MUTEX(dm_hash_cells_mutex);
0075 
0076 static void dm_hash_exit(void)
0077 {
0078     dm_hash_remove_all(false, false, false);
0079 }
0080 
0081 /*-----------------------------------------------------------------
0082  * Code for looking up a device by name
0083  *---------------------------------------------------------------*/
0084 static struct hash_cell *__get_name_cell(const char *str)
0085 {
0086     struct rb_node *n = name_rb_tree.rb_node;
0087 
0088     while (n) {
0089         struct hash_cell *hc = container_of(n, struct hash_cell, name_node);
0090         int c = strcmp(hc->name, str);
0091         if (!c) {
0092             dm_get(hc->md);
0093             return hc;
0094         }
0095         n = c >= 0 ? n->rb_left : n->rb_right;
0096     }
0097 
0098     return NULL;
0099 }
0100 
0101 static struct hash_cell *__get_uuid_cell(const char *str)
0102 {
0103     struct rb_node *n = uuid_rb_tree.rb_node;
0104 
0105     while (n) {
0106         struct hash_cell *hc = container_of(n, struct hash_cell, uuid_node);
0107         int c = strcmp(hc->uuid, str);
0108         if (!c) {
0109             dm_get(hc->md);
0110             return hc;
0111         }
0112         n = c >= 0 ? n->rb_left : n->rb_right;
0113     }
0114 
0115     return NULL;
0116 }
0117 
0118 static void __unlink_name(struct hash_cell *hc)
0119 {
0120     if (hc->name_set) {
0121         hc->name_set = false;
0122         rb_erase(&hc->name_node, &name_rb_tree);
0123     }
0124 }
0125 
0126 static void __unlink_uuid(struct hash_cell *hc)
0127 {
0128     if (hc->uuid_set) {
0129         hc->uuid_set = false;
0130         rb_erase(&hc->uuid_node, &uuid_rb_tree);
0131     }
0132 }
0133 
0134 static void __link_name(struct hash_cell *new_hc)
0135 {
0136     struct rb_node **n, *parent;
0137 
0138     __unlink_name(new_hc);
0139 
0140     new_hc->name_set = true;
0141 
0142     n = &name_rb_tree.rb_node;
0143     parent = NULL;
0144 
0145     while (*n) {
0146         struct hash_cell *hc = container_of(*n, struct hash_cell, name_node);
0147         int c = strcmp(hc->name, new_hc->name);
0148         BUG_ON(!c);
0149         parent = *n;
0150         n = c >= 0 ? &hc->name_node.rb_left : &hc->name_node.rb_right;
0151     }
0152 
0153     rb_link_node(&new_hc->name_node, parent, n);
0154     rb_insert_color(&new_hc->name_node, &name_rb_tree);
0155 }
0156 
0157 static void __link_uuid(struct hash_cell *new_hc)
0158 {
0159     struct rb_node **n, *parent;
0160 
0161     __unlink_uuid(new_hc);
0162 
0163     new_hc->uuid_set = true;
0164 
0165     n = &uuid_rb_tree.rb_node;
0166     parent = NULL;
0167 
0168     while (*n) {
0169         struct hash_cell *hc = container_of(*n, struct hash_cell, uuid_node);
0170         int c = strcmp(hc->uuid, new_hc->uuid);
0171         BUG_ON(!c);
0172         parent = *n;
0173         n = c > 0 ? &hc->uuid_node.rb_left : &hc->uuid_node.rb_right;
0174     }
0175 
0176     rb_link_node(&new_hc->uuid_node, parent, n);
0177     rb_insert_color(&new_hc->uuid_node, &uuid_rb_tree);
0178 }
0179 
0180 static struct hash_cell *__get_dev_cell(uint64_t dev)
0181 {
0182     struct mapped_device *md;
0183     struct hash_cell *hc;
0184 
0185     md = dm_get_md(huge_decode_dev(dev));
0186     if (!md)
0187         return NULL;
0188 
0189     hc = dm_get_mdptr(md);
0190     if (!hc) {
0191         dm_put(md);
0192         return NULL;
0193     }
0194 
0195     return hc;
0196 }
0197 
0198 /*-----------------------------------------------------------------
0199  * Inserting, removing and renaming a device.
0200  *---------------------------------------------------------------*/
0201 static struct hash_cell *alloc_cell(const char *name, const char *uuid,
0202                     struct mapped_device *md)
0203 {
0204     struct hash_cell *hc;
0205 
0206     hc = kmalloc(sizeof(*hc), GFP_KERNEL);
0207     if (!hc)
0208         return NULL;
0209 
0210     hc->name = kstrdup(name, GFP_KERNEL);
0211     if (!hc->name) {
0212         kfree(hc);
0213         return NULL;
0214     }
0215 
0216     if (!uuid)
0217         hc->uuid = NULL;
0218 
0219     else {
0220         hc->uuid = kstrdup(uuid, GFP_KERNEL);
0221         if (!hc->uuid) {
0222             kfree(hc->name);
0223             kfree(hc);
0224             return NULL;
0225         }
0226     }
0227 
0228     hc->name_set = hc->uuid_set = false;
0229     hc->md = md;
0230     hc->new_map = NULL;
0231     return hc;
0232 }
0233 
0234 static void free_cell(struct hash_cell *hc)
0235 {
0236     if (hc) {
0237         kfree(hc->name);
0238         kfree(hc->uuid);
0239         kfree(hc);
0240     }
0241 }
0242 
0243 /*
0244  * The kdev_t and uuid of a device can never change once it is
0245  * initially inserted.
0246  */
0247 static int dm_hash_insert(const char *name, const char *uuid, struct mapped_device *md)
0248 {
0249     struct hash_cell *cell, *hc;
0250 
0251     /*
0252      * Allocate the new cells.
0253      */
0254     cell = alloc_cell(name, uuid, md);
0255     if (!cell)
0256         return -ENOMEM;
0257 
0258     /*
0259      * Insert the cell into both hash tables.
0260      */
0261     down_write(&_hash_lock);
0262     hc = __get_name_cell(name);
0263     if (hc) {
0264         dm_put(hc->md);
0265         goto bad;
0266     }
0267 
0268     __link_name(cell);
0269 
0270     if (uuid) {
0271         hc = __get_uuid_cell(uuid);
0272         if (hc) {
0273             __unlink_name(cell);
0274             dm_put(hc->md);
0275             goto bad;
0276         }
0277         __link_uuid(cell);
0278     }
0279     dm_get(md);
0280     mutex_lock(&dm_hash_cells_mutex);
0281     dm_set_mdptr(md, cell);
0282     mutex_unlock(&dm_hash_cells_mutex);
0283     up_write(&_hash_lock);
0284 
0285     return 0;
0286 
0287  bad:
0288     up_write(&_hash_lock);
0289     free_cell(cell);
0290     return -EBUSY;
0291 }
0292 
0293 static struct dm_table *__hash_remove(struct hash_cell *hc)
0294 {
0295     struct dm_table *table;
0296     int srcu_idx;
0297 
0298     /* remove from the dev trees */
0299     __unlink_name(hc);
0300     __unlink_uuid(hc);
0301     mutex_lock(&dm_hash_cells_mutex);
0302     dm_set_mdptr(hc->md, NULL);
0303     mutex_unlock(&dm_hash_cells_mutex);
0304 
0305     table = dm_get_live_table(hc->md, &srcu_idx);
0306     if (table)
0307         dm_table_event(table);
0308     dm_put_live_table(hc->md, srcu_idx);
0309 
0310     table = NULL;
0311     if (hc->new_map)
0312         table = hc->new_map;
0313     dm_put(hc->md);
0314     free_cell(hc);
0315 
0316     return table;
0317 }
0318 
0319 static void dm_hash_remove_all(bool keep_open_devices, bool mark_deferred, bool only_deferred)
0320 {
0321     int dev_skipped;
0322     struct rb_node *n;
0323     struct hash_cell *hc;
0324     struct mapped_device *md;
0325     struct dm_table *t;
0326 
0327 retry:
0328     dev_skipped = 0;
0329 
0330     down_write(&_hash_lock);
0331 
0332     for (n = rb_first(&name_rb_tree); n; n = rb_next(n)) {
0333         hc = container_of(n, struct hash_cell, name_node);
0334         md = hc->md;
0335         dm_get(md);
0336 
0337         if (keep_open_devices &&
0338             dm_lock_for_deletion(md, mark_deferred, only_deferred)) {
0339             dm_put(md);
0340             dev_skipped++;
0341             continue;
0342         }
0343 
0344         t = __hash_remove(hc);
0345 
0346         up_write(&_hash_lock);
0347 
0348         if (t) {
0349             dm_sync_table(md);
0350             dm_table_destroy(t);
0351         }
0352         dm_ima_measure_on_device_remove(md, true);
0353         dm_put(md);
0354         if (likely(keep_open_devices))
0355             dm_destroy(md);
0356         else
0357             dm_destroy_immediate(md);
0358 
0359         /*
0360          * Some mapped devices may be using other mapped
0361          * devices, so repeat until we make no further
0362          * progress.  If a new mapped device is created
0363          * here it will also get removed.
0364          */
0365         goto retry;
0366     }
0367 
0368     up_write(&_hash_lock);
0369 
0370     if (dev_skipped)
0371         DMWARN("remove_all left %d open device(s)", dev_skipped);
0372 }
0373 
0374 /*
0375  * Set the uuid of a hash_cell that isn't already set.
0376  */
0377 static void __set_cell_uuid(struct hash_cell *hc, char *new_uuid)
0378 {
0379     mutex_lock(&dm_hash_cells_mutex);
0380     hc->uuid = new_uuid;
0381     mutex_unlock(&dm_hash_cells_mutex);
0382 
0383     __link_uuid(hc);
0384 }
0385 
0386 /*
0387  * Changes the name of a hash_cell and returns the old name for
0388  * the caller to free.
0389  */
0390 static char *__change_cell_name(struct hash_cell *hc, char *new_name)
0391 {
0392     char *old_name;
0393 
0394     /*
0395      * Rename and move the name cell.
0396      */
0397     __unlink_name(hc);
0398     old_name = hc->name;
0399 
0400     mutex_lock(&dm_hash_cells_mutex);
0401     hc->name = new_name;
0402     mutex_unlock(&dm_hash_cells_mutex);
0403 
0404     __link_name(hc);
0405 
0406     return old_name;
0407 }
0408 
0409 static struct mapped_device *dm_hash_rename(struct dm_ioctl *param,
0410                         const char *new)
0411 {
0412     char *new_data, *old_name = NULL;
0413     struct hash_cell *hc;
0414     struct dm_table *table;
0415     struct mapped_device *md;
0416     unsigned change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0;
0417     int srcu_idx;
0418 
0419     /*
0420      * duplicate new.
0421      */
0422     new_data = kstrdup(new, GFP_KERNEL);
0423     if (!new_data)
0424         return ERR_PTR(-ENOMEM);
0425 
0426     down_write(&_hash_lock);
0427 
0428     /*
0429      * Is new free ?
0430      */
0431     if (change_uuid)
0432         hc = __get_uuid_cell(new);
0433     else
0434         hc = __get_name_cell(new);
0435 
0436     if (hc) {
0437         DMWARN("Unable to change %s on mapped device %s to one that "
0438                "already exists: %s",
0439                change_uuid ? "uuid" : "name",
0440                param->name, new);
0441         dm_put(hc->md);
0442         up_write(&_hash_lock);
0443         kfree(new_data);
0444         return ERR_PTR(-EBUSY);
0445     }
0446 
0447     /*
0448      * Is there such a device as 'old' ?
0449      */
0450     hc = __get_name_cell(param->name);
0451     if (!hc) {
0452         DMWARN("Unable to rename non-existent device, %s to %s%s",
0453                param->name, change_uuid ? "uuid " : "", new);
0454         up_write(&_hash_lock);
0455         kfree(new_data);
0456         return ERR_PTR(-ENXIO);
0457     }
0458 
0459     /*
0460      * Does this device already have a uuid?
0461      */
0462     if (change_uuid && hc->uuid) {
0463         DMWARN("Unable to change uuid of mapped device %s to %s "
0464                "because uuid is already set to %s",
0465                param->name, new, hc->uuid);
0466         dm_put(hc->md);
0467         up_write(&_hash_lock);
0468         kfree(new_data);
0469         return ERR_PTR(-EINVAL);
0470     }
0471 
0472     if (change_uuid)
0473         __set_cell_uuid(hc, new_data);
0474     else
0475         old_name = __change_cell_name(hc, new_data);
0476 
0477     /*
0478      * Wake up any dm event waiters.
0479      */
0480     table = dm_get_live_table(hc->md, &srcu_idx);
0481     if (table)
0482         dm_table_event(table);
0483     dm_put_live_table(hc->md, srcu_idx);
0484 
0485     if (!dm_kobject_uevent(hc->md, KOBJ_CHANGE, param->event_nr))
0486         param->flags |= DM_UEVENT_GENERATED_FLAG;
0487 
0488     md = hc->md;
0489 
0490     dm_ima_measure_on_device_rename(md);
0491 
0492     up_write(&_hash_lock);
0493     kfree(old_name);
0494 
0495     return md;
0496 }
0497 
0498 void dm_deferred_remove(void)
0499 {
0500     dm_hash_remove_all(true, false, true);
0501 }
0502 
0503 /*-----------------------------------------------------------------
0504  * Implementation of the ioctl commands
0505  *---------------------------------------------------------------*/
0506 /*
0507  * All the ioctl commands get dispatched to functions with this
0508  * prototype.
0509  */
0510 typedef int (*ioctl_fn)(struct file *filp, struct dm_ioctl *param, size_t param_size);
0511 
0512 static int remove_all(struct file *filp, struct dm_ioctl *param, size_t param_size)
0513 {
0514     dm_hash_remove_all(true, !!(param->flags & DM_DEFERRED_REMOVE), false);
0515     param->data_size = 0;
0516     return 0;
0517 }
0518 
0519 /*
0520  * Round up the ptr to an 8-byte boundary.
0521  */
0522 #define ALIGN_MASK 7
0523 static inline size_t align_val(size_t val)
0524 {
0525     return (val + ALIGN_MASK) & ~ALIGN_MASK;
0526 }
0527 static inline void *align_ptr(void *ptr)
0528 {
0529     return (void *)align_val((size_t)ptr);
0530 }
0531 
0532 /*
0533  * Retrieves the data payload buffer from an already allocated
0534  * struct dm_ioctl.
0535  */
0536 static void *get_result_buffer(struct dm_ioctl *param, size_t param_size,
0537                    size_t *len)
0538 {
0539     param->data_start = align_ptr(param + 1) - (void *) param;
0540 
0541     if (param->data_start < param_size)
0542         *len = param_size - param->data_start;
0543     else
0544         *len = 0;
0545 
0546     return ((void *) param) + param->data_start;
0547 }
0548 
0549 static bool filter_device(struct hash_cell *hc, const char *pfx_name, const char *pfx_uuid)
0550 {
0551     const char *val;
0552     size_t val_len, pfx_len;
0553 
0554     val = hc->name;
0555     val_len = strlen(val);
0556     pfx_len = strnlen(pfx_name, DM_NAME_LEN);
0557     if (pfx_len > val_len)
0558         return false;
0559     if (memcmp(val, pfx_name, pfx_len))
0560         return false;
0561 
0562     val = hc->uuid ? hc->uuid : "";
0563     val_len = strlen(val);
0564     pfx_len = strnlen(pfx_uuid, DM_UUID_LEN);
0565     if (pfx_len > val_len)
0566         return false;
0567     if (memcmp(val, pfx_uuid, pfx_len))
0568         return false;
0569 
0570     return true;
0571 }
0572 
0573 static int list_devices(struct file *filp, struct dm_ioctl *param, size_t param_size)
0574 {
0575     struct rb_node *n;
0576     struct hash_cell *hc;
0577     size_t len, needed = 0;
0578     struct gendisk *disk;
0579     struct dm_name_list *orig_nl, *nl, *old_nl = NULL;
0580     uint32_t *event_nr;
0581 
0582     down_write(&_hash_lock);
0583 
0584     /*
0585      * Loop through all the devices working out how much
0586      * space we need.
0587      */
0588     for (n = rb_first(&name_rb_tree); n; n = rb_next(n)) {
0589         hc = container_of(n, struct hash_cell, name_node);
0590         if (!filter_device(hc, param->name, param->uuid))
0591             continue;
0592         needed += align_val(offsetof(struct dm_name_list, name) + strlen(hc->name) + 1);
0593         needed += align_val(sizeof(uint32_t) * 2);
0594         if (param->flags & DM_UUID_FLAG && hc->uuid)
0595             needed += align_val(strlen(hc->uuid) + 1);
0596     }
0597 
0598     /*
0599      * Grab our output buffer.
0600      */
0601     nl = orig_nl = get_result_buffer(param, param_size, &len);
0602     if (len < needed || len < sizeof(nl->dev)) {
0603         param->flags |= DM_BUFFER_FULL_FLAG;
0604         goto out;
0605     }
0606     param->data_size = param->data_start + needed;
0607 
0608     nl->dev = 0;    /* Flags no data */
0609 
0610     /*
0611      * Now loop through filling out the names.
0612      */
0613     for (n = rb_first(&name_rb_tree); n; n = rb_next(n)) {
0614         void *uuid_ptr;
0615         hc = container_of(n, struct hash_cell, name_node);
0616         if (!filter_device(hc, param->name, param->uuid))
0617             continue;
0618         if (old_nl)
0619             old_nl->next = (uint32_t) ((void *) nl -
0620                            (void *) old_nl);
0621         disk = dm_disk(hc->md);
0622         nl->dev = huge_encode_dev(disk_devt(disk));
0623         nl->next = 0;
0624         strcpy(nl->name, hc->name);
0625 
0626         old_nl = nl;
0627         event_nr = align_ptr(nl->name + strlen(hc->name) + 1);
0628         event_nr[0] = dm_get_event_nr(hc->md);
0629         event_nr[1] = 0;
0630         uuid_ptr = align_ptr(event_nr + 2);
0631         if (param->flags & DM_UUID_FLAG) {
0632             if (hc->uuid) {
0633                 event_nr[1] |= DM_NAME_LIST_FLAG_HAS_UUID;
0634                 strcpy(uuid_ptr, hc->uuid);
0635                 uuid_ptr = align_ptr(uuid_ptr + strlen(hc->uuid) + 1);
0636             } else {
0637                 event_nr[1] |= DM_NAME_LIST_FLAG_DOESNT_HAVE_UUID;
0638             }
0639         }
0640         nl = uuid_ptr;
0641     }
0642     /*
0643      * If mismatch happens, security may be compromised due to buffer
0644      * overflow, so it's better to crash.
0645      */
0646     BUG_ON((char *)nl - (char *)orig_nl != needed);
0647 
0648  out:
0649     up_write(&_hash_lock);
0650     return 0;
0651 }
0652 
0653 static void list_version_get_needed(struct target_type *tt, void *needed_param)
0654 {
0655     size_t *needed = needed_param;
0656 
0657     *needed += sizeof(struct dm_target_versions);
0658     *needed += strlen(tt->name);
0659     *needed += ALIGN_MASK;
0660 }
0661 
0662 static void list_version_get_info(struct target_type *tt, void *param)
0663 {
0664     struct vers_iter *info = param;
0665 
0666     /* Check space - it might have changed since the first iteration */
0667     if ((char *)info->vers + sizeof(tt->version) + strlen(tt->name) + 1 >
0668     info->end) {
0669 
0670     info->flags = DM_BUFFER_FULL_FLAG;
0671     return;
0672     }
0673 
0674     if (info->old_vers)
0675     info->old_vers->next = (uint32_t) ((void *)info->vers -
0676                        (void *)info->old_vers);
0677     info->vers->version[0] = tt->version[0];
0678     info->vers->version[1] = tt->version[1];
0679     info->vers->version[2] = tt->version[2];
0680     info->vers->next = 0;
0681     strcpy(info->vers->name, tt->name);
0682 
0683     info->old_vers = info->vers;
0684     info->vers = align_ptr(((void *) ++info->vers) + strlen(tt->name) + 1);
0685 }
0686 
0687 static int __list_versions(struct dm_ioctl *param, size_t param_size, const char *name)
0688 {
0689     size_t len, needed = 0;
0690     struct dm_target_versions *vers;
0691     struct vers_iter iter_info;
0692     struct target_type *tt = NULL;
0693 
0694     if (name) {
0695         tt = dm_get_target_type(name);
0696         if (!tt)
0697             return -EINVAL;
0698     }
0699 
0700     /*
0701      * Loop through all the devices working out how much
0702      * space we need.
0703      */
0704     if (!tt)
0705         dm_target_iterate(list_version_get_needed, &needed);
0706     else
0707         list_version_get_needed(tt, &needed);
0708 
0709     /*
0710      * Grab our output buffer.
0711      */
0712     vers = get_result_buffer(param, param_size, &len);
0713     if (len < needed) {
0714         param->flags |= DM_BUFFER_FULL_FLAG;
0715         goto out;
0716     }
0717     param->data_size = param->data_start + needed;
0718 
0719     iter_info.param_size = param_size;
0720     iter_info.old_vers = NULL;
0721     iter_info.vers = vers;
0722     iter_info.flags = 0;
0723     iter_info.end = (char *)vers+len;
0724 
0725     /*
0726      * Now loop through filling out the names & versions.
0727      */
0728     if (!tt)
0729         dm_target_iterate(list_version_get_info, &iter_info);
0730     else
0731         list_version_get_info(tt, &iter_info);
0732     param->flags |= iter_info.flags;
0733 
0734  out:
0735     if (tt)
0736         dm_put_target_type(tt);
0737     return 0;
0738 }
0739 
0740 static int list_versions(struct file *filp, struct dm_ioctl *param, size_t param_size)
0741 {
0742     return __list_versions(param, param_size, NULL);
0743 }
0744 
0745 static int get_target_version(struct file *filp, struct dm_ioctl *param, size_t param_size)
0746 {
0747     return __list_versions(param, param_size, param->name);
0748 }
0749 
0750 static int check_name(const char *name)
0751 {
0752     if (strchr(name, '/')) {
0753         DMWARN("invalid device name");
0754         return -EINVAL;
0755     }
0756 
0757     return 0;
0758 }
0759 
0760 /*
0761  * On successful return, the caller must not attempt to acquire
0762  * _hash_lock without first calling dm_put_live_table, because dm_table_destroy
0763  * waits for this dm_put_live_table and could be called under this lock.
0764  */
0765 static struct dm_table *dm_get_inactive_table(struct mapped_device *md, int *srcu_idx)
0766 {
0767     struct hash_cell *hc;
0768     struct dm_table *table = NULL;
0769 
0770     /* increment rcu count, we don't care about the table pointer */
0771     dm_get_live_table(md, srcu_idx);
0772 
0773     down_read(&_hash_lock);
0774     hc = dm_get_mdptr(md);
0775     if (!hc || hc->md != md) {
0776         DMWARN("device has been removed from the dev hash table.");
0777         goto out;
0778     }
0779 
0780     table = hc->new_map;
0781 
0782 out:
0783     up_read(&_hash_lock);
0784 
0785     return table;
0786 }
0787 
0788 static struct dm_table *dm_get_live_or_inactive_table(struct mapped_device *md,
0789                               struct dm_ioctl *param,
0790                               int *srcu_idx)
0791 {
0792     return (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) ?
0793         dm_get_inactive_table(md, srcu_idx) : dm_get_live_table(md, srcu_idx);
0794 }
0795 
0796 /*
0797  * Fills in a dm_ioctl structure, ready for sending back to
0798  * userland.
0799  */
0800 static void __dev_status(struct mapped_device *md, struct dm_ioctl *param)
0801 {
0802     struct gendisk *disk = dm_disk(md);
0803     struct dm_table *table;
0804     int srcu_idx;
0805 
0806     param->flags &= ~(DM_SUSPEND_FLAG | DM_READONLY_FLAG |
0807               DM_ACTIVE_PRESENT_FLAG | DM_INTERNAL_SUSPEND_FLAG);
0808 
0809     if (dm_suspended_md(md))
0810         param->flags |= DM_SUSPEND_FLAG;
0811 
0812     if (dm_suspended_internally_md(md))
0813         param->flags |= DM_INTERNAL_SUSPEND_FLAG;
0814 
0815     if (dm_test_deferred_remove_flag(md))
0816         param->flags |= DM_DEFERRED_REMOVE;
0817 
0818     param->dev = huge_encode_dev(disk_devt(disk));
0819 
0820     /*
0821      * Yes, this will be out of date by the time it gets back
0822      * to userland, but it is still very useful for
0823      * debugging.
0824      */
0825     param->open_count = dm_open_count(md);
0826 
0827     param->event_nr = dm_get_event_nr(md);
0828     param->target_count = 0;
0829 
0830     table = dm_get_live_table(md, &srcu_idx);
0831     if (table) {
0832         if (!(param->flags & DM_QUERY_INACTIVE_TABLE_FLAG)) {
0833             if (get_disk_ro(disk))
0834                 param->flags |= DM_READONLY_FLAG;
0835             param->target_count = table->num_targets;
0836         }
0837 
0838         param->flags |= DM_ACTIVE_PRESENT_FLAG;
0839     }
0840     dm_put_live_table(md, srcu_idx);
0841 
0842     if (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) {
0843         int srcu_idx;
0844         table = dm_get_inactive_table(md, &srcu_idx);
0845         if (table) {
0846             if (!(dm_table_get_mode(table) & FMODE_WRITE))
0847                 param->flags |= DM_READONLY_FLAG;
0848             param->target_count = table->num_targets;
0849         }
0850         dm_put_live_table(md, srcu_idx);
0851     }
0852 }
0853 
0854 static int dev_create(struct file *filp, struct dm_ioctl *param, size_t param_size)
0855 {
0856     int r, m = DM_ANY_MINOR;
0857     struct mapped_device *md;
0858 
0859     r = check_name(param->name);
0860     if (r)
0861         return r;
0862 
0863     if (param->flags & DM_PERSISTENT_DEV_FLAG)
0864         m = MINOR(huge_decode_dev(param->dev));
0865 
0866     r = dm_create(m, &md);
0867     if (r)
0868         return r;
0869 
0870     r = dm_hash_insert(param->name, *param->uuid ? param->uuid : NULL, md);
0871     if (r) {
0872         dm_put(md);
0873         dm_destroy(md);
0874         return r;
0875     }
0876 
0877     param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
0878 
0879     __dev_status(md, param);
0880 
0881     dm_put(md);
0882 
0883     return 0;
0884 }
0885 
0886 /*
0887  * Always use UUID for lookups if it's present, otherwise use name or dev.
0888  */
0889 static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
0890 {
0891     struct hash_cell *hc = NULL;
0892 
0893     if (*param->uuid) {
0894         if (*param->name || param->dev) {
0895             DMERR("Invalid ioctl structure: uuid %s, name %s, dev %llx",
0896                   param->uuid, param->name, (unsigned long long)param->dev);
0897             return NULL;
0898         }
0899 
0900         hc = __get_uuid_cell(param->uuid);
0901         if (!hc)
0902             return NULL;
0903     } else if (*param->name) {
0904         if (param->dev) {
0905             DMERR("Invalid ioctl structure: name %s, dev %llx",
0906                   param->name, (unsigned long long)param->dev);
0907             return NULL;
0908         }
0909 
0910         hc = __get_name_cell(param->name);
0911         if (!hc)
0912             return NULL;
0913     } else if (param->dev) {
0914         hc = __get_dev_cell(param->dev);
0915         if (!hc)
0916             return NULL;
0917     } else
0918         return NULL;
0919 
0920     /*
0921      * Sneakily write in both the name and the uuid
0922      * while we have the cell.
0923      */
0924     strlcpy(param->name, hc->name, sizeof(param->name));
0925     if (hc->uuid)
0926         strlcpy(param->uuid, hc->uuid, sizeof(param->uuid));
0927     else
0928         param->uuid[0] = '\0';
0929 
0930     if (hc->new_map)
0931         param->flags |= DM_INACTIVE_PRESENT_FLAG;
0932     else
0933         param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
0934 
0935     return hc;
0936 }
0937 
0938 static struct mapped_device *find_device(struct dm_ioctl *param)
0939 {
0940     struct hash_cell *hc;
0941     struct mapped_device *md = NULL;
0942 
0943     down_read(&_hash_lock);
0944     hc = __find_device_hash_cell(param);
0945     if (hc)
0946         md = hc->md;
0947     up_read(&_hash_lock);
0948 
0949     return md;
0950 }
0951 
0952 static int dev_remove(struct file *filp, struct dm_ioctl *param, size_t param_size)
0953 {
0954     struct hash_cell *hc;
0955     struct mapped_device *md;
0956     int r;
0957     struct dm_table *t;
0958 
0959     down_write(&_hash_lock);
0960     hc = __find_device_hash_cell(param);
0961 
0962     if (!hc) {
0963         DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
0964         up_write(&_hash_lock);
0965         return -ENXIO;
0966     }
0967 
0968     md = hc->md;
0969 
0970     /*
0971      * Ensure the device is not open and nothing further can open it.
0972      */
0973     r = dm_lock_for_deletion(md, !!(param->flags & DM_DEFERRED_REMOVE), false);
0974     if (r) {
0975         if (r == -EBUSY && param->flags & DM_DEFERRED_REMOVE) {
0976             up_write(&_hash_lock);
0977             dm_put(md);
0978             return 0;
0979         }
0980         DMDEBUG_LIMIT("unable to remove open device %s", hc->name);
0981         up_write(&_hash_lock);
0982         dm_put(md);
0983         return r;
0984     }
0985 
0986     t = __hash_remove(hc);
0987     up_write(&_hash_lock);
0988 
0989     if (t) {
0990         dm_sync_table(md);
0991         dm_table_destroy(t);
0992     }
0993 
0994     param->flags &= ~DM_DEFERRED_REMOVE;
0995 
0996     dm_ima_measure_on_device_remove(md, false);
0997 
0998     if (!dm_kobject_uevent(md, KOBJ_REMOVE, param->event_nr))
0999         param->flags |= DM_UEVENT_GENERATED_FLAG;
1000 
1001     dm_put(md);
1002     dm_destroy(md);
1003     return 0;
1004 }
1005 
1006 /*
1007  * Check a string doesn't overrun the chunk of
1008  * memory we copied from userland.
1009  */
1010 static int invalid_str(char *str, void *end)
1011 {
1012     while ((void *) str < end)
1013         if (!*str++)
1014             return 0;
1015 
1016     return -EINVAL;
1017 }
1018 
1019 static int dev_rename(struct file *filp, struct dm_ioctl *param, size_t param_size)
1020 {
1021     int r;
1022     char *new_data = (char *) param + param->data_start;
1023     struct mapped_device *md;
1024     unsigned change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0;
1025 
1026     if (new_data < param->data ||
1027         invalid_str(new_data, (void *) param + param_size) || !*new_data ||
1028         strlen(new_data) > (change_uuid ? DM_UUID_LEN - 1 : DM_NAME_LEN - 1)) {
1029         DMWARN("Invalid new mapped device name or uuid string supplied.");
1030         return -EINVAL;
1031     }
1032 
1033     if (!change_uuid) {
1034         r = check_name(new_data);
1035         if (r)
1036             return r;
1037     }
1038 
1039     md = dm_hash_rename(param, new_data);
1040     if (IS_ERR(md))
1041         return PTR_ERR(md);
1042 
1043     __dev_status(md, param);
1044     dm_put(md);
1045 
1046     return 0;
1047 }
1048 
1049 static int dev_set_geometry(struct file *filp, struct dm_ioctl *param, size_t param_size)
1050 {
1051     int r = -EINVAL, x;
1052     struct mapped_device *md;
1053     struct hd_geometry geometry;
1054     unsigned long indata[4];
1055     char *geostr = (char *) param + param->data_start;
1056     char dummy;
1057 
1058     md = find_device(param);
1059     if (!md)
1060         return -ENXIO;
1061 
1062     if (geostr < param->data ||
1063         invalid_str(geostr, (void *) param + param_size)) {
1064         DMWARN("Invalid geometry supplied.");
1065         goto out;
1066     }
1067 
1068     x = sscanf(geostr, "%lu %lu %lu %lu%c", indata,
1069            indata + 1, indata + 2, indata + 3, &dummy);
1070 
1071     if (x != 4) {
1072         DMWARN("Unable to interpret geometry settings.");
1073         goto out;
1074     }
1075 
1076     if (indata[0] > 65535 || indata[1] > 255 ||
1077         indata[2] > 255 || indata[3] > ULONG_MAX) {
1078         DMWARN("Geometry exceeds range limits.");
1079         goto out;
1080     }
1081 
1082     geometry.cylinders = indata[0];
1083     geometry.heads = indata[1];
1084     geometry.sectors = indata[2];
1085     geometry.start = indata[3];
1086 
1087     r = dm_set_geometry(md, &geometry);
1088 
1089     param->data_size = 0;
1090 
1091 out:
1092     dm_put(md);
1093     return r;
1094 }
1095 
1096 static int do_suspend(struct dm_ioctl *param)
1097 {
1098     int r = 0;
1099     unsigned suspend_flags = DM_SUSPEND_LOCKFS_FLAG;
1100     struct mapped_device *md;
1101 
1102     md = find_device(param);
1103     if (!md)
1104         return -ENXIO;
1105 
1106     if (param->flags & DM_SKIP_LOCKFS_FLAG)
1107         suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG;
1108     if (param->flags & DM_NOFLUSH_FLAG)
1109         suspend_flags |= DM_SUSPEND_NOFLUSH_FLAG;
1110 
1111     if (!dm_suspended_md(md)) {
1112         r = dm_suspend(md, suspend_flags);
1113         if (r)
1114             goto out;
1115     }
1116 
1117     __dev_status(md, param);
1118 
1119 out:
1120     dm_put(md);
1121 
1122     return r;
1123 }
1124 
1125 static int do_resume(struct dm_ioctl *param)
1126 {
1127     int r = 0;
1128     unsigned suspend_flags = DM_SUSPEND_LOCKFS_FLAG;
1129     struct hash_cell *hc;
1130     struct mapped_device *md;
1131     struct dm_table *new_map, *old_map = NULL;
1132 
1133     down_write(&_hash_lock);
1134 
1135     hc = __find_device_hash_cell(param);
1136     if (!hc) {
1137         DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
1138         up_write(&_hash_lock);
1139         return -ENXIO;
1140     }
1141 
1142     md = hc->md;
1143 
1144     new_map = hc->new_map;
1145     hc->new_map = NULL;
1146     param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1147 
1148     up_write(&_hash_lock);
1149 
1150     /* Do we need to load a new map ? */
1151     if (new_map) {
1152         /* Suspend if it isn't already suspended */
1153         if (param->flags & DM_SKIP_LOCKFS_FLAG)
1154             suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG;
1155         if (param->flags & DM_NOFLUSH_FLAG)
1156             suspend_flags |= DM_SUSPEND_NOFLUSH_FLAG;
1157         if (!dm_suspended_md(md))
1158             dm_suspend(md, suspend_flags);
1159 
1160         old_map = dm_swap_table(md, new_map);
1161         if (IS_ERR(old_map)) {
1162             dm_sync_table(md);
1163             dm_table_destroy(new_map);
1164             dm_put(md);
1165             return PTR_ERR(old_map);
1166         }
1167 
1168         if (dm_table_get_mode(new_map) & FMODE_WRITE)
1169             set_disk_ro(dm_disk(md), 0);
1170         else
1171             set_disk_ro(dm_disk(md), 1);
1172     }
1173 
1174     if (dm_suspended_md(md)) {
1175         r = dm_resume(md);
1176         if (!r) {
1177             dm_ima_measure_on_device_resume(md, new_map ? true : false);
1178 
1179             if (!dm_kobject_uevent(md, KOBJ_CHANGE, param->event_nr))
1180                 param->flags |= DM_UEVENT_GENERATED_FLAG;
1181         }
1182     }
1183 
1184     /*
1185      * Since dm_swap_table synchronizes RCU, nobody should be in
1186      * read-side critical section already.
1187      */
1188     if (old_map)
1189         dm_table_destroy(old_map);
1190 
1191     if (!r)
1192         __dev_status(md, param);
1193 
1194     dm_put(md);
1195     return r;
1196 }
1197 
1198 /*
1199  * Set or unset the suspension state of a device.
1200  * If the device already is in the requested state we just return its status.
1201  */
1202 static int dev_suspend(struct file *filp, struct dm_ioctl *param, size_t param_size)
1203 {
1204     if (param->flags & DM_SUSPEND_FLAG)
1205         return do_suspend(param);
1206 
1207     return do_resume(param);
1208 }
1209 
1210 /*
1211  * Copies device info back to user space, used by
1212  * the create and info ioctls.
1213  */
1214 static int dev_status(struct file *filp, struct dm_ioctl *param, size_t param_size)
1215 {
1216     struct mapped_device *md;
1217 
1218     md = find_device(param);
1219     if (!md)
1220         return -ENXIO;
1221 
1222     __dev_status(md, param);
1223     dm_put(md);
1224 
1225     return 0;
1226 }
1227 
1228 /*
1229  * Build up the status struct for each target
1230  */
1231 static void retrieve_status(struct dm_table *table,
1232                 struct dm_ioctl *param, size_t param_size)
1233 {
1234     unsigned int i, num_targets;
1235     struct dm_target_spec *spec;
1236     char *outbuf, *outptr;
1237     status_type_t type;
1238     size_t remaining, len, used = 0;
1239     unsigned status_flags = 0;
1240 
1241     outptr = outbuf = get_result_buffer(param, param_size, &len);
1242 
1243     if (param->flags & DM_STATUS_TABLE_FLAG)
1244         type = STATUSTYPE_TABLE;
1245     else if (param->flags & DM_IMA_MEASUREMENT_FLAG)
1246         type = STATUSTYPE_IMA;
1247     else
1248         type = STATUSTYPE_INFO;
1249 
1250     /* Get all the target info */
1251     num_targets = table->num_targets;
1252     for (i = 0; i < num_targets; i++) {
1253         struct dm_target *ti = dm_table_get_target(table, i);
1254         size_t l;
1255 
1256         remaining = len - (outptr - outbuf);
1257         if (remaining <= sizeof(struct dm_target_spec)) {
1258             param->flags |= DM_BUFFER_FULL_FLAG;
1259             break;
1260         }
1261 
1262         spec = (struct dm_target_spec *) outptr;
1263 
1264         spec->status = 0;
1265         spec->sector_start = ti->begin;
1266         spec->length = ti->len;
1267         strncpy(spec->target_type, ti->type->name,
1268             sizeof(spec->target_type) - 1);
1269 
1270         outptr += sizeof(struct dm_target_spec);
1271         remaining = len - (outptr - outbuf);
1272         if (remaining <= 0) {
1273             param->flags |= DM_BUFFER_FULL_FLAG;
1274             break;
1275         }
1276 
1277         /* Get the status/table string from the target driver */
1278         if (ti->type->status) {
1279             if (param->flags & DM_NOFLUSH_FLAG)
1280                 status_flags |= DM_STATUS_NOFLUSH_FLAG;
1281             ti->type->status(ti, type, status_flags, outptr, remaining);
1282         } else
1283             outptr[0] = '\0';
1284 
1285         l = strlen(outptr) + 1;
1286         if (l == remaining) {
1287             param->flags |= DM_BUFFER_FULL_FLAG;
1288             break;
1289         }
1290 
1291         outptr += l;
1292         used = param->data_start + (outptr - outbuf);
1293 
1294         outptr = align_ptr(outptr);
1295         spec->next = outptr - outbuf;
1296     }
1297 
1298     if (used)
1299         param->data_size = used;
1300 
1301     param->target_count = num_targets;
1302 }
1303 
1304 /*
1305  * Wait for a device to report an event
1306  */
1307 static int dev_wait(struct file *filp, struct dm_ioctl *param, size_t param_size)
1308 {
1309     int r = 0;
1310     struct mapped_device *md;
1311     struct dm_table *table;
1312     int srcu_idx;
1313 
1314     md = find_device(param);
1315     if (!md)
1316         return -ENXIO;
1317 
1318     /*
1319      * Wait for a notification event
1320      */
1321     if (dm_wait_event(md, param->event_nr)) {
1322         r = -ERESTARTSYS;
1323         goto out;
1324     }
1325 
1326     /*
1327      * The userland program is going to want to know what
1328      * changed to trigger the event, so we may as well tell
1329      * him and save an ioctl.
1330      */
1331     __dev_status(md, param);
1332 
1333     table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1334     if (table)
1335         retrieve_status(table, param, param_size);
1336     dm_put_live_table(md, srcu_idx);
1337 
1338 out:
1339     dm_put(md);
1340 
1341     return r;
1342 }
1343 
1344 /*
1345  * Remember the global event number and make it possible to poll
1346  * for further events.
1347  */
1348 static int dev_arm_poll(struct file *filp, struct dm_ioctl *param, size_t param_size)
1349 {
1350     struct dm_file *priv = filp->private_data;
1351 
1352     priv->global_event_nr = atomic_read(&dm_global_event_nr);
1353 
1354     return 0;
1355 }
1356 
1357 static inline fmode_t get_mode(struct dm_ioctl *param)
1358 {
1359     fmode_t mode = FMODE_READ | FMODE_WRITE;
1360 
1361     if (param->flags & DM_READONLY_FLAG)
1362         mode = FMODE_READ;
1363 
1364     return mode;
1365 }
1366 
1367 static int next_target(struct dm_target_spec *last, uint32_t next, void *end,
1368                struct dm_target_spec **spec, char **target_params)
1369 {
1370     *spec = (struct dm_target_spec *) ((unsigned char *) last + next);
1371     *target_params = (char *) (*spec + 1);
1372 
1373     if (*spec < (last + 1))
1374         return -EINVAL;
1375 
1376     return invalid_str(*target_params, end);
1377 }
1378 
1379 static int populate_table(struct dm_table *table,
1380               struct dm_ioctl *param, size_t param_size)
1381 {
1382     int r;
1383     unsigned int i = 0;
1384     struct dm_target_spec *spec = (struct dm_target_spec *) param;
1385     uint32_t next = param->data_start;
1386     void *end = (void *) param + param_size;
1387     char *target_params;
1388 
1389     if (!param->target_count) {
1390         DMWARN("populate_table: no targets specified");
1391         return -EINVAL;
1392     }
1393 
1394     for (i = 0; i < param->target_count; i++) {
1395 
1396         r = next_target(spec, next, end, &spec, &target_params);
1397         if (r) {
1398             DMWARN("unable to find target");
1399             return r;
1400         }
1401 
1402         r = dm_table_add_target(table, spec->target_type,
1403                     (sector_t) spec->sector_start,
1404                     (sector_t) spec->length,
1405                     target_params);
1406         if (r) {
1407             DMWARN("error adding target to table");
1408             return r;
1409         }
1410 
1411         next = spec->next;
1412     }
1413 
1414     return dm_table_complete(table);
1415 }
1416 
1417 static bool is_valid_type(enum dm_queue_mode cur, enum dm_queue_mode new)
1418 {
1419     if (cur == new ||
1420         (cur == DM_TYPE_BIO_BASED && new == DM_TYPE_DAX_BIO_BASED))
1421         return true;
1422 
1423     return false;
1424 }
1425 
1426 static int table_load(struct file *filp, struct dm_ioctl *param, size_t param_size)
1427 {
1428     int r;
1429     struct hash_cell *hc;
1430     struct dm_table *t, *old_map = NULL;
1431     struct mapped_device *md;
1432     struct target_type *immutable_target_type;
1433 
1434     md = find_device(param);
1435     if (!md)
1436         return -ENXIO;
1437 
1438     r = dm_table_create(&t, get_mode(param), param->target_count, md);
1439     if (r)
1440         goto err;
1441 
1442     /* Protect md->type and md->queue against concurrent table loads. */
1443     dm_lock_md_type(md);
1444     r = populate_table(t, param, param_size);
1445     if (r)
1446         goto err_unlock_md_type;
1447 
1448     dm_ima_measure_on_table_load(t, STATUSTYPE_IMA);
1449 
1450     immutable_target_type = dm_get_immutable_target_type(md);
1451     if (immutable_target_type &&
1452         (immutable_target_type != dm_table_get_immutable_target_type(t)) &&
1453         !dm_table_get_wildcard_target(t)) {
1454         DMWARN("can't replace immutable target type %s",
1455                immutable_target_type->name);
1456         r = -EINVAL;
1457         goto err_unlock_md_type;
1458     }
1459 
1460     if (dm_get_md_type(md) == DM_TYPE_NONE) {
1461         /* setup md->queue to reflect md's type (may block) */
1462         r = dm_setup_md_queue(md, t);
1463         if (r) {
1464             DMWARN("unable to set up device queue for new table.");
1465             goto err_unlock_md_type;
1466         }
1467     } else if (!is_valid_type(dm_get_md_type(md), dm_table_get_type(t))) {
1468         DMWARN("can't change device type (old=%u vs new=%u) after initial table load.",
1469                dm_get_md_type(md), dm_table_get_type(t));
1470         r = -EINVAL;
1471         goto err_unlock_md_type;
1472     }
1473 
1474     dm_unlock_md_type(md);
1475 
1476     /* stage inactive table */
1477     down_write(&_hash_lock);
1478     hc = dm_get_mdptr(md);
1479     if (!hc || hc->md != md) {
1480         DMWARN("device has been removed from the dev hash table.");
1481         up_write(&_hash_lock);
1482         r = -ENXIO;
1483         goto err_destroy_table;
1484     }
1485 
1486     if (hc->new_map)
1487         old_map = hc->new_map;
1488     hc->new_map = t;
1489     up_write(&_hash_lock);
1490 
1491     param->flags |= DM_INACTIVE_PRESENT_FLAG;
1492     __dev_status(md, param);
1493 
1494     if (old_map) {
1495         dm_sync_table(md);
1496         dm_table_destroy(old_map);
1497     }
1498 
1499     dm_put(md);
1500 
1501     return 0;
1502 
1503 err_unlock_md_type:
1504     dm_unlock_md_type(md);
1505 err_destroy_table:
1506     dm_table_destroy(t);
1507 err:
1508     dm_put(md);
1509 
1510     return r;
1511 }
1512 
1513 static int table_clear(struct file *filp, struct dm_ioctl *param, size_t param_size)
1514 {
1515     struct hash_cell *hc;
1516     struct mapped_device *md;
1517     struct dm_table *old_map = NULL;
1518     bool has_new_map = false;
1519 
1520     down_write(&_hash_lock);
1521 
1522     hc = __find_device_hash_cell(param);
1523     if (!hc) {
1524         DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table.");
1525         up_write(&_hash_lock);
1526         return -ENXIO;
1527     }
1528 
1529     if (hc->new_map) {
1530         old_map = hc->new_map;
1531         hc->new_map = NULL;
1532         has_new_map = true;
1533     }
1534 
1535     param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1536 
1537     __dev_status(hc->md, param);
1538     md = hc->md;
1539     up_write(&_hash_lock);
1540     if (old_map) {
1541         dm_sync_table(md);
1542         dm_table_destroy(old_map);
1543     }
1544     dm_ima_measure_on_table_clear(md, has_new_map);
1545     dm_put(md);
1546 
1547     return 0;
1548 }
1549 
1550 /*
1551  * Retrieves a list of devices used by a particular dm device.
1552  */
1553 static void retrieve_deps(struct dm_table *table,
1554               struct dm_ioctl *param, size_t param_size)
1555 {
1556     unsigned int count = 0;
1557     struct list_head *tmp;
1558     size_t len, needed;
1559     struct dm_dev_internal *dd;
1560     struct dm_target_deps *deps;
1561 
1562     deps = get_result_buffer(param, param_size, &len);
1563 
1564     /*
1565      * Count the devices.
1566      */
1567     list_for_each (tmp, dm_table_get_devices(table))
1568         count++;
1569 
1570     /*
1571      * Check we have enough space.
1572      */
1573     needed = struct_size(deps, dev, count);
1574     if (len < needed) {
1575         param->flags |= DM_BUFFER_FULL_FLAG;
1576         return;
1577     }
1578 
1579     /*
1580      * Fill in the devices.
1581      */
1582     deps->count = count;
1583     count = 0;
1584     list_for_each_entry (dd, dm_table_get_devices(table), list)
1585         deps->dev[count++] = huge_encode_dev(dd->dm_dev->bdev->bd_dev);
1586 
1587     param->data_size = param->data_start + needed;
1588 }
1589 
1590 static int table_deps(struct file *filp, struct dm_ioctl *param, size_t param_size)
1591 {
1592     struct mapped_device *md;
1593     struct dm_table *table;
1594     int srcu_idx;
1595 
1596     md = find_device(param);
1597     if (!md)
1598         return -ENXIO;
1599 
1600     __dev_status(md, param);
1601 
1602     table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1603     if (table)
1604         retrieve_deps(table, param, param_size);
1605     dm_put_live_table(md, srcu_idx);
1606 
1607     dm_put(md);
1608 
1609     return 0;
1610 }
1611 
1612 /*
1613  * Return the status of a device as a text string for each
1614  * target.
1615  */
1616 static int table_status(struct file *filp, struct dm_ioctl *param, size_t param_size)
1617 {
1618     struct mapped_device *md;
1619     struct dm_table *table;
1620     int srcu_idx;
1621 
1622     md = find_device(param);
1623     if (!md)
1624         return -ENXIO;
1625 
1626     __dev_status(md, param);
1627 
1628     table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1629     if (table)
1630         retrieve_status(table, param, param_size);
1631     dm_put_live_table(md, srcu_idx);
1632 
1633     dm_put(md);
1634 
1635     return 0;
1636 }
1637 
1638 /*
1639  * Process device-mapper dependent messages.  Messages prefixed with '@'
1640  * are processed by the DM core.  All others are delivered to the target.
1641  * Returns a number <= 1 if message was processed by device mapper.
1642  * Returns 2 if message should be delivered to the target.
1643  */
1644 static int message_for_md(struct mapped_device *md, unsigned argc, char **argv,
1645               char *result, unsigned maxlen)
1646 {
1647     int r;
1648 
1649     if (**argv != '@')
1650         return 2; /* no '@' prefix, deliver to target */
1651 
1652     if (!strcasecmp(argv[0], "@cancel_deferred_remove")) {
1653         if (argc != 1) {
1654             DMERR("Invalid arguments for @cancel_deferred_remove");
1655             return -EINVAL;
1656         }
1657         return dm_cancel_deferred_remove(md);
1658     }
1659 
1660     r = dm_stats_message(md, argc, argv, result, maxlen);
1661     if (r < 2)
1662         return r;
1663 
1664     DMERR("Unsupported message sent to DM core: %s", argv[0]);
1665     return -EINVAL;
1666 }
1667 
1668 /*
1669  * Pass a message to the target that's at the supplied device offset.
1670  */
1671 static int target_message(struct file *filp, struct dm_ioctl *param, size_t param_size)
1672 {
1673     int r, argc;
1674     char **argv;
1675     struct mapped_device *md;
1676     struct dm_table *table;
1677     struct dm_target *ti;
1678     struct dm_target_msg *tmsg = (void *) param + param->data_start;
1679     size_t maxlen;
1680     char *result = get_result_buffer(param, param_size, &maxlen);
1681     int srcu_idx;
1682 
1683     md = find_device(param);
1684     if (!md)
1685         return -ENXIO;
1686 
1687     if (tmsg < (struct dm_target_msg *) param->data ||
1688         invalid_str(tmsg->message, (void *) param + param_size)) {
1689         DMWARN("Invalid target message parameters.");
1690         r = -EINVAL;
1691         goto out;
1692     }
1693 
1694     r = dm_split_args(&argc, &argv, tmsg->message);
1695     if (r) {
1696         DMWARN("Failed to split target message parameters");
1697         goto out;
1698     }
1699 
1700     if (!argc) {
1701         DMWARN("Empty message received.");
1702         r = -EINVAL;
1703         goto out_argv;
1704     }
1705 
1706     r = message_for_md(md, argc, argv, result, maxlen);
1707     if (r <= 1)
1708         goto out_argv;
1709 
1710     table = dm_get_live_table(md, &srcu_idx);
1711     if (!table)
1712         goto out_table;
1713 
1714     if (dm_deleting_md(md)) {
1715         r = -ENXIO;
1716         goto out_table;
1717     }
1718 
1719     ti = dm_table_find_target(table, tmsg->sector);
1720     if (!ti) {
1721         DMWARN("Target message sector outside device.");
1722         r = -EINVAL;
1723     } else if (ti->type->message)
1724         r = ti->type->message(ti, argc, argv, result, maxlen);
1725     else {
1726         DMWARN("Target type does not support messages");
1727         r = -EINVAL;
1728     }
1729 
1730  out_table:
1731     dm_put_live_table(md, srcu_idx);
1732  out_argv:
1733     kfree(argv);
1734  out:
1735     if (r >= 0)
1736         __dev_status(md, param);
1737 
1738     if (r == 1) {
1739         param->flags |= DM_DATA_OUT_FLAG;
1740         if (dm_message_test_buffer_overflow(result, maxlen))
1741             param->flags |= DM_BUFFER_FULL_FLAG;
1742         else
1743             param->data_size = param->data_start + strlen(result) + 1;
1744         r = 0;
1745     }
1746 
1747     dm_put(md);
1748     return r;
1749 }
1750 
1751 /*
1752  * The ioctl parameter block consists of two parts, a dm_ioctl struct
1753  * followed by a data buffer.  This flag is set if the second part,
1754  * which has a variable size, is not used by the function processing
1755  * the ioctl.
1756  */
1757 #define IOCTL_FLAGS_NO_PARAMS       1
1758 #define IOCTL_FLAGS_ISSUE_GLOBAL_EVENT  2
1759 
1760 /*-----------------------------------------------------------------
1761  * Implementation of open/close/ioctl on the special char
1762  * device.
1763  *---------------------------------------------------------------*/
1764 static ioctl_fn lookup_ioctl(unsigned int cmd, int *ioctl_flags)
1765 {
1766     static const struct {
1767         int cmd;
1768         int flags;
1769         ioctl_fn fn;
1770     } _ioctls[] = {
1771         {DM_VERSION_CMD, 0, NULL}, /* version is dealt with elsewhere */
1772         {DM_REMOVE_ALL_CMD, IOCTL_FLAGS_NO_PARAMS | IOCTL_FLAGS_ISSUE_GLOBAL_EVENT, remove_all},
1773         {DM_LIST_DEVICES_CMD, 0, list_devices},
1774 
1775         {DM_DEV_CREATE_CMD, IOCTL_FLAGS_NO_PARAMS | IOCTL_FLAGS_ISSUE_GLOBAL_EVENT, dev_create},
1776         {DM_DEV_REMOVE_CMD, IOCTL_FLAGS_NO_PARAMS | IOCTL_FLAGS_ISSUE_GLOBAL_EVENT, dev_remove},
1777         {DM_DEV_RENAME_CMD, IOCTL_FLAGS_ISSUE_GLOBAL_EVENT, dev_rename},
1778         {DM_DEV_SUSPEND_CMD, IOCTL_FLAGS_NO_PARAMS, dev_suspend},
1779         {DM_DEV_STATUS_CMD, IOCTL_FLAGS_NO_PARAMS, dev_status},
1780         {DM_DEV_WAIT_CMD, 0, dev_wait},
1781 
1782         {DM_TABLE_LOAD_CMD, 0, table_load},
1783         {DM_TABLE_CLEAR_CMD, IOCTL_FLAGS_NO_PARAMS, table_clear},
1784         {DM_TABLE_DEPS_CMD, 0, table_deps},
1785         {DM_TABLE_STATUS_CMD, 0, table_status},
1786 
1787         {DM_LIST_VERSIONS_CMD, 0, list_versions},
1788 
1789         {DM_TARGET_MSG_CMD, 0, target_message},
1790         {DM_DEV_SET_GEOMETRY_CMD, 0, dev_set_geometry},
1791         {DM_DEV_ARM_POLL, IOCTL_FLAGS_NO_PARAMS, dev_arm_poll},
1792         {DM_GET_TARGET_VERSION, 0, get_target_version},
1793     };
1794 
1795     if (unlikely(cmd >= ARRAY_SIZE(_ioctls)))
1796         return NULL;
1797 
1798     cmd = array_index_nospec(cmd, ARRAY_SIZE(_ioctls));
1799     *ioctl_flags = _ioctls[cmd].flags;
1800     return _ioctls[cmd].fn;
1801 }
1802 
1803 /*
1804  * As well as checking the version compatibility this always
1805  * copies the kernel interface version out.
1806  */
1807 static int check_version(unsigned int cmd, struct dm_ioctl __user *user)
1808 {
1809     uint32_t version[3];
1810     int r = 0;
1811 
1812     if (copy_from_user(version, user->version, sizeof(version)))
1813         return -EFAULT;
1814 
1815     if ((DM_VERSION_MAJOR != version[0]) ||
1816         (DM_VERSION_MINOR < version[1])) {
1817         DMWARN("ioctl interface mismatch: "
1818                "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)",
1819                DM_VERSION_MAJOR, DM_VERSION_MINOR,
1820                DM_VERSION_PATCHLEVEL,
1821                version[0], version[1], version[2], cmd);
1822         r = -EINVAL;
1823     }
1824 
1825     /*
1826      * Fill in the kernel version.
1827      */
1828     version[0] = DM_VERSION_MAJOR;
1829     version[1] = DM_VERSION_MINOR;
1830     version[2] = DM_VERSION_PATCHLEVEL;
1831     if (copy_to_user(user->version, version, sizeof(version)))
1832         return -EFAULT;
1833 
1834     return r;
1835 }
1836 
1837 #define DM_PARAMS_MALLOC    0x0001  /* Params allocated with kvmalloc() */
1838 #define DM_WIPE_BUFFER      0x0010  /* Wipe input buffer before returning from ioctl */
1839 
1840 static void free_params(struct dm_ioctl *param, size_t param_size, int param_flags)
1841 {
1842     if (param_flags & DM_WIPE_BUFFER)
1843         memset(param, 0, param_size);
1844 
1845     if (param_flags & DM_PARAMS_MALLOC)
1846         kvfree(param);
1847 }
1848 
1849 static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl *param_kernel,
1850                int ioctl_flags, struct dm_ioctl **param, int *param_flags)
1851 {
1852     struct dm_ioctl *dmi;
1853     int secure_data;
1854     const size_t minimum_data_size = offsetof(struct dm_ioctl, data);
1855     unsigned noio_flag;
1856 
1857     if (copy_from_user(param_kernel, user, minimum_data_size))
1858         return -EFAULT;
1859 
1860     if (param_kernel->data_size < minimum_data_size) {
1861         DMERR("Invalid data size in the ioctl structure: %u",
1862               param_kernel->data_size);
1863         return -EINVAL;
1864     }
1865 
1866     secure_data = param_kernel->flags & DM_SECURE_DATA_FLAG;
1867 
1868     *param_flags = secure_data ? DM_WIPE_BUFFER : 0;
1869 
1870     if (ioctl_flags & IOCTL_FLAGS_NO_PARAMS) {
1871         dmi = param_kernel;
1872         dmi->data_size = minimum_data_size;
1873         goto data_copied;
1874     }
1875 
1876     /*
1877      * Use __GFP_HIGH to avoid low memory issues when a device is
1878      * suspended and the ioctl is needed to resume it.
1879      * Use kmalloc() rather than vmalloc() when we can.
1880      */
1881     dmi = NULL;
1882     noio_flag = memalloc_noio_save();
1883     dmi = kvmalloc(param_kernel->data_size, GFP_KERNEL | __GFP_HIGH);
1884     memalloc_noio_restore(noio_flag);
1885 
1886     if (!dmi) {
1887         if (secure_data && clear_user(user, param_kernel->data_size))
1888             return -EFAULT;
1889         return -ENOMEM;
1890     }
1891 
1892     *param_flags |= DM_PARAMS_MALLOC;
1893 
1894     /* Copy from param_kernel (which was already copied from user) */
1895     memcpy(dmi, param_kernel, minimum_data_size);
1896 
1897     if (copy_from_user(&dmi->data, (char __user *)user + minimum_data_size,
1898                param_kernel->data_size - minimum_data_size))
1899         goto bad;
1900 data_copied:
1901     /* Wipe the user buffer so we do not return it to userspace */
1902     if (secure_data && clear_user(user, param_kernel->data_size))
1903         goto bad;
1904 
1905     *param = dmi;
1906     return 0;
1907 
1908 bad:
1909     free_params(dmi, param_kernel->data_size, *param_flags);
1910 
1911     return -EFAULT;
1912 }
1913 
1914 static int validate_params(uint cmd, struct dm_ioctl *param)
1915 {
1916     /* Always clear this flag */
1917     param->flags &= ~DM_BUFFER_FULL_FLAG;
1918     param->flags &= ~DM_UEVENT_GENERATED_FLAG;
1919     param->flags &= ~DM_SECURE_DATA_FLAG;
1920     param->flags &= ~DM_DATA_OUT_FLAG;
1921 
1922     /* Ignores parameters */
1923     if (cmd == DM_REMOVE_ALL_CMD ||
1924         cmd == DM_LIST_DEVICES_CMD ||
1925         cmd == DM_LIST_VERSIONS_CMD)
1926         return 0;
1927 
1928     if (cmd == DM_DEV_CREATE_CMD) {
1929         if (!*param->name) {
1930             DMWARN("name not supplied when creating device");
1931             return -EINVAL;
1932         }
1933     } else if (*param->uuid && *param->name) {
1934         DMWARN("only supply one of name or uuid, cmd(%u)", cmd);
1935         return -EINVAL;
1936     }
1937 
1938     /* Ensure strings are terminated */
1939     param->name[DM_NAME_LEN - 1] = '\0';
1940     param->uuid[DM_UUID_LEN - 1] = '\0';
1941 
1942     return 0;
1943 }
1944 
1945 static int ctl_ioctl(struct file *file, uint command, struct dm_ioctl __user *user)
1946 {
1947     int r = 0;
1948     int ioctl_flags;
1949     int param_flags;
1950     unsigned int cmd;
1951     struct dm_ioctl *param;
1952     ioctl_fn fn = NULL;
1953     size_t input_param_size;
1954     struct dm_ioctl param_kernel;
1955 
1956     /* only root can play with this */
1957     if (!capable(CAP_SYS_ADMIN))
1958         return -EACCES;
1959 
1960     if (_IOC_TYPE(command) != DM_IOCTL)
1961         return -ENOTTY;
1962 
1963     cmd = _IOC_NR(command);
1964 
1965     /*
1966      * Check the interface version passed in.  This also
1967      * writes out the kernel's interface version.
1968      */
1969     r = check_version(cmd, user);
1970     if (r)
1971         return r;
1972 
1973     /*
1974      * Nothing more to do for the version command.
1975      */
1976     if (cmd == DM_VERSION_CMD)
1977         return 0;
1978 
1979     fn = lookup_ioctl(cmd, &ioctl_flags);
1980     if (!fn) {
1981         DMWARN("dm_ctl_ioctl: unknown command 0x%x", command);
1982         return -ENOTTY;
1983     }
1984 
1985     /*
1986      * Copy the parameters into kernel space.
1987      */
1988     r = copy_params(user, &param_kernel, ioctl_flags, &param, &param_flags);
1989 
1990     if (r)
1991         return r;
1992 
1993     input_param_size = param->data_size;
1994     r = validate_params(cmd, param);
1995     if (r)
1996         goto out;
1997 
1998     param->data_size = offsetof(struct dm_ioctl, data);
1999     r = fn(file, param, input_param_size);
2000 
2001     if (unlikely(param->flags & DM_BUFFER_FULL_FLAG) &&
2002         unlikely(ioctl_flags & IOCTL_FLAGS_NO_PARAMS))
2003         DMERR("ioctl %d tried to output some data but has IOCTL_FLAGS_NO_PARAMS set", cmd);
2004 
2005     if (!r && ioctl_flags & IOCTL_FLAGS_ISSUE_GLOBAL_EVENT)
2006         dm_issue_global_event();
2007 
2008     /*
2009      * Copy the results back to userland.
2010      */
2011     if (!r && copy_to_user(user, param, param->data_size))
2012         r = -EFAULT;
2013 
2014 out:
2015     free_params(param, input_param_size, param_flags);
2016     return r;
2017 }
2018 
2019 static long dm_ctl_ioctl(struct file *file, uint command, ulong u)
2020 {
2021     return (long)ctl_ioctl(file, command, (struct dm_ioctl __user *)u);
2022 }
2023 
2024 #ifdef CONFIG_COMPAT
2025 static long dm_compat_ctl_ioctl(struct file *file, uint command, ulong u)
2026 {
2027     return (long)dm_ctl_ioctl(file, command, (ulong) compat_ptr(u));
2028 }
2029 #else
2030 #define dm_compat_ctl_ioctl NULL
2031 #endif
2032 
2033 static int dm_open(struct inode *inode, struct file *filp)
2034 {
2035     int r;
2036     struct dm_file *priv;
2037 
2038     r = nonseekable_open(inode, filp);
2039     if (unlikely(r))
2040         return r;
2041 
2042     priv = filp->private_data = kmalloc(sizeof(struct dm_file), GFP_KERNEL);
2043     if (!priv)
2044         return -ENOMEM;
2045 
2046     priv->global_event_nr = atomic_read(&dm_global_event_nr);
2047 
2048     return 0;
2049 }
2050 
2051 static int dm_release(struct inode *inode, struct file *filp)
2052 {
2053     kfree(filp->private_data);
2054     return 0;
2055 }
2056 
2057 static __poll_t dm_poll(struct file *filp, poll_table *wait)
2058 {
2059     struct dm_file *priv = filp->private_data;
2060     __poll_t mask = 0;
2061 
2062     poll_wait(filp, &dm_global_eventq, wait);
2063 
2064     if ((int)(atomic_read(&dm_global_event_nr) - priv->global_event_nr) > 0)
2065         mask |= EPOLLIN;
2066 
2067     return mask;
2068 }
2069 
2070 static const struct file_operations _ctl_fops = {
2071     .open    = dm_open,
2072     .release = dm_release,
2073     .poll    = dm_poll,
2074     .unlocked_ioctl  = dm_ctl_ioctl,
2075     .compat_ioctl = dm_compat_ctl_ioctl,
2076     .owner   = THIS_MODULE,
2077     .llseek  = noop_llseek,
2078 };
2079 
2080 static struct miscdevice _dm_misc = {
2081     .minor      = MAPPER_CTRL_MINOR,
2082     .name       = DM_NAME,
2083     .nodename   = DM_DIR "/" DM_CONTROL_NODE,
2084     .fops       = &_ctl_fops
2085 };
2086 
2087 MODULE_ALIAS_MISCDEV(MAPPER_CTRL_MINOR);
2088 MODULE_ALIAS("devname:" DM_DIR "/" DM_CONTROL_NODE);
2089 
2090 /*
2091  * Create misc character device and link to DM_DIR/control.
2092  */
2093 int __init dm_interface_init(void)
2094 {
2095     int r;
2096 
2097     r = misc_register(&_dm_misc);
2098     if (r) {
2099         DMERR("misc_register failed for control device");
2100         return r;
2101     }
2102 
2103     DMINFO("%d.%d.%d%s initialised: %s", DM_VERSION_MAJOR,
2104            DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL, DM_VERSION_EXTRA,
2105            DM_DRIVER_EMAIL);
2106     return 0;
2107 }
2108 
2109 void dm_interface_exit(void)
2110 {
2111     misc_deregister(&_dm_misc);
2112     dm_hash_exit();
2113 }
2114 
2115 /**
2116  * dm_copy_name_and_uuid - Copy mapped device name & uuid into supplied buffers
2117  * @md: Pointer to mapped_device
2118  * @name: Buffer (size DM_NAME_LEN) for name
2119  * @uuid: Buffer (size DM_UUID_LEN) for uuid or empty string if uuid not defined
2120  */
2121 int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid)
2122 {
2123     int r = 0;
2124     struct hash_cell *hc;
2125 
2126     if (!md)
2127         return -ENXIO;
2128 
2129     mutex_lock(&dm_hash_cells_mutex);
2130     hc = dm_get_mdptr(md);
2131     if (!hc || hc->md != md) {
2132         r = -ENXIO;
2133         goto out;
2134     }
2135 
2136     if (name)
2137         strcpy(name, hc->name);
2138     if (uuid)
2139         strcpy(uuid, hc->uuid ? : "");
2140 
2141 out:
2142     mutex_unlock(&dm_hash_cells_mutex);
2143 
2144     return r;
2145 }
2146 EXPORT_SYMBOL_GPL(dm_copy_name_and_uuid);
2147 
2148 /**
2149  * dm_early_create - create a mapped device in early boot.
2150  *
2151  * @dmi: Contains main information of the device mapping to be created.
2152  * @spec_array: array of pointers to struct dm_target_spec. Describes the
2153  * mapping table of the device.
2154  * @target_params_array: array of strings with the parameters to a specific
2155  * target.
2156  *
2157  * Instead of having the struct dm_target_spec and the parameters for every
2158  * target embedded at the end of struct dm_ioctl (as performed in a normal
2159  * ioctl), pass them as arguments, so the caller doesn't need to serialize them.
2160  * The size of the spec_array and target_params_array is given by
2161  * @dmi->target_count.
2162  * This function is supposed to be called in early boot, so locking mechanisms
2163  * to protect against concurrent loads are not required.
2164  */
2165 int __init dm_early_create(struct dm_ioctl *dmi,
2166                struct dm_target_spec **spec_array,
2167                char **target_params_array)
2168 {
2169     int r, m = DM_ANY_MINOR;
2170     struct dm_table *t, *old_map;
2171     struct mapped_device *md;
2172     unsigned int i;
2173 
2174     if (!dmi->target_count)
2175         return -EINVAL;
2176 
2177     r = check_name(dmi->name);
2178     if (r)
2179         return r;
2180 
2181     if (dmi->flags & DM_PERSISTENT_DEV_FLAG)
2182         m = MINOR(huge_decode_dev(dmi->dev));
2183 
2184     /* alloc dm device */
2185     r = dm_create(m, &md);
2186     if (r)
2187         return r;
2188 
2189     /* hash insert */
2190     r = dm_hash_insert(dmi->name, *dmi->uuid ? dmi->uuid : NULL, md);
2191     if (r)
2192         goto err_destroy_dm;
2193 
2194     /* alloc table */
2195     r = dm_table_create(&t, get_mode(dmi), dmi->target_count, md);
2196     if (r)
2197         goto err_hash_remove;
2198 
2199     /* add targets */
2200     for (i = 0; i < dmi->target_count; i++) {
2201         r = dm_table_add_target(t, spec_array[i]->target_type,
2202                     (sector_t) spec_array[i]->sector_start,
2203                     (sector_t) spec_array[i]->length,
2204                     target_params_array[i]);
2205         if (r) {
2206             DMWARN("error adding target to table");
2207             goto err_destroy_table;
2208         }
2209     }
2210 
2211     /* finish table */
2212     r = dm_table_complete(t);
2213     if (r)
2214         goto err_destroy_table;
2215 
2216     /* setup md->queue to reflect md's type (may block) */
2217     r = dm_setup_md_queue(md, t);
2218     if (r) {
2219         DMWARN("unable to set up device queue for new table.");
2220         goto err_destroy_table;
2221     }
2222 
2223     /* Set new map */
2224     dm_suspend(md, 0);
2225     old_map = dm_swap_table(md, t);
2226     if (IS_ERR(old_map)) {
2227         r = PTR_ERR(old_map);
2228         goto err_destroy_table;
2229     }
2230     set_disk_ro(dm_disk(md), !!(dmi->flags & DM_READONLY_FLAG));
2231 
2232     /* resume device */
2233     r = dm_resume(md);
2234     if (r)
2235         goto err_destroy_table;
2236 
2237     DMINFO("%s (%s) is ready", md->disk->disk_name, dmi->name);
2238     dm_put(md);
2239     return 0;
2240 
2241 err_destroy_table:
2242     dm_table_destroy(t);
2243 err_hash_remove:
2244     (void) __hash_remove(__get_name_cell(dmi->name));
2245     /* release reference from __get_name_cell */
2246     dm_put(md);
2247 err_destroy_dm:
2248     dm_put(md);
2249     dm_destroy(md);
2250     return r;
2251 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!