auto import from //depot/cupcake/@135843
diff --git a/vold/devmapper.c b/vold/devmapper.c
new file mode 100644
index 0000000..ef44c90
--- /dev/null
+++ b/vold/devmapper.c
@@ -0,0 +1,463 @@
+
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <sched.h>
+#include <fcntl.h>
+
+#include <sys/mount.h>
+
+#include <linux/loop.h>
+#include <linux/dm-ioctl.h>
+
+#include <cutils/config_utils.h>
+#include <cutils/properties.h>
+
+#include "vold.h"
+#include "devmapper.h"
+
+#define DEBUG_DEVMAPPER 1
+
+static void *_align(void *ptr, unsigned int a)
+{
+ register unsigned long agn = --a;
+
+ return (void *) (((unsigned long) ptr + agn) & ~agn);
+}
+
+static struct dm_ioctl *_dm_ioctl_setup(struct devmapping *dm, int flags)
+{
+ void *buffer;
+ void *p;
+ const size_t min_size = 16 * 1024;
+ size_t len = sizeof(struct dm_ioctl);
+ struct dm_ioctl *io;
+ struct dm_target_spec *tgt;
+ int i;
+ char params[1024];
+ char key[80];
+
+ key[0] = '\0';
+ for (i = 0; i < (int) sizeof(dm->key); i++) {
+ char tmp[8];
+
+ sprintf(tmp, "%02x", dm->key[i]);
+ strcat(key, tmp);
+ }
+
+ char srcdev[128];
+
+ // XXX: Handle non crypt targets and non twofish (use param)
+ if (dm->src_type == dmsrc_loopback)
+ strcpy(srcdev, dm->type_data.loop.loop_dev);
+ else if (dm->src_type == dmsrc_partition)
+ strcpy(srcdev, dm->type_data.part.part_dev);
+
+ sprintf(params, "twofish %s 0 %s 0", key, srcdev);
+
+LOG_VOL("Params = '%s'", params);
+
+ if (len < min_size)
+ len = min_size;
+
+ if (!(buffer = malloc(len))) {
+ LOGE("out of memory");
+ return NULL;
+ }
+
+ memset(buffer, 0, len);
+ io = buffer;
+ tgt = (struct dm_target_spec *) &buffer[sizeof(struct dm_ioctl)];
+
+ io->version[0] = 4;
+ io->version[1] = 0;
+ io->version[2] = 0;
+
+ io->data_size = len;
+ io->data_start = sizeof(struct dm_ioctl);
+
+ io->flags = flags;
+ io->dev = 0;
+
+ io->target_count = 1;
+ io->event_nr = 1;
+ strncpy(io->name, dm->target, sizeof(io->name));
+
+ tgt->status = 0;
+ tgt->sector_start = 0;
+ tgt->length = (dm->size_mb * (1024 * 1024)) / 512;
+ strncpy(tgt->target_type, "crypt", sizeof(tgt->target_type));
+
+ p = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
+ strcpy((char *) p, params);
+ p+= strlen(params) + 1;
+
+ p = _align(p, 8);
+ tgt->next = p - buffer;
+
+ return io;
+}
+
+static int get_next_available_dm()
+{
+ int i;
+
+ for (i = 0; i < 8; i++) {
+ char path[255];
+ sprintf(path, "/dev/block/dm-%d", i);
+ if ((access(path, F_OK) < 0) && (errno == ENOENT))
+ return i;
+ }
+
+ LOGE("Out of device mapper numbers");
+ return -1;
+}
+
+static int create_devmapping(struct devmapping *dm)
+{
+ struct dm_ioctl *io;
+ int rc, fd;
+
+#if DEBUG_DEVMAPPER
+ LOG_VOL("create_devmapping():");
+#endif
+
+ if (dm->dm_no < 0) {
+ LOGE("Invalid dm_no set");
+ return -EINVAL;
+ }
+
+ if ((fd = open("/dev/device-mapper", O_RDWR)) < 0) {
+ LOGE("Error opening device mapper (%d)", errno);
+ return -errno;
+ }
+
+ if (!(io = _dm_ioctl_setup(dm, 0))) {
+ LOGE("Unable to setup ioctl (out of memory)");
+ close(fd);
+ return -ENOMEM;
+ }
+
+ if ((rc = ioctl(fd, DM_DEV_CREATE, io)) < 0) {
+ LOGE("device-mapper create ioctl failed (%d)", errno);
+ rc = -errno;
+ goto out_free;
+ }
+
+ free(io);
+
+ if (!(io = _dm_ioctl_setup(dm, DM_STATUS_TABLE_FLAG))) {
+ LOGE("Unable to setup ioctl (out of memory)");
+ rc = -ENOMEM;
+ goto out_nofree;
+ }
+
+ if ((rc = ioctl(fd, DM_TABLE_LOAD, io)) < 0) {
+ LOGE("device-mapper load ioctl failed (%d)", errno);
+ rc = -errno;
+ goto out_free;
+ }
+
+ free(io);
+
+ if (!(io = _dm_ioctl_setup(dm, 0))) {
+ LOGE("Unable to setup ioctl (out of memory)");
+ rc = -ENOMEM;
+ goto out_nofree;
+ }
+
+ if ((rc = ioctl(fd, DM_DEV_SUSPEND, io)) < 0) {
+ LOGE("device-mapper resume ioctl failed (%d)", errno);
+ rc = -errno;
+ goto out_free;
+ }
+
+out_free:
+ free (io);
+out_nofree:
+ close (fd);
+ return rc;
+}
+
+static int loopback_start(struct devmapping *dm)
+{
+ int i;
+ int fd;
+ char filename[255];
+ int rc;
+
+#if DEBUG_DEVMAPPER
+ LOG_VOL("loopback_start(%s):", dm->type_data.loop.loop_src);
+#endif
+
+ for (i = 0; i < MAX_LOOP; i++) {
+ struct loop_info info;
+
+ sprintf(filename, "/dev/block/loop%d", i);
+
+ if ((fd = open(filename, O_RDWR)) < 0) {
+ LOGE("Unable to open %s (%s)", filename, strerror(errno));
+ return -errno;
+ }
+
+ rc = ioctl(fd, LOOP_GET_STATUS, &info);
+ if (rc < 0 && errno == ENXIO)
+ break;
+
+ close(fd);
+
+ if (rc < 0) {
+ LOGE("Unable to get loop status for %s (%s)", filename,
+ strerror(errno));
+ return -errno;
+ }
+ }
+
+ if (i == MAX_LOOP) {
+ LOGE("Out of loop devices");
+ return -ENOSPC;
+ }
+
+ int file_fd;
+
+ if ((file_fd = open(dm->type_data.loop.loop_src, O_RDWR)) < 0) {
+ LOGE("Unable to open %s (%s)", dm->type_data.loop.loop_src,
+ strerror(errno));
+ return -errno;
+ }
+
+ if (ioctl(fd, LOOP_SET_FD, file_fd) < 0) {
+ LOGE("Error setting up loopback interface (%s)", strerror(errno));
+ return -errno;
+ }
+
+ dm->type_data.loop.loop_dev = strdup(filename);
+ dm->type_data.loop.loop_no = i;
+
+ close(fd);
+ close(file_fd);
+
+#if DEBUG_DEVMAPPER
+ LOG_VOL("Loop setup on %s for %s", dm->type_data.loop.loop_dev,
+ dm->type_data.loop.loop_src);
+#endif
+
+ return 0;
+}
+
+int devmapper_start(struct devmapping *dm)
+{
+ int rc;
+ char src_blkdev_path[255];
+
+#if DEBUG_DEVMAPPER
+ LOG_VOL("devmapper_start()");
+#endif
+
+ if (dm->src_type == dmsrc_loopback) {
+ if ((rc = loopback_start(dm)) < 0)
+ return rc;
+ } else if (dm->src_type == dmsrc_partition) {
+ LOGE("partition maps not yet supported");
+ return -ENOSYS;
+ } else {
+ LOGE("devmapper_start(): Unsupported source type '%d'", dm->src_type);
+ return -ENOENT;
+ }
+
+ /*
+ * Configure the device mapper
+ */
+ if ((rc = create_devmapping(dm)) < 0) {
+ LOGE("Failed to create devmapping (%d)", rc);
+ // XXX: if loopback then tear down
+ return rc;
+ }
+
+ return 0;
+}
+
+struct devmapping *devmapper_init(char *src, char *src_type, uint32_t size_mb,
+ char *target, char *params, char *tgt_fs, char *mediapath)
+{
+ struct devmapping *dm;
+
+ if (!(dm = malloc(sizeof(struct devmapping)))) {
+ LOGE("devmapper_init(): out of memory");
+ return NULL;
+ }
+
+ memset(dm, 0, sizeof(struct devmapping));
+
+ if (!strcmp(src_type, "loopback_file")) {
+ dm->src_type = dmsrc_loopback;
+ dm->type_data.loop.loop_src = strdup(src);
+ } else if (!strncmp(src_type, "partition ", strlen("partition "))) {
+ dm->src_type = dmsrc_partition;
+ char *p = strtok(src_type, " ");
+ if (!p) {
+ LOGE("Invalid partition specifier");
+ goto out_free;
+ }
+ dm->type_data.part.part_type = strtoul(p, NULL, 0);
+ } else {
+ LOGE("Invalid src_type defined (%s)", src_type);
+ goto out_free;
+ }
+
+ // XXX: Validate these
+ dm->size_mb = size_mb;
+ dm->target = strdup(target);
+ dm->params = strdup(params);
+ dm->tgt_fs = strdup(tgt_fs);
+
+ if ((dm->dm_no = get_next_available_dm()) < 0)
+ goto out_free;
+
+ sprintf(mediapath, "/devices/virtual/block/dm-%d", dm->dm_no);
+
+ if (!(dm->media = media_create(mediapath,
+ "unknown",
+ "unknown",
+ media_devmapper))) {
+ LOGE("Unable to create media");
+ goto out_free;
+ }
+
+ return dm;
+ out_free:
+ if (dm->target)
+ free(dm->target);
+ if (dm->params)
+ free(dm->params);
+ if (dm->tgt_fs)
+ free(dm->tgt_fs);
+
+ free(dm);
+ return NULL;
+}
+
+int devmapper_genesis(struct devmapping *dm)
+{
+
+ if (dm->src_type == dmsrc_loopback) {
+ int fd;
+
+ LOG_VOL("devmapper_genesis(): Working on %s",
+ dm->type_data.loop.loop_src);
+
+ unlink(dm->type_data.loop.loop_src);
+
+ LOG_VOL("devmapper_genesis(): Creating imagefile (%u MB)",
+ dm->size_mb);
+
+ if ((fd = creat(dm->type_data.loop.loop_src, 0600)) < 0) {
+ LOGE("Error creating imagefile (%s)", strerror(errno));
+ return -errno;
+ }
+
+ if (ftruncate(fd, (dm->size_mb * (1024 * 1024))) < 0) {
+ LOGE("Error truncating imagefile (%s)", strerror(errno));
+ close(fd);
+ return -errno;
+ }
+ close(fd);
+ } else if (dm->src_type == dmsrc_partition) {
+ LOGE("partition maps not yet supported");
+ return -ENOSYS;
+ }
+
+ return devmapper_start(dm);
+}
+
+static int destroy_devmapping(struct devmapping *dm)
+{
+ struct dm_ioctl *io;
+ int dmFd;
+ int rc = 0;
+
+ LOG_VOL("destroy_devmapping():");
+
+ if ((dmFd = open("/dev/device-mapper", O_RDWR)) < 0) {
+ LOGE("Error opening device mapper (%d)", errno);
+ return -errno;
+ }
+
+ if (!(io = _dm_ioctl_setup(dm, DM_PERSISTENT_DEV_FLAG))) {
+ LOGE("Unable to setup ioctl (out of memory)");
+ rc = -ENOMEM;
+ goto out_nofree;
+ }
+
+ if ((rc = ioctl(dmFd, DM_DEV_REMOVE, io)) < 0) {
+ LOGE("device-mapper remove ioctl failed (%d)", errno);
+ rc = -errno;
+ goto out_free;
+ }
+
+out_free:
+ free (io);
+out_nofree:
+ close (dmFd);
+ return rc;
+}
+
+static int loopback_stop(struct devmapping *dm)
+{
+ char devname[255];
+ int device_fd;
+ int rc = 0;
+
+ LOG_VOL("loopback_stop():");
+
+ device_fd = open(dm->type_data.loop.loop_dev, O_RDONLY);
+ if (device_fd < 0) {
+ LOG_ERROR("Failed to open loop (%d)", errno);
+ return -errno;
+ }
+
+ if (ioctl(device_fd, LOOP_CLR_FD, 0) < 0) {
+ LOG_ERROR("Failed to destroy loop (%d)", errno);
+ rc = -errno;
+ }
+
+ close(device_fd);
+ return rc;
+}
+
+int devmapper_stop(struct devmapping *dm)
+{
+ int rc;
+
+ LOG_VOL("devmapper_stop():");
+
+ if ((rc = destroy_devmapping(dm)))
+ return rc;
+
+ if (dm->src_type == dmsrc_loopback) {
+ if ((rc = loopback_stop(dm)))
+ return rc;
+ } else if (dm->src_type == dmsrc_partition) {
+ LOGE("partition maps not yet supported");
+ return -ENOSYS;
+ }
+ return 0;
+}