CHROMIUM: add boot-to-device mapper support.

drivers/md/dm-ioctl.c

 /*
  * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
  * Copyright (C) 2004 - 2006 Red Hat, Inc. All rights reserved.
  *
  * This file is released under the GPL.
  */
 
 #include "dm.h"
 
 #include <linux/module.h>
@@ skipping 1043 matching lines @@
                                         (sector_t) spec->length,
                                         target_params);
                 if (r) {
                         DMWARN("error adding target to table");
                         return r;
                 }
 
                 next = spec->next;
         }
 
-        r = dm_table_set_type(table);
-        if (r) {
-                DMWARN("unable to set table type");
-                return r;
-        }
-
         return dm_table_complete(table);
 }
 
-static int table_prealloc_integrity(struct dm_table *t,
-                                    struct mapped_device *md)
-{
-        struct list_head *devices = dm_table_get_devices(t);
-        struct dm_dev_internal *dd;
-
-        list_for_each_entry(dd, devices, list)
-                if (bdev_get_integrity(dd->dm_dev.bdev))
-                        return blk_integrity_register(dm_disk(md), NULL);
-
-        return 0;
-}
-
 static int table_load(struct dm_ioctl *param, size_t param_size)
 {
         int r;
         struct hash_cell *hc;
         struct dm_table *t;
         struct mapped_device *md;
 
         md = find_device(param);
         if (!md)
                 return -ENXIO;
 
         r = dm_table_create(&t, get_mode(param), param->target_count, md);
         if (r)
                 goto out;
 
         r = populate_table(t, param, param_size);
         if (r) {
                 dm_table_destroy(t);
                 goto out;
         }
 
-        r = table_prealloc_integrity(t, md);
-        if (r) {
-                DMERR("%s: could not register integrity profile.",
-                      dm_device_name(md));
-                dm_table_destroy(t);
-                goto out;
-        }
-
-        r = dm_table_alloc_md_mempools(t);
-        if (r) {
-                DMWARN("unable to allocate mempools for this table");
-                dm_table_destroy(t);
-                goto out;
-        }
-
         down_write(&_hash_lock);
         hc = dm_get_mdptr(md);
         if (!hc || hc->md != md) {
                 DMWARN("device has been removed from the dev hash table.");
                 dm_table_destroy(t);
                 up_write(&_hash_lock);
                 r = -ENXIO;
                 goto out;
         }
 
@@ skipping 440 matching lines @@
 }
 
 void dm_interface_exit(void)
 {
         if (misc_deregister(&_dm_misc) < 0)
                 DMERR("misc_deregister failed for control device");
 
         dm_hash_exit();
 }
 
+
+/**
+ * dm_ioctl_export - Permanently export a mapped device via the ioctl interface
+ * @md: Pointer to mapped_device
+ * @name: Buffer (size DM_NAME_LEN) for name
+ * @uuid: Buffer (size DM_UUID_LEN) for uuid or NULL if not desired
+ */
+int dm_ioctl_export(struct mapped_device *md, const char *name,
+                    const char *uuid)
+{
+        int r = 0;
+        struct hash_cell *hc;
+
+        if (!md) {
+                r = -ENXIO;
+                goto out;
+        }
+
+        /* The name and uuid can only be set once. */
+        mutex_lock(&dm_hash_cells_mutex);
+        hc = dm_get_mdptr(md);
+        mutex_unlock(&dm_hash_cells_mutex);
+        if (hc) {
+                DMERR("%s: already exported", dm_device_name(md));
+                r = -ENXIO;
+                goto out;
+        }
+
+        r = dm_hash_insert(name, uuid, md);
+        if (r) {
+                DMERR("%s: could not bind to '%s'", dm_device_name(md), name);
+                goto out;
+        }
+
+        /* Let udev know we've changed. */
+        dm_kobject_uevent(md, KOBJ_CHANGE, dm_get_event_nr(md));
+out:
+        return r;
+}
 /**
  * dm_copy_name_and_uuid - Copy mapped device name & uuid into supplied buffers
  * @md: Pointer to mapped_device
  * @name: Buffer (size DM_NAME_LEN) for name
  * @uuid: Buffer (size DM_UUID_LEN) for uuid or empty string if uuid not defined
  */
 int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid)
 {
         int r = 0;
         struct hash_cell *hc;
@@ skipping 11 matching lines @@
         if (name)
                 strcpy(name, hc->name);
         if (uuid)
                 strcpy(uuid, hc->uuid ? : "");
 
 out:
         mutex_unlock(&dm_hash_cells_mutex);
 
         return r;
 }