Signed-off-by: Ryan Grimm <grimm@xxxxxxxxxx>
Signed-off-by: Dan Smith <danms@xxxxxxxxxx>
# HG changeset patch
# User Ryan Grimm <grimm@xxxxxxxxxx>
# Date 1156521490 18000
# Node ID 2cb702dcea0e44dcfb9c243943d3e523245ad495
# Parent d5eb5205ff3588cc151fb15d6201c26c67e87506
dm-userspace xen kernel patch
diff -r d5eb5205ff35 -r 2cb702dcea0e buildconfigs/linux-defconfig_xen0_ia64
--- a/buildconfigs/linux-defconfig_xen0_ia64 Thu Aug 24 16:25:49 2006 +0100
+++ b/buildconfigs/linux-defconfig_xen0_ia64 Fri Aug 25 10:58:10 2006 -0500
@@ -485,6 +485,7 @@ CONFIG_MD=y
CONFIG_MD=y
# CONFIG_BLK_DEV_MD is not set
# CONFIG_BLK_DEV_DM is not set
+CONFIG_DM_USERSPACE=n
#
# Fusion MPT device support
diff -r d5eb5205ff35 -r 2cb702dcea0e buildconfigs/linux-defconfig_xen0_x86_32
--- a/buildconfigs/linux-defconfig_xen0_x86_32 Thu Aug 24 16:25:49 2006 +0100
+++ b/buildconfigs/linux-defconfig_xen0_x86_32 Fri Aug 25 10:58:10 2006 -0500
@@ -600,6 +600,7 @@ CONFIG_DM_MIRROR=y
CONFIG_DM_MIRROR=y
# CONFIG_DM_ZERO is not set
# CONFIG_DM_MULTIPATH is not set
+CONFIG_DM_USERSPACE=m
#
# Fusion MPT device support
diff -r d5eb5205ff35 -r 2cb702dcea0e buildconfigs/linux-defconfig_xen0_x86_64
--- a/buildconfigs/linux-defconfig_xen0_x86_64 Thu Aug 24 16:25:49 2006 +0100
+++ b/buildconfigs/linux-defconfig_xen0_x86_64 Fri Aug 25 10:58:10 2006 -0500
@@ -552,6 +552,7 @@ CONFIG_DM_MIRROR=y
# CONFIG_DM_ZERO is not set
CONFIG_DM_MULTIPATH=y
CONFIG_DM_MULTIPATH_EMC=y
+CONFIG_DM_USERSPACE=m
#
# Fusion MPT device support
diff -r d5eb5205ff35 -r 2cb702dcea0e buildconfigs/linux-defconfig_xen_x86_32
--- a/buildconfigs/linux-defconfig_xen_x86_32 Thu Aug 24 16:25:49 2006 +0100
+++ b/buildconfigs/linux-defconfig_xen_x86_32 Fri Aug 25 10:58:10 2006 -0500
@@ -1187,6 +1187,7 @@ CONFIG_DM_ZERO=m
CONFIG_DM_ZERO=m
CONFIG_DM_MULTIPATH=m
CONFIG_DM_MULTIPATH_EMC=m
+CONFIG_DM_USERSPACE=m
#
# Fusion MPT device support
diff -r d5eb5205ff35 -r 2cb702dcea0e buildconfigs/linux-defconfig_xen_x86_64
--- a/buildconfigs/linux-defconfig_xen_x86_64 Thu Aug 24 16:25:49 2006 +0100
+++ b/buildconfigs/linux-defconfig_xen_x86_64 Fri Aug 25 10:58:10 2006 -0500
@@ -1130,6 +1130,7 @@ CONFIG_DM_ZERO=m
CONFIG_DM_ZERO=m
CONFIG_DM_MULTIPATH=m
CONFIG_DM_MULTIPATH_EMC=m
+CONFIG_DM_USERSPACE=m
#
# Fusion MPT device support
diff -r d5eb5205ff35 -r 2cb702dcea0e patches/linux-2.6.16.13/series
--- a/patches/linux-2.6.16.13/series Thu Aug 24 16:25:49 2006 +0100
+++ b/patches/linux-2.6.16.13/series Fri Aug 25 10:58:10 2006 -0500
@@ -1,5 +1,6 @@ blktap-aio-16_03_06.patch
blktap-aio-16_03_06.patch
device_bind.patch
+dmu.patch
fix-hz-suspend.patch
fix-ide-cd-pio-mode.patch
i386-mach-io-check-nmi.patch
diff -r d5eb5205ff35 -r 2cb702dcea0e patches/linux-2.6.16.13/dmu.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/linux-2.6.16.13/dmu.patch Fri Aug 25 10:58:10 2006 -0500
@@ -0,0 +1,2591 @@
+diff -purN ../pristine-linux-2.6.16.13/drivers/md/dm-user.h
./drivers/md/dm-user.h
+--- ../pristine-linux-2.6.16.13/drivers/md/dm-user.h 1969-12-31
18:00:00.000000000 -0600
++++ ./drivers/md/dm-user.h 2006-08-16 18:48:18.000000000 -0500
+@@ -0,0 +1,209 @@
++/*
++ * Copyright (C) International Business Machines Corp., 2006
++ * Author: Dan Smith <danms@xxxxxxxxxx>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; under version 2 of the License.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ */
++
++#ifndef __DM_USER_H
++#define __DM_USER_H
++
++#include <linux/hardirq.h>
++
++#define DMU_KEY_LEN 256
++
++extern struct target_type userspace_target;
++extern mempool_t *request_pool;
++extern dev_t dmu_dev;
++extern spinlock_t devices_lock;
++extern struct list_head devices;
++
++/*
++ * A hash table of remaps
++ */
++struct hash_table {
++ struct list_head *table; /* Array of lists (buckets) */
++ uint64_t size; /* Number of buckets */
++ uint32_t mask; /* Mask used to determine bucket */
++ uint64_t count; /* Number of remaps in entire table */
++};
++
++/*
++ * A block device that we can send bios to
++ */
++struct target_device {
++ struct list_head list; /* Our place in the targets list */
++ struct block_device *bdev; /* The target block_device */
++ struct kref users; /* Self-destructing reference count */
++};
++
++/*
++ * A dm-userspace device, which consists of multiple targets sharing a
++ * common key
++ */
++struct dmu_device {
++ struct list_head list; /* Our place in the devices list */
++
++ spinlock_t lock; /* Protects all the fields below */
++
++ struct list_head requests; /* List of pending requests */
++ struct list_head target_devs; /* List of devices we can target */
++ struct hash_table remaps; /* Hash table of all our maps */
++
++ void *transport_private; /* Private data for userspace comms */
++
++ char key[DMU_KEY_LEN]; /* Unique name string for device */
++ struct kref users; /* Self-destructing reference count */
++
++ wait_queue_head_t wqueue; /* To block while waiting for reqs */
++
++ uint64_t block_size; /* Block size for this device */
++ uint64_t block_mask; /* Mask for offset in block */
++ unsigned int block_shift; /* Shift to convert to/from block */
++
++ struct kcopyd_client *kcopy; /* Interface to kcopyd */
++
++ uint32_t id_counter; /* Used to generate request IDs */
++};
++
++struct userspace_request {
++ struct list_head list; /* Our place on the request queue */
++
++ spinlock_t lock; /* Protects all the fields below */
++
++ struct dmu_device *dev; /* The DMU device that owns us */
++
++ int type; /* Type of request */
++ int sent; /* Non-zero if we've been sent */
++ uint32_t flags; /* Attribute flags */
++ uint32_t id; /* Unique ID for sync with userspace */
++ union {
++ uint64_t block; /* The block in question */
++ } u;
++ atomic_t refcnt; /* Reference count */
++
++ struct dmu_map *remap; /* The remap we represent */
++};
++
++struct dmu_map {
++ struct list_head list; /* Our place in a remap bucket chain */
++ struct list_head mru_list; /* Our place on the MRU list */
++
++ spinlock_t lock; /* Protects all the fields below */
++
++ uint64_t org_block; /* Original block */
++ uint64_t new_block; /* Destination block */
++ int64_t offset; /* Sectors to offset remapped block */
++ uint32_t flags; /* Attribute flags */
++ uint32_t id; /* Unique ID for sync with userspace */
++
++ struct target_device *src; /* Source blkdev for COPY_FIRST */
++ struct target_device *dest; /* Where the remapped block is */
++
++ struct bio_list bios; /* Bios queued for remapping */
++ struct bio_list bios_waiting; /* Bios waiting for endio sync */
++
++ struct dmu_device *dev; /* The DMU device that owns us */
++ struct dmu_map *next; /* Next remap that depends on us */
++
++ struct work_struct endio_task;/* Work to be done on bio endios */
++};
++
++/* Find and grab a reference to a target device */
++struct target_device *find_target(struct dmu_device *dev,
++ dev_t devno);
++
++/* Object allocation, destruction, and initialization routines */
++void init_remap(struct dmu_device *dev, struct dmu_map *remap);
++void init_request(struct dmu_device *dev,
++ int type,
++ struct userspace_request *req);
++void free_remap(struct dmu_map *remap);
++void __free_remap(struct dmu_map *remap);
++struct dmu_map *alloc_remap_atomic(struct dmu_device *dev);
++
++/* Hash table manipulation */
++struct dmu_map *ht_find_map(struct hash_table *ht, uint64_t block);
++void ht_insert_map(struct hash_table *ht, struct dmu_map *map);
++struct dmu_map *ht_find_map_dev(struct dmu_device *dev, uint64_t block);
++void ht_delete_map(struct hash_table *ht, struct dmu_map *map);
++
++/* Character device transport functions */
++int register_chardev_transport(struct dmu_device *dev);
++void unregister_chardev_transport(struct dmu_device *dev);
++int init_chardev_transport(void);
++void cleanup_chardev_transport(void);
++void write_chardev_transport_info(struct dmu_device *dev,
++ char *buf, unsigned int maxlen);
++
++/* Return the block number for @sector */
++static inline u64 dmu_block(struct dmu_device *dev,
++ sector_t sector)
++{
++ return sector >> dev->block_shift;
++}
++
++/* Return the sector offset in a block for @sector */
++static inline u64 dmu_sector_offset(struct dmu_device *dev,
++ sector_t sector)
++{
++ return sector & dev->block_mask;
++}
++
++/* Return the starting sector for @block */
++static inline u64 dmu_sector(struct dmu_device *dev,
++ uint64_t block)
++{
++ return block << dev->block_shift;
++}
++
++/* Add a request to a device's request queue */
++static void add_request(struct dmu_device *dev,
++ struct userspace_request *req)
++{
++ spin_lock(&dev->lock);
++ list_add_tail(&req->list, &dev->requests);
++ spin_unlock(&dev->lock);
++
++ wake_up(&dev->wqueue);
++}
++
++/* Remap @bio based on the information in @remap */
++static void __bio_remap(struct bio *bio,
++ struct dmu_map *remap)
++{
++ BUG_ON(remap->dest == NULL);
++
++ bio->bi_sector = dmu_sector(remap->dev, remap->new_block) +
++ dmu_sector_offset(remap->dev, bio->bi_sector) +
++ remap->offset;
++
++ bio->bi_bdev = remap->dest->bdev;
++}
++
++/* Increase the usage count for @dev */
++static inline void get_dev(struct dmu_device *dev)
++{
++ kref_get(&dev->users);
++}
++
++/* Decrease the usage count for @dev */
++void destroy_dmu_device(struct kref *ref);
++static inline void put_dev(struct dmu_device *dev)
++{
++ kref_put(&dev->users, destroy_dmu_device);
++}
++
++#endif
+diff -purN ../pristine-linux-2.6.16.13/drivers/md/dm-userspace.c
./drivers/md/dm-userspace.c
+--- ../pristine-linux-2.6.16.13/drivers/md/dm-userspace.c 1969-12-31
18:00:00.000000000 -0600
++++ ./drivers/md/dm-userspace.c 2006-08-16 18:48:18.000000000 -0500
+@@ -0,0 +1,1132 @@
++/*
++ * Copyright (C) International Business Machines Corp., 2006
++ * Author: Dan Smith <danms@xxxxxxxxxx>
++ * Author: Ryan Grimm <grimm@xxxxxxxxxx>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; under version 2 of the License.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ */
++
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/bio.h>
++#include <linux/slab.h>
++#include <linux/spinlock.h>
++#include <linux/list.h>
++#include <linux/fs.h>
++#include <linux/cdev.h>
++#include <linux/types.h>
++#include <linux/poll.h>
++
++#include <linux/dm-userspace.h>
++
++#include "dm.h"
++#include "dm-bio-list.h"
++#include "kcopyd.h"
++#include "dm-user.h"
++
++#define DMU_COPY_PAGES 256
++#define DMU_REMAP_RESERVE 128
++
++#define DM_MSG_PREFIX "dm-userspace"
++
++static kmem_cache_t *request_cache;
++static kmem_cache_t *remap_cache;
++
++mempool_t *request_pool;
++
++static int enable_watchdog = 0;
++static struct work_struct wd;
++
++spinlock_t devices_lock;
++LIST_HEAD(devices);
++
++static spinlock_t mru_list_lock;
++static LIST_HEAD(mru_list);
++
++/* Device number for the control device */
++dev_t dmu_dev;
++
++static int error_bios(struct bio_list *bios)
++{
++ struct bio *bio;
++ int count = 0;
++
++ while ((bio = bio_list_pop(bios)) != NULL) {
++ bio_io_error(bio, bio->bi_size);
++ count++;
++ }
++
++ if (count)
++ DMERR("*** Failed %i requests", count);
++
++ return count;
++}
++
++static void remap_hit(struct dmu_map *remap)
++{
++ spin_lock(&mru_list_lock);
++
++ list_del_init(&remap->mru_list);
++ list_add(&remap->mru_list, &mru_list);
++
++ spin_unlock(&mru_list_lock);
++}
++
++struct dmu_map *alloc_remap_atomic(struct dmu_device *dev)
++{
++ struct dmu_map *remap = NULL;
++
++ /* Try to allocate one from the cache */
++ remap = kmem_cache_alloc(remap_cache, GFP_NOIO);
++ if (remap) {
++ INIT_LIST_HEAD(&remap->mru_list);
++
++ spin_lock(&mru_list_lock);
++ list_add_tail(&remap->mru_list, &mru_list);
++ spin_unlock(&mru_list_lock);
++
++ goto out;
++ }
++
++ /* Unable to alloc one, so get the LRU item off the list */
++ spin_lock(&mru_list_lock);
++ remap = list_entry(mru_list.prev, struct dmu_map, mru_list);
++ spin_unlock(&mru_list_lock);
++
++ if (remap) {
++ struct dmu_device *dev = remap->dev;
++ unsigned long flags;
++
++ DMINFO("Memory is low. Stealing the LRU remap...");
++
++ spin_lock(&dev->lock);
++ spin_lock_irqsave(&remap->lock, flags);
++ if (dmu_get_flag(&remap->flags, DMU_FLAG_INUSE)) {
++ /* Remove it from whatever device owns it */
++
++ if (!list_empty(&remap->list))
++ list_del_init(&remap->list);
++
++ dmu_clr_flag(&remap->flags, DMU_FLAG_INUSE);
++
++ if (!dmu_get_flag(&remap->flags, DMU_FLAG_VALID)) {
++ /* If the LRU remap is not valid,
++ we're in trouble */
++ spin_unlock_irqrestore(&remap->lock, flags);
++ spin_unlock(&dev->lock);
++ printk(KERN_EMERG
++ "dm-userspace: Unable to allocate "
++ "or steal a remap!\n");
++ goto out;
++ }
++ }
++
++ spin_unlock_irqrestore(&remap->lock, flags);
++ spin_unlock(&dev->lock);
++
++ remap_hit(remap);
++ } else {
++ DMERR("Failed to alloc or steal a remap!");
++ }
++
++ out:
++ return remap;
++}
++
++void free_remap(struct dmu_map *remap)
++{
++ unsigned long flags;
++
++ if (error_bios(&remap->bios)) {
++ DMERR("Freed a map with in-flight data!");
++ BUG();
++ }
++
++ spin_lock_irqsave(&remap->lock, flags);
++ dmu_clr_flag(&remap->flags, DMU_FLAG_INUSE);
++ spin_unlock_irqrestore(&remap->lock, flags);
++
++ spin_lock(&remap->dev->lock);
++ list_del(&remap->list);
++ spin_unlock(&remap->dev->lock);
++
++ spin_lock(&mru_list_lock);
++ list_del_init(&remap->mru_list);
++ list_add_tail(&remap->mru_list, &mru_list);
++ spin_unlock(&mru_list_lock);
++}
++
++void __free_remap(struct dmu_map *remap)
++{
++ if (error_bios(&remap->bios)) {
++ DMERR("Freed a map with in-flight data!");
++ BUG();
++ }
++
++ dmu_clr_flag(&remap->flags, DMU_FLAG_INUSE);
++
++ list_del(&remap->list);
++
++ spin_lock(&mru_list_lock);
++ list_del_init(&remap->mru_list);
++ list_add_tail(&remap->mru_list, &mru_list);
++ spin_unlock(&mru_list_lock);
++}
++
++static struct userspace_request *make_sync_req(struct dmu_device *dev,
++ struct dmu_map *remap)
++{
++ struct userspace_request *req;
++ unsigned long flags;
++
++ req = mempool_alloc(request_pool, GFP_NOIO);
++ if (!req) {
++ DMERR("Failed to allocate copy response");
++ return NULL;
++ }
++ init_request(dev, DM_USERSPACE_SYNC_COMPLETE, req);
++
++ spin_lock_irqsave(&remap->lock, flags);
++ req->id = remap->id;
++ spin_unlock_irqrestore(&remap->lock, flags);
++
++ req->remap = remap;
++
++ return req;
++}
++
++static void endio_worker(void *data)
++{
++ struct dmu_map *remap = data;
++ struct userspace_request *req = NULL;
++
++ req = make_sync_req(remap->dev, remap);
++
++ if (req)
++ add_request(req->dev, req);
++}
++
++void init_remap(struct dmu_device *dev, struct dmu_map *remap)
++{
++ spin_lock_init(&remap->lock);
++ remap->org_block = remap->new_block = 0;
++ remap->offset = 0;
++ remap->flags = 0;
++ dmu_set_flag(&remap->flags, DMU_FLAG_INUSE);
++ remap->src = remap->dest = NULL;
++ bio_list_init(&remap->bios);
++ bio_list_init(&remap->bios_waiting);
++ INIT_LIST_HEAD(&remap->list);
++ remap->dev = dev;
++ remap->next = NULL;
++
++ INIT_WORK(&remap->endio_task, endio_worker, remap);
++}
++
++void init_request(struct dmu_device *dev,
++ int type,
++ struct userspace_request *req)
++{
++ spin_lock_init(&req->lock);
++ INIT_LIST_HEAD(&req->list);
++ req->dev = dev;
++ req->type = type;
++ req->sent = 0;
++ req->flags = 0;
++ if (type == DM_USERSPACE_SYNC_COMPLETE) {
++ req->u.block = 0;
++ req->id = 0;
++ } else {
++ spin_lock(&dev->lock);
++ dev->id_counter++;
++ if (dev->id_counter == 0)
++ dev->id_counter = 1;
++ req->id = dev->id_counter;
++ spin_unlock(&dev->lock);
++ }
++ atomic_set(&req->refcnt, 0);
++}
++
++/*
++ * For an even block distribution, this is not too bad, but it could
++ * probably be better
++ */
++static uint32_t ht_hash(struct hash_table *ht, uint64_t block)
++{
++ return (uint32_t)block & ht->mask;
++}
++
++static int ht_init(struct hash_table *ht, unsigned long size)
++{
++ uint64_t i;
++ unsigned long pages;
++ unsigned int order = ffs((size * sizeof(struct list_head *)) /
++ PAGE_SIZE);
++
++ if (order > 9)
++ return 0;
++
++ pages = __get_free_pages(GFP_ATOMIC, order);
++ if (!pages)
++ return 0;
++
++ ht->table = (void *)pages;
++ ht->size = size;
++ ht->count = 0;
++ ht->mask = size - 1;
++
++ for (i = 0; i < size; i++)
++ INIT_LIST_HEAD(&ht->table[i]);
++
++ return 1;
++}
++
++static void ht_insert_bucket(struct dmu_map *map, struct list_head *list)
++{
++ list_add_tail(&map->list, list);
++}
++
++/*
++ * I'm sure this is quite dumb, but it works for now
++ */
++static int ht_should_grow(struct hash_table *ht)
++{
++ return ht->count > (2 * (ht->size / 4));
++}
++
++static void ht_grow_table(struct hash_table *ht);
++void ht_insert_map(struct hash_table *ht, struct dmu_map *map)
++{
++ uint32_t addr;
++
++ addr = ht_hash(ht, map->org_block) & ht->mask;
++
++ BUG_ON(addr >= ht->size);
++
++ ht_insert_bucket(map, &ht->table[addr]);
++ ht->count++;
++
++ if (ht_should_grow(ht))
++ ht_grow_table(ht);
++}
++
++void ht_delete_map(struct hash_table *ht, struct dmu_map *map)
++{
++ list_del_init(&map->list);
++ BUG_ON(ht->count == 0);
++ ht->count--;
++}
++
++struct dmu_map *ht_find_map(struct hash_table *ht, uint64_t block)
++{
++ uint32_t addr;
++ struct dmu_map *m;
++
++ addr = ht_hash(ht, block) & ht->mask;
++
++ BUG_ON(addr >= ht->size);
++
++ list_for_each_entry(m, &ht->table[addr], list) {
++ if (m->org_block == block) {
++ remap_hit(m);
++ return m;
++ }
++ }
++
++ return NULL;
++}
++
++struct dmu_map *ht_find_map_dev(struct dmu_device *dev, uint64_t block)
++{
++ struct dmu_map *remap;
++
++ spin_lock(&dev->lock);
++
++ remap = ht_find_map(&dev->remaps, block);
++
++ spin_unlock(&dev->lock);
++
++ return remap;
++}
++
++static void ht_grow_table(struct hash_table *ht)
++{
++ struct hash_table old_table;
++ uint64_t i;
++
++ old_table = *ht;
++
++ if (!ht_init(ht, old_table.size * 2))
++ return;
++
++ for (i = 0; i < old_table.size; i++ ) {
++ struct dmu_map *m, *n;
++ list_for_each_entry_safe(m, n, &old_table.table[i],
++ list) {
++ list_del_init(&m->list);
++ ht_insert_map(ht, m);
++ }
++ }
++
++ free_pages((unsigned long)old_table.table,
++ ffs((old_table.size * sizeof(struct list_head *))
++ / PAGE_SIZE));
++}
++
++static uint64_t ht_destroy_table(struct hash_table *ht)
++{
++ uint64_t i, count = 0;
++ struct dmu_map *m, *n;
++
++ for (i = 0; i < ht->size; i++) {
++ list_for_each_entry_safe(m, n, &ht->table[i], list) {
++ ht_delete_map(ht, m);
++ free_remap(m);
++ count++;
++ }
++ }
++
++ free_pages((unsigned long)ht->table,
++ ffs((ht->size * sizeof(struct list_head *))
++ / PAGE_SIZE));
++
++ return count;
++}
++
++struct target_device *find_target(struct dmu_device *dev,
++ dev_t devno)
++{
++ struct target_device *target, *match = NULL;
++
++ spin_lock(&dev->lock);
++ list_for_each_entry(target, &dev->target_devs, list) {
++ if (target->bdev->bd_dev == devno) {
++ match = target;
++ break;
++ }
++ }
++ spin_unlock(&dev->lock);
++
++ return match;
++}
++
++static struct target_device *get_target(struct dmu_device *dev,
++ dev_t devno)
++{
++
++ struct target_device *target;
++ struct block_device *bdev;
++
++ target = find_target(dev, devno);
++ if (target)
++ return target;
++
++ bdev = open_by_devnum(devno, FMODE_READ | FMODE_WRITE);
++ if (IS_ERR(bdev)) {
++ DMERR("Unable to lookup device %x", devno);
++ return NULL;
++ }
++
++ target = kmalloc(sizeof(*target), GFP_KERNEL);
++ if (!target) {
++ DMERR("Unable to alloc new target device");
++ return NULL;
++ }
++
++ target->bdev = bdev;
++ INIT_LIST_HEAD(&target->list);
++
++ spin_lock(&dev->lock);
++ list_add_tail(&target->list, &dev->target_devs);
++ spin_unlock(&dev->lock);
++
++ return target;
++}
++
++/* Caller must hold dev->lock */
++static void put_target(struct dmu_device *dev,
++ struct target_device *target)
++{
++ list_del(&target->list);
++
++ bd_release(target->bdev);
++ blkdev_put(target->bdev);
++
++ kfree(target);
++}
++
++/*
++ * This periodically dumps out some debug information. It's really
++ * only useful while developing.
++ */
++static void watchdog(void *data)
++{
++ unsigned int v_remaps, i_remaps, reqs, s_reqs, devs = 0;
++ struct dmu_device *dev;
++ struct dmu_map *map;
++ struct userspace_request *req;
++ uint64_t i;
++
++ spin_lock(&devices_lock);
++
++ list_for_each_entry(dev, &devices, list) {
++ spin_lock(&dev->lock);
++
++ v_remaps = i_remaps = reqs = s_reqs = 0;
++
++ for (i = 0; i < dev->remaps.size; i++) {
++ list_for_each_entry(map, &dev->remaps.table[i], list)
++ if (dmu_get_flag(&map->flags, DMU_FLAG_VALID))
++ v_remaps++;
++ else
++ i_remaps++;
++ }
++
++ list_for_each_entry(req, &dev->requests, list)
++ if (req->sent)
++ s_reqs++;
++ else
++ reqs++;
++
++ printk("Device "
++ " reqs: %u/%u "
++ " inv maps: %u "
++ " val maps: %u\n",
++ reqs, s_reqs, i_remaps, v_remaps);
++ devs++;
++
++ spin_unlock(&dev->lock);
++ }
++
++ spin_unlock(&devices_lock);
++
++ schedule_delayed_work(&wd, HZ);
++}
++
++void destroy_dmu_device(struct kref *ref)
++{
++ struct dmu_device *dev;
++ struct list_head *cursor, *next;
++ uint64_t remaps;
++
++ dev = container_of(ref, struct dmu_device, users);
++
++ spin_lock(&devices_lock);
++ list_del(&dev->list);
++ spin_unlock(&devices_lock);
++
++ list_for_each_safe(cursor, next, &dev->target_devs) {
++ struct target_device *target;
++
++ target = list_entry(cursor,
++ struct target_device,
++ list);
++
++ put_target(dev, target);
++ }
++
++ remaps = ht_destroy_table(&dev->remaps);
++
++ list_for_each_safe(cursor, next, &dev->requests) {
++ struct userspace_request *req;
++
++ req = list_entry(cursor,
++ struct userspace_request,
++ list);
++
++ list_del(&req->list);
++
++ mempool_free(req, request_pool);
++ }
++
++ kcopyd_client_destroy(dev->kcopy);
++ unregister_chardev_transport(dev);
++
++ kfree(dev);
++}
++
++static int init_dmu_device(struct dmu_device *dev, u32 block_size)
++{
++ int ret;
++
++ init_waitqueue_head(&dev->wqueue);
++ INIT_LIST_HEAD(&dev->list);
++ INIT_LIST_HEAD(&dev->requests);
++ INIT_LIST_HEAD(&dev->target_devs);
++ kref_init(&dev->users);
++ spin_lock_init(&dev->lock);
++
++ dev->id_counter = 1; /* reserve 0 for unsolicited maps */
++
++ if (!ht_init(&dev->remaps, 2048)) {
++ DMERR("Unable to allocate hash table");
++ return 0;
++ }
++
++ dev->block_size = block_size;
++ dev->block_mask = block_size - 1;
++ dev->block_shift = ffs(block_size) - 1;
++
++ ret = kcopyd_client_create(DMU_COPY_PAGES, &dev->kcopy);
++ if (ret) {
++ DMERR("Failed to initialize kcopyd client");
++ return 0;
++ }
++
++ return 1;
++}
++
++static struct dmu_device *new_dmu_device(char *key,
++ struct dm_target *ti,
++ u32 block_size)
++{
++ struct dmu_device *dev;
++ int ret;
++
++ dev = kmalloc(sizeof(*dev), GFP_KERNEL);
++ if (dev == NULL) {
++ DMERR("Failed to allocate new userspace device");
++ return NULL;
++ }
++
++ if (!init_dmu_device(dev, block_size))
++ goto bad1;
++
++ snprintf(dev->key, DMU_KEY_LEN, "%s", key);
++
++ ret = register_chardev_transport(dev);
++ if (!ret)
++ goto bad2;
++
++ spin_lock(&devices_lock);
++ list_add(&dev->list, &devices);
++ spin_unlock(&devices_lock);
++
++ return dev;
++
++ bad2:
++ put_dev(dev);
++ bad1:
++ kfree(dev);
++ DMERR("Failed to create device");
++ return NULL;
++}
++
++static struct dmu_device *find_dmu_device(const char *key)
++{
++ struct dmu_device *dev;
++ struct dmu_device *match = NULL;
++
++ spin_lock(&devices_lock);
++
++ list_for_each_entry(dev, &devices, list) {
++ spin_lock(&dev->lock);
++ if (strncmp(dev->key, key, DMU_KEY_LEN) == 0) {
++ match = dev;
++ spin_unlock(&dev->lock);
++ break;
++ }
++ spin_unlock(&dev->lock);
++ }
++
++ spin_unlock(&devices_lock);
++
++ return match;
++}
++
++static int dmu_ctr(struct dm_target *ti, unsigned int argc, char **argv)
++{
++ uint64_t block_size;
++ struct dmu_device *dev;
++ char *device_key;
++ char *block_size_param;
++ int target_idx = 2;
++
++ if (argc < 3) {
++ ti->error = "Invalid argument count";
++ return -EINVAL;
++ }
++
++ device_key = argv[0];
++ block_size_param = argv[1];
++
++ block_size = simple_strtoul(block_size_param, NULL, 10) / 512;
++
++ dev = find_dmu_device(device_key);
++ if (dev == NULL) {
++ dev = new_dmu_device(device_key,
++ ti,
++ block_size);
++ if (dev == NULL) {
++ ti->error = "Failed to create device";
++ goto bad;
++ }
++ } else {
++ get_dev(dev);
++ }
++
++ spin_lock(&dev->lock);
++ if (dev->block_size != block_size) {
++ ti->error = "Invalid block size";
++ goto bad;
++ }
++ spin_unlock(&dev->lock);
++
++ /* Resolve target devices */
++ do {
++ int maj, min;
++ sscanf(argv[target_idx], "%i:%i", &maj, &min);
++ if (!get_target(dev, MKDEV(maj, min))) {
++ DMERR("Failed to find target device %i:%i (%s)",
++ maj, min, argv[target_idx]);
++ goto out;
++ }
++ } while (++target_idx < argc);
++
++ ti->private = dev;
++ ti->split_io = block_size;
++
++ return 0;
++
++ bad:
++ if (dev) {
++ spin_unlock(&dev->lock);
++ }
++ out:
++ if (dev) {
++ put_dev(dev);
++ }
++
++ return -EINVAL;
++}
++
++static void dmu_dtr(struct dm_target *ti)
++{
++ struct dmu_device *dev = (struct dmu_device *) ti->private;
++
++ put_dev(dev);
++}
++
++/* Search @dev for an outstanding request for remapping @block */
++static struct userspace_request *find_existing_req(struct dmu_device *dev,
++ uint64_t block)
++{
++ struct userspace_request *req;
++ struct userspace_request *match = NULL;
++
++ spin_lock(&dev->lock);
++
++ list_for_each_entry_reverse(req, &dev->requests, list) {
++ if ((req->type == DM_USERSPACE_MAP_BLOCK_REQ) &&
++ (req->remap->org_block == block)) {
++ match = req;
++ atomic_inc(&match->refcnt);
++ break;
++ }
++ }
++
++ spin_unlock(&dev->lock);
++
++ return match;
++}
++
++static int make_new_request(struct dmu_device *dev,
++ struct bio *bio,
++ void **ctxptr)
++{
++ struct userspace_request *req;
++
++ req = mempool_alloc(request_pool, GFP_NOIO);
++ if (req == NULL)
++ goto bad;
++
++ init_request(dev, DM_USERSPACE_MAP_BLOCK_REQ, req);
++
++ dmu_set_flag(&req->flags, DMU_FLAG_RD);
++ if (bio_rw(bio))
++ dmu_set_flag(&req->flags, DMU_FLAG_WR);
++ else
++ dmu_clr_flag(&req->flags, DMU_FLAG_WR);
++
++ req->remap = alloc_remap_atomic(dev);
++ if (!req->remap) {
++ DMERR("Failed to alloc remap!");
++ goto bad;
++ }
++ init_remap(dev, req->remap);
++
++ bio_list_add(&req->remap->bios, bio);
++ req->remap->org_block = dmu_block(dev, bio->bi_sector);
++
++ *ctxptr = req->remap;
++
++ add_request(dev, req);
++
++ return 0;
++
++ bad:
++ DMERR("Failed to queue bio!");
++ return -1;
++}
++
++static int dmu_map_remap_case(struct dmu_device *dev,
++ struct dmu_map *remap,
++ struct bio *bio)
++{
++ int ret = 0;
++ int rw;
++ unsigned long flags;
++
++ spin_lock_irqsave(&remap->lock, flags);
++
++ /*
++ * We've got it locked, so make sure the info is still valid
++ * before we use it
++ */
++ if (!dmu_get_flag(&remap->flags, DMU_FLAG_INUSE)) {
++ ret = -1;
++ DMERR("Got an invalid remap from hashtable");
++ goto unlock;
++ } else if (remap->org_block != dmu_block(dev, bio->bi_sector)) {
++ ret = -1;
++ DMERR("Aiee, org block changed underneath us!");
++ goto unlock;
++ }
++
++ rw = dmu_get_flag(&remap->flags, DMU_FLAG_WR);
++
++
++ if (rw || (bio_rw(bio) == rw)) {
++ if (dmu_get_flag(&remap->flags, DMU_FLAG_VALID)) {
++ __bio_remap(bio, remap);
++ ret = 1;
++ } else {
++ bio_list_add(&remap->bios, bio);
++ }
++ } else {
++ ret = -1;
++// printk("Remap doesn't match perms: %llu (%c!=%c)\n",
++// remap->org_block,
++// rw ? 'W':'R',
++// bio_rw(bio) ? 'W':'R');
++ }
++
++ unlock:
++ spin_unlock_irqrestore(&remap->lock, flags);
++
++ return ret;
++}
++
++static int dmu_map_request_case(struct dmu_device *dev,
++ struct userspace_request *req,
++ struct bio *bio)
++{
++ int ret = 0;
++ int req_rw = dmu_get_flag(&req->flags, DMU_FLAG_WR);
++ unsigned long flags;
++
++ spin_lock(&req->lock);
++ spin_lock_irqsave(&req->remap->lock, flags);
++
++ if (!req_rw && bio_rw(bio) && !req->sent) {
++ /* Convert to R/W and Queue */
++ dmu_set_flag(&req->flags, DMU_FLAG_WR);
++ bio_list_add(&req->remap->bios, bio);
++ } else if (!req_rw && bio_rw(bio) && req->sent) {
++ /* Can't convert, must re-request */
++ ret = -1;
++ } else {
++ /* Queue */
++ bio_list_add(&req->remap->bios, bio);
++ }
++
++ spin_unlock_irqrestore(&req->remap->lock, flags);
++ spin_unlock(&req->lock);
++
++ return ret;
++}
++
++DECLARE_MUTEX(map_mutex);
++
++static int dmu_map(struct dm_target *ti, struct bio *bio,
++ union map_info *map_context)
++{
++ struct dmu_device *dev = (struct dmu_device *) ti->private;
++ struct dmu_map *remap;
++ struct userspace_request *req;
++ int ret = 0;
++ u64 block;
++
++ down(&map_mutex);
++
++ map_context->ptr = NULL;
++
++ block = dmu_block(dev, bio->bi_sector);
++
++ remap = ht_find_map_dev(dev, block);
++ if (remap) {
++ ret = dmu_map_remap_case(dev, remap, bio);
++ if (ret >= 0) {
++ map_context->ptr = remap;
++ goto done;
++ }
++
++ }
++
++ req = find_existing_req(dev, block);
++ if (req) {
++ ret = dmu_map_request_case(dev, req, bio);
++ atomic_dec(&req->refcnt);
++ if (ret >= 0) {
++ map_context->ptr = req->remap;
++ goto done;
++ }
++ }
++
++ ret = make_new_request(dev, bio, &map_context->ptr);
++
++ done:
++ up(&map_mutex);
++
++ return ret;
++}
++
++static int dmu_status(struct dm_target *ti, status_type_t type,
++ char *result, unsigned int maxlen)
++{
++ struct dmu_device *dev = (struct dmu_device *) ti->private;
++
++ switch (type) {
++ case STATUSTYPE_INFO:
++ write_chardev_transport_info(dev, result, maxlen);
++ break;
++
++ case STATUSTYPE_TABLE:
++ snprintf(result, maxlen, "%s %llu",
++ dev->key,
++ dev->block_size * 512);
++ break;
++ }
++
++ return 0;
++}
++
++static int __handle_bio_endio(struct dmu_map *remap,
++ struct bio *bio,
++ struct userspace_request **req)
++{
++ int ret = 0;
++ unsigned long flags;
++
++ spin_lock_irqsave(&remap->lock, flags);
++ if (dmu_get_flag(&remap->flags, DMU_FLAG_WAITING) &&
++ remap->bios_waiting.head == NULL) {
++ /* First endio and waiting for resp from userspace */
++ bio_list_add(&remap->bios_waiting, bio);
++
++ /* Schedule request worker */
++ INIT_WORK(&remap->endio_task, endio_worker, remap);
++ schedule_work(&remap->endio_task);
++
++ ret = 1;
++ } else if (dmu_get_flag(&remap->flags, DMU_FLAG_WAITING)) {
++ /* Still waiting for resp from userspace */
++ bio_list_add(&remap->bios_waiting, bio);
++ ret = 1;
++ } else if (remap->bios_waiting.head != NULL) {
++ /* Got resp from userspace but bios waiting list nonempty */
++ if (bio == remap->bios_waiting.head) {
++ bio_list_pop(&remap->bios_waiting);
++ ret = 0;
++ } else {
++ bio_list_add(&remap->bios_waiting, bio);
++ ret = 1;
++ }
++ }
++ spin_unlock_irqrestore(&remap->lock, flags);
++
++ return ret;
++}
++
++static int dmu_end_io(struct dm_target *ti, struct bio *bio,
++ int error, union map_info *map_context)
++{
++ struct dmu_map *remap;
++ struct userspace_request *req = NULL;
++ int ret = 0;
++
++ remap = map_context->ptr;
++
++ if (error) {
++ DMERR("Error in dmu_end_io");
++ return -1;
++ } else if (!remap) {
++ return 0;
++ }
++
++ ret = __handle_bio_endio(remap, bio, &req);
++
++ return ret;
++}
++
++struct target_type userspace_target = {
++ .name = "userspace",
++ .version = {0, 1, 0},
++ .module = THIS_MODULE,
++ .ctr = dmu_ctr,
++ .dtr = dmu_dtr,
++ .map = dmu_map,
++ .status = dmu_status,
++ .end_io = dmu_end_io
++};
++
++static int destroy_mru_list(void)
++{
++ struct dmu_map *map, *next;
++ int count = 0;
++
++ spin_lock(&mru_list_lock);
++
++ list_for_each_entry_safe(map, next, &mru_list, mru_list) {
++ list_del(&map->mru_list);
++ kmem_cache_free(remap_cache, map);
++ count++;
++ }
++
++ spin_unlock(&mru_list_lock);
++
++ return count;
++}
++
++int __init dm_userspace_init(void)
++{
++ int i;
++ int r = dm_register_target(&userspace_target);
++ if (r < 0) {
++ DMERR("Register failed %d", r);
++ return 0;
++ }
++
++ spin_lock_init(&devices_lock);
++ spin_lock_init(&mru_list_lock);
++
++ if (enable_watchdog) {
++ INIT_WORK(&wd, watchdog, NULL);
++ schedule_delayed_work(&wd, HZ);
++ }
++
++ request_cache =
++ kmem_cache_create("dm-userspace-requests",
++ sizeof(struct userspace_request),
++ __alignof__ (struct userspace_request),
++ 0, NULL, NULL);
++ if (!request_cache) {
++ DMERR("Failed to allocate request cache");
++ goto bad;
++ }
++
++ remap_cache =
++ kmem_cache_create("dm-userspace-remaps",
++ sizeof(struct dmu_map),
++ __alignof__ (struct dmu_map),
++ 0, NULL, NULL);
++ if (!remap_cache) {
++ DMERR("Failed to allocate remap cache");
++ goto bad2;
++ }
++
++ request_pool = mempool_create(64,
++ mempool_alloc_slab, mempool_free_slab,
++ request_cache);
++ if (!request_pool) {
++ DMERR("Failed to allocate request pool");
++ goto bad3;
++ }
++
++ r = init_chardev_transport();
++ if (!r)
++ goto bad4;
++
++ for (i = 0; i < DMU_REMAP_RESERVE; i++) {
++ struct dmu_map *remap;
++
++ remap = alloc_remap_atomic(NULL);
++ if (!remap) {
++ DMERR("Failed to allocate %i/%i reserve remap",
++ i, DMU_REMAP_RESERVE);
++ goto bad5;
++ }
++ init_remap(NULL, remap);
++ remap_hit(remap);
++ }
++
++ return 1;
++
++ bad5:
++ destroy_mru_list();
++ bad4:
++ mempool_destroy(request_pool);
++ bad3:
++ kmem_cache_destroy(remap_cache);
++ bad2:
++ kmem_cache_destroy(request_cache);
++ bad:
++ dm_unregister_target(&userspace_target);
++
++ return 0;
++}
++
++void __exit dm_userspace_exit(void)
++{
++ int r;
++ struct list_head *cursor, *next;
++ struct dmu_device *dev;
++
++ if (enable_watchdog)
++ if (!cancel_delayed_work(&wd))
++ flush_scheduled_work();
++
++ spin_lock(&devices_lock);
++
++ list_for_each_safe(cursor, next, &devices) {
++ dev = list_entry(cursor, struct dmu_device, list);
++ list_del(cursor);
++ destroy_dmu_device(&dev->users);
++ DMERR("Destroying hanging device %s", dev->key);
++ }
++
++ spin_unlock(&devices_lock);
++
++ cleanup_chardev_transport();
++
++ r = destroy_mru_list();
++
++ mempool_destroy(request_pool);
++ kmem_cache_destroy(request_cache);
++ kmem_cache_destroy(remap_cache);
++
++ r = dm_unregister_target(&userspace_target);
++ if (r < 0)
++ DMERR("unregister failed %d", r);
++}
++
++module_init(dm_userspace_init);
++module_exit(dm_userspace_exit);
++
++module_param(enable_watchdog, int, S_IRUGO);
++
++MODULE_DESCRIPTION(DM_NAME " userspace target");
++MODULE_AUTHOR("Dan Smith");
++MODULE_LICENSE("GPL");
+diff -purN ../pristine-linux-2.6.16.13/drivers/md/dm-userspace-chardev.c
./drivers/md/dm-userspace-chardev.c
+--- ../pristine-linux-2.6.16.13/drivers/md/dm-userspace-chardev.c
1969-12-31 18:00:00.000000000 -0600
++++ ./drivers/md/dm-userspace-chardev.c 2006-08-16 18:48:18.000000000
-0500
+@@ -0,0 +1,900 @@
++/*
++ * Copyright (C) International Business Machines Corp., 2006
++ * Author: Dan Smith <danms@xxxxxxxxxx>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; under version 2 of the License.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ */
++
++#include <linux/spinlock.h>
++#include <linux/blkdev.h>
++#include <linux/mempool.h>
++#include <linux/dm-userspace.h>
++#include <linux/list.h>
++#include <linux/sched.h>
++#include <linux/wait.h>
++#include <linux/poll.h>
++#include <linux/fs.h>
++#include <linux/cdev.h>
++#include <asm/uaccess.h>
++
++#include "dm.h"
++#include "dm-bio-list.h"
++#include "kcopyd.h"
++#include "dm-user.h"
++
++#define DM_MSG_PREFIX "dm-userspace"
++
++/* This allows for a cleaner separation between the dm-userspace
++ * device-mapper target, and the userspace transport used. Right now,
++ * only a chardev transport exists, but it's possible that there could
++ * be more in the future
++ */
++struct chardev_transport {
++ struct cdev cdev;
++ dev_t ctl_dev;
++ struct dmu_device *parent;
++};
++
++static void remap_flusher(struct dmu_map *remap);
++
++static int have_pending_requests(struct dmu_device *dev)
++{
++ struct userspace_request *req;
++ int ret = 0;
++
++ /* FIXME: We could keep a count of how many waiting reqs
++ * there are, eliminating the need to count, and possibly the
++ * need to lock
++ */
++
++ spin_lock(&dev->lock);
++
++ list_for_each_entry(req, &dev->requests, list) {
++ if (!req->sent) {
++ ret = 1;
++ break;
++ }
++ }
++
++ spin_unlock(&dev->lock);
++
++ return ret;
++}
++
++static void copy_callback(int read_err,
++ unsigned int write_err,
++ void *data)
++{
++ remap_flusher((struct dmu_map *)data);
++}
++
++static void copy_block(struct dmu_map *remap)
++{
++ struct io_region src, dst;
++ struct kcopyd_client *client;
++ unsigned long flags;
++
++ spin_lock_irqsave(&remap->lock, flags);
++
++ src.bdev = remap->src->bdev;
++ src.sector = remap->org_block << remap->dev->block_shift;
++ src.count = remap->dev->block_size;
++
++ dst.bdev = remap->dest->bdev;
++ dst.sector = (remap->new_block << remap->dev->block_shift);
++ dst.sector += remap->offset;
++ dst.count = remap->dev->block_size;
++
++ client = remap->dev->kcopy;
++
++ spin_unlock_irqrestore(&remap->lock, flags);
++
++ kcopyd_copy(client, &src, 1, &dst, 0, copy_callback, remap);
++}
++
++static void copy_or_flush(struct dmu_map *remap)
++{
++ int copy;
++ unsigned long flags;
++
++ spin_lock_irqsave(&remap->lock, flags);
++ copy = dmu_get_flag(&remap->flags, DMU_FLAG_COPY_FIRST);
++ spin_unlock_irqrestore(&remap->lock, flags);
++
++ if (copy)
++ copy_block(remap);
++ else
++ remap_flusher(remap);
++}
++
++static struct bio *pop_and_remap(struct dmu_map *remap)
++{
++ struct bio *bio = NULL;
++ unsigned long flags;
++
++ spin_lock_irqsave(&remap->lock, flags);
++
++ bio = bio_list_pop(&remap->bios);
++ if (bio)
++ __bio_remap(bio, remap);
++ else {
++ /* If there are no more bios, we must set the VALID
++ * flag before we release the lock
++ */
++ dmu_set_flag(&remap->flags, DMU_FLAG_VALID);
++ }
++
++ spin_unlock_irqrestore(&remap->lock, flags);
++
++ return bio;
++}
++
++static void get_remap_attrs(struct dmu_map *remap,
++ int *temporary,
++ struct dmu_map **next)
++{
++ unsigned long flags;
++
++ spin_lock_irqsave(&remap->lock, flags);
++
++ *temporary = dmu_get_flag(&remap->flags, DMU_FLAG_TEMPORARY);
++ *next = remap->next;
++ remap->next = NULL;
++
++ spin_unlock_irqrestore(&remap->lock, flags);
++}
++
++static void remap_flusher(struct dmu_map *remap)
++{
++ struct bio *bio;
++ int temporary = 0;
++ struct dmu_map *next;
++
++ while (1) {
++
++ bio = pop_and_remap(remap);
++
++ if (bio)
++ generic_make_request(bio);
++ else
++ break;
++ }
++
++ get_remap_attrs(remap, &temporary, &next);
++
++ if (next)
++ copy_or_flush(next);
++
++ if (temporary) {
++ free_remap(remap);
++ }
++}
++
++static int send_userspace_message(uint8_t __user *buffer,
++ struct userspace_request *req)
++{
++ int ret = 0;
++ struct dmu_msg_header hdr;
++ union {
++ struct dmu_msg_map_request map_req;
++ struct dmu_msg_status status_req;
++ struct dmu_msg_version ver_req;
++ } msgs;
++
++ memset(&msgs, 0, sizeof(msgs));
++ spin_lock(&req->lock);
++
++ hdr.id = req->id;
++
++ switch (req->type) {
++ case DM_USERSPACE_GET_VERSION:
++ hdr.msg_type = req->type;
++ hdr.payload_len = sizeof(msgs.ver_req);
++ msgs.ver_req.kernel_ver =
++ userspace_target.version[0] << 16 |
++ userspace_target.version[1] << 8 |
++ userspace_target.version[2];
++
++ break;
++
++ case DM_USERSPACE_MAP_BLOCK_REQ:
++ hdr.msg_type = req->type;
++ hdr.payload_len = sizeof(msgs.map_req);
++ msgs.map_req.org_block =
++ dmu_block(req->dev, req->remap->bios.head->bi_sector);
++ dmu_cpy_flag(&msgs.map_req.flags, req->flags, DMU_FLAG_RD);
++ dmu_cpy_flag(&msgs.map_req.flags, req->flags, DMU_FLAG_WR);
++
++ break;
++
++ case DM_USERSPACE_SYNC_COMPLETE:
++ case DM_USERSPACE_INVAL_COMPLETE:
++ case DM_USERSPACE_INVAL_FAILED:
++ hdr.msg_type = DM_USERSPACE_STATUS;
++ hdr.payload_len = sizeof(msgs.status_req);
++ msgs.status_req.status = req->type;
++ msgs.status_req.id_of_op = req->id;
++
++ break;
++
++ default:
++ DMWARN("Unknown message type %i", req->type);
++ ret = 0;
++ }
++
++ spin_unlock(&req->lock);
++
++ if (copy_to_user(buffer, &hdr, sizeof(hdr)))
++ return -EFAULT;
++ if (copy_to_user(buffer + sizeof(hdr), &msgs, hdr.payload_len))
++ return -EFAULT;
++
++ ret = sizeof(hdr) + hdr.payload_len;
++
++ if ((req->type != DM_USERSPACE_MAP_BLOCK_REQ) &&
++ (req->type != DM_USERSPACE_SYNC_COMPLETE)) {
++ /* Only some requests get responses, so we take others
++ * off the request queue here
++ */
++ spin_lock(&req->dev->lock);
++ list_del(&req->list);
++ spin_unlock(&req->dev->lock);
++ mempool_free(req, request_pool);
++ }
++
++ return ret;
++}
++
++struct userspace_request *pluck_next_request(struct dmu_device *dev,
++ int size_available)
++{
++ struct userspace_request *req, *match = NULL;
++
++ spin_lock(&dev->lock);
++
++ list_for_each_entry(req, &dev->requests, list) {
++ spin_lock(&req->lock);
++ if (!req->sent) {
++ if (dmu_get_msg_len(req->type) < size_available) {
++ req->sent = 1;
++ match = req;
++ } else {
++ /* Must break here to preserve order */
++ spin_unlock(&req->lock);
++ break;
++ }
++ }
++ spin_unlock(&req->lock);
++
++ if (match)
++ break;
++ }
++
++ spin_unlock(&dev->lock);
++
++ return match;
++}
++
++ssize_t dmu_ctl_read(struct file *file, char __user *buffer,
++ size_t size, loff_t *offset)
++{
++
++ struct dmu_device *dev = (struct dmu_device *)file->private_data;
++ struct userspace_request *req = NULL;
++ int ret = 0, r;
++
++ if (!capable(CAP_SYS_ADMIN))
++ return -EACCES;
++
++ while (!have_pending_requests(dev)) {
++ if (file->f_flags & O_NONBLOCK) {
++ return 0;
++ }
++
++ if (wait_event_interruptible(dev->wqueue,
++ have_pending_requests(dev)))
++ return -ERESTARTSYS;
++ }
++
++ while(ret < size) {
++ req = pluck_next_request(dev, size - ret);
++ if (!req)
++ /* One or more of the following conditions is true:
++ * 1. No more requests available for sending
++ * 2. No more room in the outgoing buffer
++ */
++ break;
++
++ r = send_userspace_message((void *)(buffer + ret), req);
++ if (r == 0)
++ continue;
++ else if (r < 0)
++ return r;
++
++ ret += r;
++ }
++
++ return ret;
++}
++
++/*
++ * Returns:
++ * 1 if we're chained to our parent
++ * 0 if parent is valid and was removed
++ * -1 if we gave our bios to the invalid parent
++ */
++static int handle_parent_remap(struct dmu_map *parent,
++ struct dmu_map *remap,
++ struct dmu_msg_map_response *msg)
++{
++ int ret = 0;
++ int free_parent = 0;
++ unsigned long flags;
++
++ spin_lock_irqsave(&parent->lock, flags);
++
++ if (!dmu_get_flag(&parent->flags, DMU_FLAG_INUSE)) {
++ /* This is in the process of being destroyed,
++ * so we can't use it
++ */
++ goto end_parent;
++ }
++
++ if (!dmu_get_flag(&parent->flags, DMU_FLAG_VALID)) {
++ if (dmu_get_flag(&parent->flags, DMU_FLAG_WR) ==
++ dmu_get_flag(&msg->flags, DMU_FLAG_WR) &&
++ (parent->new_block == msg->new_block)) {
++ /* Perms match for this not-yet-valid remap,
++ so tag our bios on to it and bail */
++ bio_list_merge(&parent->bios, &remap->bios);
++ bio_list_init(&remap->bios);
++ ret = -1;
++ } else {
++ /* Remove parent from remap table, and
++ * chain our new remap to this one so
++ * it will fire when parent goes
++ * valid
++ */
++ list_del_init(&parent->list);
++ if (parent->next) {
++ DMERR("Parent already chained!");
++ BUG();
++ }
++ parent->next = remap;
++ dmu_set_flag(&parent->flags, DMU_FLAG_TEMPORARY);
++ ret = 1;
++ }
++ } else {
++ /* Remove existing valid remap */
++ free_parent = 1;
++ }
++
++ end_parent:
++ if (free_parent)
++ __free_remap(parent);
++
++ spin_unlock_irqrestore(&parent->lock, flags);
++
++ return ret;
++}
++
++static int remap_request(struct dmu_msg_map_response *msg,
++ struct dmu_device *dev, uint32_t id)
++{
++ struct dmu_map *remap = NULL, *parent = NULL;
++ struct target_device *s_dev = NULL, *d_dev = NULL;
++ int is_chained = 0;
++ struct userspace_request *cursor, *next, *req = NULL;
++
++ /* See if we have a pending request that matches */
++ spin_lock(&dev->lock);
++ list_for_each_entry_safe(cursor, next, &dev->requests, list) {
++ if ((cursor->type == DM_USERSPACE_MAP_BLOCK_REQ) &&
++ (cursor->id == msg->id_of_req)) {
++ req = cursor;
++ list_del(&req->list);
++ break;
++ }
++ }
++ spin_unlock(&dev->lock);
++
++ if (dmu_get_flag(&msg->flags, DMU_FLAG_COPY_FIRST)) {
++ s_dev = find_target(dev, MKDEV(msg->src_maj, msg->src_min));
++ if (!s_dev) {
++ DMERR("Failed to find src device %i:%i",
++ msg->src_maj, msg->src_min);
++ goto bad;
++ }
++ }
++
++ d_dev = find_target(dev, MKDEV(msg->dst_maj, msg->dst_min));
++ if (!d_dev) {
++ DMERR("Failed to find dest device %i:%i",
++ msg->dst_maj, msg->dst_min);
++ goto bad;
++ }
++
++ if (req) {
++ while (atomic_read(&req->refcnt) != 0)
++ /* Wait for exclusive use of request. Even
++ * though we have removed it from the list,
++ * someone still has a pointer to it, which
++ * means we must wait for them to finish with
++ * it before continuing.
++ */
++ schedule();
++ remap = req->remap;
++ mempool_free(req, request_pool);
++ } else {
++ /* Allocate a new remap early (before grabbing locks),
++ * since we will most likely need it, and we didn't
++ * get one with the request
++ */
++ /* FIXME */
++ remap = alloc_remap_atomic(dev);
++ if (!remap) {
++ DMERR("Failed to alloc remap!");
++ goto bad;
++ }
++ init_remap(dev, remap);
++ }
++
++ spin_lock(&dev->lock);
++
++ /* FIXME: Now that we pass the remap with the req, do we need
++ IRQs disabled here? */
++ spin_lock(&remap->lock);
++ remap->org_block = msg->org_block;
++
++ /* Now, we insert the new remap into the table, and remove the
++ * existing map, if present, all while the device is locked
++ */
++
++ parent = ht_find_map(&dev->remaps, msg->org_block);
++ if (parent) {
++ is_chained = handle_parent_remap(parent, remap, msg);
++ if (is_chained < 0) {
++ __free_remap(remap);
++ spin_unlock(&remap->lock);
++ spin_unlock(&dev->lock);
++ return 1;
++ }
++ }
++
++ if (dmu_get_flag(&msg->flags, DMU_FLAG_SYNC))
++ dmu_set_flag(&remap->flags, DMU_FLAG_WAITING);
++
++ remap->new_block = msg->new_block;
++ remap->offset = msg->offset;
++ remap->src = s_dev;
++ remap->dest = d_dev;
++ remap->dev = dev;
++ remap->id = id;
++
++ dmu_cpy_flag(&remap->flags, msg->flags, DMU_FLAG_COPY_FIRST);
++ dmu_cpy_flag(&remap->flags, msg->flags, DMU_FLAG_TEMPORARY);
++ dmu_cpy_flag(&remap->flags, msg->flags, DMU_FLAG_SYNC);
++ dmu_cpy_flag(&remap->flags, msg->flags, DMU_FLAG_WR);
++ dmu_cpy_flag(&remap->flags, msg->flags, DMU_FLAG_RD);
++ dmu_clr_flag(&remap->flags, DMU_FLAG_VALID);
++
++ spin_unlock(&remap->lock);
++
++ ht_insert_map(&dev->remaps, remap);
++
++ spin_unlock(&dev->lock);
++
++ if (! is_chained)
++ copy_or_flush(remap);
++
++ return 1;
++
++ bad:
++ DMERR("Remap error: chaos may ensue");
++
++ return 0;
++}
++
++/*
++ * Adds the request to the front of the queue so it's picked up first
++ */
++static void add_urgent_request(struct dmu_device *dev,
++ struct userspace_request *req)
++{
++ spin_lock(&dev->lock);
++ list_add(&req->list, &dev->requests);
++ spin_unlock(&dev->lock);
++
++ wake_up(&dev->wqueue);
++}
++
++static int version_request(struct dmu_msg_version *msg,
++ struct dmu_device *dev, uint32_t id)
++{
++ struct userspace_request *req;
++
++ req = mempool_alloc(request_pool, GFP_NOIO);
++ if (!req) {
++ DMERR("Failed to alloc version response");
++ return 0;
++ }
++
++ init_request(dev, DM_USERSPACE_GET_VERSION, req);
++ add_urgent_request(dev, req);
++
++ return 1;
++}
++
++static int invalidate_request(struct dmu_msg_invalidate_map *msg,
++ struct dmu_device *dev, uint32_t id)
++{
++ struct dmu_map *remap;
++ struct userspace_request *req;
++ int ret = 1;
++ unsigned long flags;
++
++ remap = ht_find_map_dev(dev, msg->org_block);
++ if (!remap)
++ ret = 0;
++ else {
++ spin_lock(&dev->lock);
++ spin_lock_irqsave(&remap->lock, flags);
++ if (dmu_get_flag(&remap->flags, DMU_FLAG_VALID))
++ ht_delete_map(&dev->remaps, remap);
++ else
++ ret = 0;
++ spin_unlock_irqrestore(&remap->lock, flags);
++ spin_unlock(&dev->lock);
++ }
++
++ req = mempool_alloc(request_pool, GFP_NOIO);
++ if (!req) {
++ DMERR("Failed to allocate request");
++ return 0;
++ }
++
++ if (ret)
++ init_request(dev, DM_USERSPACE_INVAL_COMPLETE, req);
++ else
++ init_request(dev, DM_USERSPACE_INVAL_FAILED, req);
++
++ req->u.block = msg->org_block;
++ req->id = id;
++
++ add_request(dev, req);
++
++ return ret;
++}
++
++static void sync_complete(struct dmu_device *dev, uint32_t id_of_op) {
++ struct dmu_map *remap = NULL;
++ struct bio *bio;
++ struct userspace_request *req, *next;
++ unsigned long flags;
++
++ spin_lock(&dev->lock);
++ list_for_each_entry_safe(req, next, &dev->requests, list) {
++ if (req->id == id_of_op) {
++ list_del(&req->list);
++ break;
++ }
++ }
++ spin_unlock(&dev->lock);
++
++ if (!req) {
++ DMERR("Unable to complete unknown request: %u\n",
++ id_of_op);
++ return;
++ }
++
++ while (atomic_read(&req->refcnt) != 0)
++ /* Wait for exclusive use of request. Even
++ * though we have removed it from the list,
++ * someone still has a pointer to it, which
++ * means we must wait for them to finish with
++ * it before continuing.
++ */
++ schedule();
++
++ remap = req->remap;
++ mempool_free(req, request_pool);
++
++ if (remap) {
++ spin_lock_irqsave(&remap->lock, flags);
++ dmu_clr_flag(&remap->flags, DMU_FLAG_WAITING);
++ spin_unlock_irqrestore(&remap->lock, flags);
++ while(1) {
++ spin_lock_irqsave(&remap->lock, flags);
++ bio = remap->bios_waiting.head;
++ spin_unlock_irqrestore(&remap->lock, flags);
++ if (!bio)
++ break;
++ bio->bi_end_io(bio, 0, 0);
++ }
++ } else {
++ DMERR("Unable to complete empty request: %u\n",
++ id_of_op);
++ }
++}
++
++ssize_t dmu_ctl_write(struct file *file, const char __user *buffer,
++ size_t size, loff_t *offset)
++{
++ struct dmu_device *dev = (struct dmu_device *)file->private_data;
++ int ret = 0;
++ struct dmu_msg_header hdr;
++ union {
++ struct dmu_msg_map_response map_rsp;
++ struct dmu_msg_invalidate_map inval_rsp;
++ struct dmu_msg_version ver_req;
++ struct dmu_msg_status status_rsp;
++ } msgs;
++
++ if (!capable(CAP_SYS_ADMIN))
++ return -EACCES;
++
++ while ((ret + sizeof(hdr)) < size) {
++ if (copy_from_user(&hdr, buffer+ret, sizeof(hdr))) {
++ DMERR("%s copy_from_user failed!", __FUNCTION__);
++ ret = -EFAULT;
++ goto out;
++ }
++
++ ret += sizeof(hdr);
++
++ switch (hdr.msg_type) {
++
++ case DM_USERSPACE_GET_VERSION:
++ if (hdr.payload_len != sizeof(msgs.ver_req)) {
++ DMERR("Malformed version request");
++ break;
++ }
++
++ if (copy_from_user(&msgs.ver_req, buffer+ret,
++ sizeof(msgs.ver_req))) {
++ DMERR("%s copy_from_user failed!",
++ __FUNCTION__);
++ ret = -EFAULT;
++ goto out;
++ }
++
++ version_request(&msgs.ver_req, dev, hdr.id);
++ break;
++
++ case DM_USERSPACE_MAP_BLOCK_RESP:
++ if (hdr.payload_len != sizeof(msgs.map_rsp)) {
++ DMERR("Malformed block response");
++ break;
++ }
++
++ if (copy_from_user(&msgs.map_rsp, buffer+ret,
++ sizeof(msgs.map_rsp))) {
++ DMERR("%s copy_from_user failed!",
++ __FUNCTION__);
++ ret = -EFAULT;
++ goto out;
++ }
++
++ remap_request(&msgs.map_rsp, dev,
++ msgs.map_rsp.id_of_req);
++ break;
++
++ case DM_USERSPACE_MAP_FAILED:
++ if (hdr.payload_len != sizeof(msgs.map_rsp)) {
++ DMERR("Malformed block failed response");
++ break;
++ }
++
++ if (copy_from_user(&msgs.map_rsp, buffer+ret,
++ sizeof(msgs.map_rsp))) {
++ DMERR("%s copy_from_user failed",
++ __FUNCTION__);
++ ret = -EFAULT;
++ goto out;
++ }
++
++ DMERR("Userspace map failed");
++ break;
++
++ case DM_USERSPACE_MAP_INVALIDATE:
++ if (hdr.payload_len != sizeof(msgs.inval_rsp)) {
++ DMERR("Malformed invalidate request");
++ break;
++ }
++
++ if (copy_from_user(&msgs.inval_rsp, buffer+ret,
++ sizeof(msgs.inval_rsp))) {
++ DMERR("%s copy_from_user failed",
++ __FUNCTION__);
++ ret = -EFAULT;
++ goto out;
++ }
++
++ invalidate_request(&msgs.inval_rsp, dev, hdr.id);
++ break;
++
++ case DM_USERSPACE_STATUS:
++ if (hdr.payload_len != sizeof(msgs.status_rsp)) {
++ DMERR("Malformed invalidate request");
++ break;
++ }
++
++ if (copy_from_user(&msgs.status_rsp, buffer+ret,
++ sizeof(msgs.status_rsp))) {
++ DMERR("%s copy_from_user failed",
++ __FUNCTION__);
++ ret = -EFAULT;
++ goto out;
++ }
++
++ if (msgs.status_rsp.status ==
++ DM_USERSPACE_SYNC_COMPLETE) {
++ /* FIXME: check req */
++ sync_complete(dev, msgs.status_rsp.id_of_op);
++ }
++ break;
++
++ default:
++ DMWARN("Unknown request type: %i", hdr.msg_type);
++ }
++
++ ret += hdr.payload_len;
++ }
++ out:
++ return ret;
++}
++
++int dmu_ctl_open(struct inode *inode, struct file *file)
++{
++ struct chardev_transport *t;
++ struct dmu_device *dev;
++
++ if (!capable(CAP_SYS_ADMIN))
++ return -EACCES;
++
++ t = container_of(inode->i_cdev, struct chardev_transport, cdev);
++ dev = t->parent;
++
++ get_dev(dev);
++
++ file->private_data = dev;
++
++ return 0;
++}
++
++int dmu_ctl_release(struct inode *inode, struct file *file)
++{
++ struct dmu_device *dev;
++
++ dev = (struct dmu_device *)file->private_data;
++
++ put_dev(dev);
++
++ return 0;
++}
++
++unsigned dmu_ctl_poll(struct file *file, poll_table *wait)
++{
++ struct dmu_device *dev = (struct dmu_device *)file->private_data;
++ unsigned mask = 0;
++
++ poll_wait(file, &dev->wqueue, wait);
++
++ if (have_pending_requests(dev))
++ mask |= POLLIN | POLLRDNORM;
++
++ return mask;
++}
++
++static struct file_operations ctl_fops = {
++ .open = dmu_ctl_open,
++ .release = dmu_ctl_release,
++ .read = dmu_ctl_read,
++ .write = dmu_ctl_write,
++ .poll = dmu_ctl_poll,
++ .owner = THIS_MODULE,
++};
++
++static int get_free_minor(void)
++{
++ struct dmu_device *dev;
++ int minor = 0;
++
++ spin_lock(&devices_lock);
++
++ while (1) {
++ list_for_each_entry(dev, &devices, list) {
++ struct chardev_transport *t = dev->transport_private;
++ if (MINOR(t->ctl_dev) == minor)
++ goto dupe;
++ }
++ break;
++ dupe:
++ minor++;
++ }
++
++ spin_unlock(&devices_lock);
++
++ return minor;
++}
++
++int register_chardev_transport(struct dmu_device *dev)
++{
++ struct chardev_transport *t;
++ int ret;
++
++ dev->transport_private = kmalloc(sizeof(struct chardev_transport),
++ GFP_KERNEL);
++ t = dev->transport_private;
++
++ if (!t) {
++ DMERR("Failed to allocate chardev transport");
++ goto bad;
++ }
++
++ t->ctl_dev = MKDEV(MAJOR(dmu_dev), get_free_minor());
++ t->parent = dev;
++
++ cdev_init(&t->cdev, &ctl_fops);
++ t->cdev.owner = THIS_MODULE;
++ t->cdev.ops = &ctl_fops;
++
++ ret = cdev_add(&t->cdev, t->ctl_dev, 1);
++ if (ret < 0) {
++ DMERR("Failed to register control device %d:%d",
++ MAJOR(t->ctl_dev), MINOR(t->ctl_dev));
++ goto bad;
++ }
++
++ return 1;
++
++ bad:
++ kfree(t);
++ return 0;
++}
++
++void unregister_chardev_transport(struct dmu_device *dev)
++{
++ struct chardev_transport *t = dev->transport_private;
++
++ cdev_del(&t->cdev);
++ kfree(t);
++}
++
++int init_chardev_transport(void)
++{
++ int r;
++
++ r = alloc_chrdev_region(&dmu_dev, 0, 10, "dm-userspace");
++ if (r) {
++ DMERR("Failed to allocate chardev region");
++ return 0;
++ } else
++ return 1;
++}
++
++void cleanup_chardev_transport(void)
++{
++ unregister_chrdev_region(dmu_dev, 10);
++}
++
++void write_chardev_transport_info(struct dmu_device *dev,
++ char *buf, unsigned int maxlen)
++{
++ struct chardev_transport *t = dev->transport_private;
++
++ snprintf(buf, maxlen, "%x:%x",
++ MAJOR(t->ctl_dev), MINOR(t->ctl_dev));
++}
+diff -purN ../pristine-linux-2.6.16.13/drivers/md/dm-userspace.h
./drivers/md/dm-userspace.h
+--- ../pristine-linux-2.6.16.13/drivers/md/dm-userspace.h 1969-12-31
18:00:00.000000000 -0600
++++ ./drivers/md/dm-userspace.h 2006-08-16 18:48:18.000000000 -0500
+@@ -0,0 +1,147 @@
++/*
++ * Copyright (C) International Business Machines Corp., 2006
++ * Author: Dan Smith <danms@xxxxxxxxxx>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; under version 2 of the License.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ */
++
++#ifndef __DM_USERSPACE_H
++#define __DM_USERSPACE_H
++
++#include <linux/types.h>
++
++/*
++ * Message Types
++ */
++#define DM_USERSPACE_GET_VERSION 1
++#define DM_USERSPACE_MAP_BLOCK_REQ 2
++#define DM_USERSPACE_MAP_BLOCK_RESP 3
++#define DM_USERSPACE_MAP_FAILED 4
++#define DM_USERSPACE_MAP_INVALIDATE 5
++#define DM_USERSPACE_STATUS 6
++
++/*
++ * Status codes
++ */
++#define DM_USERSPACE_INVAL_COMPLETE 101
++#define DM_USERSPACE_INVAL_FAILED 102
++#define DM_USERSPACE_SYNC_COMPLETE 103
++
++/*
++ * Flags and associated macros
++ */
++#define DMU_FLAG_VALID 1
++#define DMU_FLAG_RD 2
++#define DMU_FLAG_WR 4
++#define DMU_FLAG_COPY_FIRST 8
++#define DMU_FLAG_TEMPORARY 16
++#define DMU_FLAG_INUSE 32
++#define DMU_FLAG_SYNC 64
++#define DMU_FLAG_WAITING 128
++
++static int dmu_get_flag(uint32_t *flags, uint32_t flag)
++{
++ return (*flags & flag) != 0;
++}
++
++static void dmu_set_flag(uint32_t *flags, uint32_t flag)
++{
++ *flags |= flag;
++}
++
++static void dmu_clr_flag(uint32_t *flags, uint32_t flag)
++{
++ *flags &= (~flag);
++}
++
++static void dmu_cpy_flag(uint32_t *flags, uint32_t src, uint32_t flag)
++{
++ *flags = (*flags & ~flag) | (src & flag);
++}
++
++/*
++ * This message header is sent in front of every message, in both
++ * directions
++ */
++struct dmu_msg_header {
++ uint32_t msg_type;
++ uint32_t payload_len;
++ uint32_t id;
++};
++
++/* DM_USERSPACE_GET_VERSION */
++struct dmu_msg_version {
++ uint32_t userspace_ver;
++ uint32_t kernel_ver;
++};
++
++/* For status codes */
++struct dmu_msg_status {
++ uint32_t id_of_op;
++ uint32_t status;
++};
++
++/* DM_USERSPACE_MAP_BLOCK_REQ */
++struct dmu_msg_map_request {
++ uint64_t org_block;
++
++ uint32_t flags;
++};
++
++/* DM_USERSPACE_MAP_BLOCK_RESP
++ * DM_USERSPACE_MAP_BLOCK_FAILED
++ */
++struct dmu_msg_map_response {
++ uint64_t org_block;
++ uint64_t new_block;
++ int64_t offset;
++
++ uint32_t id_of_req;
++ uint32_t flags;
++
++ uint32_t src_maj;
++ uint32_t src_min;
++
++ uint32_t dst_maj;
++ uint32_t dst_min;
++};
++
++/* DM_USERSPACE_MAP_INVALIDATE */
++struct dmu_msg_invalidate_map {
++ uint64_t org_block;
++};
++
++static inline int dmu_get_msg_len(int type)
++{
++ switch (type) {
++ case DM_USERSPACE_GET_VERSION:
++ return sizeof(struct dmu_msg_version);
++ case DM_USERSPACE_INVAL_COMPLETE:
++ case DM_USERSPACE_INVAL_FAILED:
++ case DM_USERSPACE_STATUS:
++ return sizeof(struct dmu_msg_status);
++ case DM_USERSPACE_MAP_BLOCK_REQ:
++ return sizeof(struct dmu_msg_map_request);
++ case DM_USERSPACE_MAP_BLOCK_RESP:
++ case DM_USERSPACE_MAP_FAILED:
++ return sizeof(struct dmu_msg_map_response);
++ case DM_USERSPACE_MAP_INVALIDATE:
++ return sizeof(struct dmu_msg_invalidate_map);
++ default:
++ return -1;
++ };
++}
++
++#endif
+diff -purN ../pristine-linux-2.6.16.13/drivers/md/Kconfig ./drivers/md/Kconfig
+--- ../pristine-linux-2.6.16.13/drivers/md/Kconfig 2006-05-02
16:38:44.000000000 -0500
++++ ./drivers/md/Kconfig 2006-08-16 18:48:18.000000000 -0500
+@@ -210,6 +210,12 @@ config DM_SNAPSHOT
+ ---help---
+ Allow volume managers to take writeable snapshots of a device.
+
++config DM_USERSPACE
++ tristate "Userspace target (EXPERIMENTAL)"
++ depends on BLK_DEV_DM && EXPERIMENTAL
++ ---help---
++ A target that provides a userspace interface to device-mapper
++
+ config DM_MIRROR
+ tristate "Mirror target (EXPERIMENTAL)"
+ depends on BLK_DEV_DM && EXPERIMENTAL
+diff -purN ../pristine-linux-2.6.16.13/drivers/md/Makefile
./drivers/md/Makefile
+--- ../pristine-linux-2.6.16.13/drivers/md/Makefile 2006-05-02
16:38:44.000000000 -0500
++++ ./drivers/md/Makefile 2006-08-16 18:48:18.000000000 -0500
+@@ -14,6 +14,7 @@ raid6-objs := raid6main.o raid6algos.o r
+ raid6altivec1.o raid6altivec2.o raid6altivec4.o \
+ raid6altivec8.o \
+ raid6mmx.o raid6sse1.o raid6sse2.o
++dm-user-objs := dm-userspace.o dm-userspace-chardev.o
+ hostprogs-y := mktables
+
+ # Note: link order is important. All raid personalities
+@@ -37,6 +38,7 @@ obj-$(CONFIG_DM_MULTIPATH_EMC) += dm-emc
+ obj-$(CONFIG_DM_SNAPSHOT) += dm-snapshot.o
+ obj-$(CONFIG_DM_MIRROR) += dm-mirror.o
+ obj-$(CONFIG_DM_ZERO) += dm-zero.o
++obj-$(CONFIG_DM_USERSPACE) += dm-user.o
+
+ quiet_cmd_unroll = UNROLL $@
+ cmd_unroll = $(PERL) $(srctree)/$(src)/unroll.pl $(UNROLL) \
+diff -purN ../pristine-linux-2.6.16.13/include/linux/dm-userspace.h
./include/linux/dm-userspace.h
+--- ../pristine-linux-2.6.16.13/include/linux/dm-userspace.h 1969-12-31
18:00:00.000000000 -0600
++++ ./include/linux/dm-userspace.h 2006-08-16 18:48:28.000000000 -0500
+@@ -0,0 +1,147 @@
++/*
++ * Copyright (C) International Business Machines Corp., 2006
++ * Author: Dan Smith <danms@xxxxxxxxxx>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; under version 2 of the License.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ */
++
++#ifndef __DM_USERSPACE_H
++#define __DM_USERSPACE_H
++
++#include <linux/types.h>
++
++/*
++ * Message Types
++ */
++#define DM_USERSPACE_GET_VERSION 1
++#define DM_USERSPACE_MAP_BLOCK_REQ 2
++#define DM_USERSPACE_MAP_BLOCK_RESP 3
++#define DM_USERSPACE_MAP_FAILED 4
++#define DM_USERSPACE_MAP_INVALIDATE 5
++#define DM_USERSPACE_STATUS 6
++
++/*
++ * Status codes
++ */
++#define DM_USERSPACE_INVAL_COMPLETE 101
++#define DM_USERSPACE_INVAL_FAILED 102
++#define DM_USERSPACE_SYNC_COMPLETE 103
++
++/*
++ * Flags and associated macros
++ */
++#define DMU_FLAG_VALID 1
++#define DMU_FLAG_RD 2
++#define DMU_FLAG_WR 4
++#define DMU_FLAG_COPY_FIRST 8
++#define DMU_FLAG_TEMPORARY 16
++#define DMU_FLAG_INUSE 32
++#define DMU_FLAG_SYNC 64
++#define DMU_FLAG_WAITING 128
++
++static int dmu_get_flag(uint32_t *flags, uint32_t flag)
++{
++ return (*flags & flag) != 0;
++}
++
++static void dmu_set_flag(uint32_t *flags, uint32_t flag)
++{
++ *flags |= flag;
++}
++
++static void dmu_clr_flag(uint32_t *flags, uint32_t flag)
++{
++ *flags &= (~flag);
++}
++
++static void dmu_cpy_flag(uint32_t *flags, uint32_t src, uint32_t flag)
++{
++ *flags = (*flags & ~flag) | (src & flag);
++}
++
++/*
++ * This message header is sent in front of every message, in both
++ * directions
++ */
++struct dmu_msg_header {
++ uint32_t msg_type;
++ uint32_t payload_len;
++ uint32_t id;
++};
++
++/* DM_USERSPACE_GET_VERSION */
++struct dmu_msg_version {
++ uint32_t userspace_ver;
++ uint32_t kernel_ver;
++};
++
++/* For status codes */
++struct dmu_msg_status {
++ uint32_t id_of_op;
++ uint32_t status;
++};
++
++/* DM_USERSPACE_MAP_BLOCK_REQ */
++struct dmu_msg_map_request {
++ uint64_t org_block;
++
++ uint32_t flags;
++};
++
++/* DM_USERSPACE_MAP_BLOCK_RESP
++ * DM_USERSPACE_MAP_BLOCK_FAILED
++ */
++struct dmu_msg_map_response {
++ uint64_t org_block;
++ uint64_t new_block;
++ int64_t offset;
++
++ uint32_t id_of_req;
++ uint32_t flags;
++
++ uint32_t src_maj;
++ uint32_t src_min;
++
++ uint32_t dst_maj;
++ uint32_t dst_min;
++};
++
++/* DM_USERSPACE_MAP_INVALIDATE */
++struct dmu_msg_invalidate_map {
++ uint64_t org_block;
++};
++
++static inline int dmu_get_msg_len(int type)
++{
++ switch (type) {
++ case DM_USERSPACE_GET_VERSION:
++ return sizeof(struct dmu_msg_version);
++ case DM_USERSPACE_INVAL_COMPLETE:
++ case DM_USERSPACE_INVAL_FAILED:
++ case DM_USERSPACE_STATUS:
++ return sizeof(struct dmu_msg_status);
++ case DM_USERSPACE_MAP_BLOCK_REQ:
++ return sizeof(struct dmu_msg_map_request);
++ case DM_USERSPACE_MAP_BLOCK_RESP:
++ case DM_USERSPACE_MAP_FAILED:
++ return sizeof(struct dmu_msg_map_response);
++ case DM_USERSPACE_MAP_INVALIDATE:
++ return sizeof(struct dmu_msg_invalidate_map);
++ default:
++ return -1;
++ };
++}
++
++#endif
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel
|
Home