Staging: dst: core files.

This patch contains DST core files, which introduce
block layer, connector and sysfs registration glue and main headers.

Connector is used for the configuration of the node (its type, address,
device name and so on). Sysfs provides bits of information about running
devices in the following format:

+/*
+ * DST sysfs tree for device called 'storage':
+ *
+ * /sys/bus/dst/devices/storage/
+ * /sys/bus/dst/devices/storage/type : 192.168.4.80:1025
+ * /sys/bus/dst/devices/storage/size : 800
+ * /sys/bus/dst/devices/storage/name : storage
+ */

DST header contains structure definitions and protocol command description.

Signed-off-by: Evgeniy Polyakov <zbr@ioremap.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

3 files changed, 1562 insertions, 1 deletions

diff --git a/drivers/staging/dst/dcore.c b/drivers/staging/dst/dcore.c
new file mode 100644
index 000000000000..c6e3cd1a5051
--- /dev/null
+++ b/drivers/staging/dst/dcore.c
@@ -0,0 +1,972 @@
+/*
+ * 2007+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
+ * All rights reserved.
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/blkdev.h>
+#include <linux/bio.h>
+#include <linux/buffer_head.h>
+#include <linux/connector.h>
+#include <linux/dst.h>
+#include <linux/device.h>
+#include <linux/jhash.h>
+#include <linux/idr.h>
+#include <linux/init.h>
+#include <linux/namei.h>
+#include <linux/slab.h>
+#include <linux/socket.h>
+
+#include <linux/in.h>
+#include <linux/in6.h>
+
+#include <net/sock.h>
+
+static int dst_major;
+
+static DEFINE_MUTEX(dst_hash_lock);
+static struct list_head *dst_hashtable;
+static unsigned int dst_hashtable_size = 128;
+module_param(dst_hashtable_size, uint, 0644);
+
+static char dst_name[] = "Dementianting goldfish";
+
+static DEFINE_IDR(dst_index_idr);
+static struct cb_id cn_dst_id = { CN_DST_IDX, CN_DST_VAL };
+
+/*
+ * DST sysfs tree for device called 'storage':
+ *
+ * /sys/bus/dst/devices/storage/
+ * /sys/bus/dst/devices/storage/type : 192.168.4.80:1025
+ * /sys/bus/dst/devices/storage/size : 800
+ * /sys/bus/dst/devices/storage/name : storage
+ */
+
+static int dst_dev_match(struct device *dev, struct device_driver *drv)
+{
+        return 1;
+}
+
+static struct bus_type dst_dev_bus_type = {
+        .name           = "dst",
+        .match          = &dst_dev_match,
+};
+
+static void dst_node_release(struct device *dev)
+{
+        struct dst_info *info = container_of(dev, struct dst_info, device);
+
+        kfree(info);
+}
+
+static struct device dst_node_dev = {
+        .bus            = &dst_dev_bus_type,
+        .release        = &dst_node_release
+};
+
+/*
+ * Setting size of the node after it was changed.
+ */
+static void dst_node_set_size(struct dst_node *n)
+{
+        struct block_device *bdev;
+
+        set_capacity(n->disk, n->size >> 9);
+
+        bdev = bdget_disk(n->disk, 0);
+        if (bdev) {
+                mutex_lock(&bdev->bd_inode->i_mutex);
+                i_size_write(bdev->bd_inode, n->size);
+                mutex_unlock(&bdev->bd_inode->i_mutex);
+                bdput(bdev);
+        }
+}
+
+/*
+ * Distributed storage request processing function.
+ */
+static int dst_request(struct request_queue *q, struct bio *bio)
+{
+        struct dst_node *n = q->queuedata;
+
+        bio_get(bio);
+
+        return dst_process_bio(n, bio);
+}
+
+/*
+ * Open/close callbacks for appropriate block device.
+ */
+static int dst_bdev_open(struct block_device *bdev, fmode_t mode)
+{
+        struct dst_node *n = bdev->bd_disk->private_data;
+
+        dst_node_get(n);
+        return 0;
+}
+
+static int dst_bdev_release(struct gendisk *disk, fmode_t mode)
+{
+        struct dst_node *n = disk->private_data;
+
+        dst_node_put(n);
+        return 0;
+}
+
+static struct block_device_operations dst_blk_ops = {
+        .open           = dst_bdev_open,
+        .release        = dst_bdev_release,
+        .owner          = THIS_MODULE,
+};
+
+/*
+ * Block layer binding - disk is created when array is fully configured
+ * by userspace request.
+ */
+static int dst_node_create_disk(struct dst_node *n)
+{
+        int err = -ENOMEM;
+        u32 index = 0;
+
+        n->queue = blk_init_queue(NULL, NULL);
+        if (!n->queue)
+                goto err_out_exit;
+
+        n->queue->queuedata = n;
+        blk_queue_make_request(n->queue, dst_request);
+        blk_queue_max_phys_segments(n->queue, n->max_pages);
+        blk_queue_max_hw_segments(n->queue, n->max_pages);
+
+        err = -ENOMEM;
+        n->disk = alloc_disk(1);
+        if (!n->disk)
+                goto err_out_free_queue;
+
+        if (!(n->state->permissions & DST_PERM_WRITE)) {
+                printk(KERN_INFO "DST node %s attached read-only.\n", n->name);
+                set_disk_ro(n->disk, 1);
+        }
+
+        if (!idr_pre_get(&dst_index_idr, GFP_KERNEL))
+                goto err_out_put;
+
+        mutex_lock(&dst_hash_lock);
+        err = idr_get_new(&dst_index_idr, NULL, &index);
+        mutex_unlock(&dst_hash_lock);
+        if (err)
+                goto err_out_put;
+
+        n->disk->major = dst_major;
+        n->disk->first_minor = index;
+        n->disk->fops = &dst_blk_ops;
+        n->disk->queue = n->queue;
+        n->disk->private_data = n;
+        snprintf(n->disk->disk_name, sizeof(n->disk->disk_name), "dst-%s", n->name);
+
+        return 0;
+
+err_out_put:
+        put_disk(n->disk);
+err_out_free_queue:
+        blk_cleanup_queue(n->queue);
+err_out_exit:
+        return err;
+}
+
+/*
+ * Sysfs machinery: show device's size.
+ */
+static ssize_t dst_show_size(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct dst_info *info = container_of(dev, struct dst_info, device);
+
+        return sprintf(buf, "%llu\n", info->size);
+}
+
+/*
+ * Show local exported device.
+ */
+static ssize_t dst_show_local(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct dst_info *info = container_of(dev, struct dst_info, device);
+
+        return sprintf(buf, "%s\n", info->local);
+}
+
+/*
+ * Shows type of the remote node - device major/minor number
+ * for local nodes and address (af_inet ipv4/ipv6 only) for remote nodes.
+ */
+static ssize_t dst_show_type(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct dst_info *info = container_of(dev, struct dst_info, device);
+        int family = info->net.addr.sa_family;
+
+        if (family == AF_INET) {
+                struct sockaddr_in *sin = (struct sockaddr_in *)&info->net.addr;
+                return sprintf(buf, "%u.%u.%u.%u:%d\n",
+                        NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
+        } else if (family == AF_INET6) {
+                struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&info->net.addr;
+                return sprintf(buf,
+                        "%pi6:%d\n",
+                        &sin->sin6_addr, ntohs(sin->sin6_port));
+        } else {
+                int i, sz = PAGE_SIZE - 2; /* 0 symbol and '\n' below */
+                int size, addrlen = info->net.addr.sa_data_len;
+                unsigned char *a = (unsigned char *)&info->net.addr.sa_data;
+                char *buf_orig = buf;
+
+                size = snprintf(buf, sz, "family: %d, addrlen: %u, addr: ",
+                                family, addrlen);
+                sz -= size;
+                buf += size;
+
+                for (i=0; i<addrlen; ++i) {
+                        if (sz < 3)
+                                break;
+
+                        size = snprintf(buf, sz, "%02x ", a[i]);
+                        sz -= size;
+                        buf += size;
+                }
+                buf += sprintf(buf, "\n");
+
+                return buf - buf_orig;
+        }
+        return 0;
+}
+
+static struct device_attribute dst_node_attrs[] = {
+        __ATTR(size, 0444, dst_show_size, NULL),
+        __ATTR(type, 0444, dst_show_type, NULL),
+        __ATTR(local, 0444, dst_show_local, NULL),
+};
+
+static int dst_create_node_attributes(struct dst_node *n)
+{
+        int err, i;
+
+        for (i=0; i<ARRAY_SIZE(dst_node_attrs); ++i) {
+                err = device_create_file(&n->info->device,
+                                &dst_node_attrs[i]);
+                if (err)
+                        goto err_out_remove_all;
+        }
+        return 0;
+
+err_out_remove_all:
+        while (--i >= 0)
+                device_remove_file(&n->info->device,
+                                &dst_node_attrs[i]);
+
+        return err;
+}
+
+static void dst_remove_node_attributes(struct dst_node *n)
+{
+        int i;
+
+        for (i=0; i<ARRAY_SIZE(dst_node_attrs); ++i)
+                device_remove_file(&n->info->device,
+                                &dst_node_attrs[i]);
+}
+
+/*
+ * Sysfs cleanup and initialization.
+ * Shows number of useful parameters.
+ */
+static void dst_node_sysfs_exit(struct dst_node *n)
+{
+        if (n->info) {
+                dst_remove_node_attributes(n);
+                device_unregister(&n->info->device);
+                n->info = NULL;
+        }
+}
+
+static int dst_node_sysfs_init(struct dst_node *n)
+{
+        int err;
+
+        n->info = kzalloc(sizeof(struct dst_info), GFP_KERNEL);
+        if (!n->info)
+                return -ENOMEM;
+
+        memcpy(&n->info->device, &dst_node_dev, sizeof(struct device));
+        n->info->size = n->size;
+
+        snprintf(n->info->device.bus_id, sizeof(n->info->device.bus_id), "dst-%s", n->name);
+        err = device_register(&n->info->device);
+        if (err) {
+                dprintk(KERN_ERR "Failed to register node '%s', err: %d.\n",
+                                n->name, err);
+                goto err_out_exit;
+        }
+
+        dst_create_node_attributes(n);
+
+        return 0;
+
+err_out_exit:
+        kfree(n->info);
+        n->info = NULL;
+        return err;
+}
+
+/*
+ * DST node hash tables machinery.
+ */
+static inline unsigned int dst_hash(char *str, unsigned int size)
+{
+        return (jhash(str, size, 0) % dst_hashtable_size);
+}
+
+static void dst_node_remove(struct dst_node *n)
+{
+        mutex_lock(&dst_hash_lock);
+        list_del_init(&n->node_entry);
+        mutex_unlock(&dst_hash_lock);
+}
+
+static void dst_node_add(struct dst_node *n)
+{
+        unsigned hash = dst_hash(n->name, sizeof(n->name));
+
+        mutex_lock(&dst_hash_lock);
+        list_add_tail(&n->node_entry, &dst_hashtable[hash]);
+        mutex_unlock(&dst_hash_lock);
+}
+
+/*
+ * Cleaning node when it is about to be freed.
+ * There are still users of the socket though,
+ * so connection cleanup should be protected.
+ */
+static void dst_node_cleanup(struct dst_node *n)
+{
+        struct dst_state *st = n->state;
+
+        if (!st)
+                return;
+
+        if (n->queue) {
+                blk_cleanup_queue(n->queue);
+
+                mutex_lock(&dst_hash_lock);
+                idr_remove(&dst_index_idr, n->disk->first_minor);
+                mutex_unlock(&dst_hash_lock);
+
+                put_disk(n->disk);
+        }
+
+        if (n->bdev) {
+                sync_blockdev(n->bdev);
+                blkdev_put(n->bdev, FMODE_READ|FMODE_WRITE);
+        }
+
+        dst_state_lock(st);
+        st->need_exit = 1;
+        dst_state_exit_connected(st);
+        dst_state_unlock(st);
+
+        wake_up(&st->thread_wait);
+
+        dst_state_put(st);
+        n->state = NULL;
+}
+
+/*
+ * Free security attributes attached to given node.
+ */
+static void dst_security_exit(struct dst_node *n)
+{
+        struct dst_secure *s, *tmp;
+
+        list_for_each_entry_safe(s, tmp, &n->security_list, sec_entry) {
+                list_del(&s->sec_entry);
+                kfree(s);
+        }
+}
+
+/*
+ * Free node when there are no more users.
+ * Actually node has to be freed on behalf od userspace process,
+ * since there are number of threads, which are embedded in the
+ * node, so they can not exit and free node from there, that is
+ * why there is a wakeup if reference counter is not equal to zero.
+ */
+void dst_node_put(struct dst_node *n)
+{
+        if (unlikely(!n))
+                return;
+
+        dprintk("%s: n: %p, refcnt: %d.\n",
+                        __func__, n, atomic_read(&n->refcnt));
+
+        if (atomic_dec_and_test(&n->refcnt)) {
+                dst_node_remove(n);
+                n->trans_scan_timeout = 0;
+                dst_node_cleanup(n);
+                thread_pool_destroy(n->pool);
+                dst_node_sysfs_exit(n);
+                dst_node_crypto_exit(n);
+                dst_security_exit(n);
+                dst_node_trans_exit(n);
+
+                kfree(n);
+
+                dprintk("%s: freed n: %p.\n", __func__, n);
+        } else {
+                wake_up(&n->wait);
+        }
+}
+
+/*
+ * This function finds devices major/minor numbers for given pathname.
+ */
+static int dst_lookup_device(const char *path, dev_t *dev)
+{
+        int err;
+        struct nameidata nd;
+        struct inode *inode;
+
+        err = path_lookup(path, LOOKUP_FOLLOW, &nd);
+        if (err)
+                return err;
+
+        inode = nd.path.dentry->d_inode;
+        if (!inode) {
+                err = -ENOENT;
+                goto out;
+        }
+
+        if (!S_ISBLK(inode->i_mode)) {
+                err = -ENOTBLK;
+                goto out;
+        }
+
+        *dev = inode->i_rdev;
+
+out:
+        path_put(&nd.path);
+        return err;
+}
+
+/*
+ * Setting up export device: lookup by the name, get its size
+ * and setup listening socket, which will accept clients, which
+ * will submit IO for given storage.
+ */
+static int dst_setup_export(struct dst_node *n, struct dst_ctl *ctl,
+                struct dst_export_ctl *le)
+{
+        int err;
+        dev_t dev = 0; /* gcc likes to scream here */
+
+        snprintf(n->info->local, sizeof(n->info->local), "%s", le->device);
+
+        err = dst_lookup_device(le->device, &dev);
+        if (err)
+                return err;
+
+        n->bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
+        if (!n->bdev)
+                return -ENODEV;
+
+        if (n->size != 0)
+                n->size = min_t(loff_t, n->bdev->bd_inode->i_size, n->size);
+        else
+                n->size = n->bdev->bd_inode->i_size;
+
+        n->info->size = n->size;
+        err = dst_node_init_listened(n, le);
+        if (err)
+                goto err_out_cleanup;
+
+        return 0;
+
+err_out_cleanup:
+        blkdev_put(n->bdev, FMODE_READ|FMODE_WRITE);
+        n->bdev = NULL;
+
+        return err;
+}
+
+/* Empty thread pool callbacks for the network processing threads. */
+static inline void *dst_thread_network_init(void *data)
+{
+        dprintk("%s: data: %p.\n", __func__, data);
+        return data;
+}
+
+static inline void dst_thread_network_cleanup(void *data)
+{
+        dprintk("%s: data: %p.\n", __func__, data);
+}
+
+/*
+ * Allocate DST node and initialize some of its parameters.
+ */
+static struct dst_node *dst_alloc_node(struct dst_ctl *ctl,
+                int (*start)(struct dst_node *),
+                int num)
+{
+        struct dst_node *n;
+        int err;
+
+        n = kzalloc(sizeof(struct dst_node), GFP_KERNEL);
+        if (!n)
+                return NULL;
+
+        INIT_LIST_HEAD(&n->node_entry);
+
+        INIT_LIST_HEAD(&n->security_list);
+        mutex_init(&n->security_lock);
+
+        init_waitqueue_head(&n->wait);
+
+        n->trans_scan_timeout = msecs_to_jiffies(ctl->trans_scan_timeout);
+        if (!n->trans_scan_timeout)
+                n->trans_scan_timeout = HZ;
+
+        n->trans_max_retries = ctl->trans_max_retries;
+        if (!n->trans_max_retries)
+                n->trans_max_retries = 10;
+
+        /*
+         * Pretty much arbitrary default numbers.
+         * 32 matches maximum number of pages in bio originated from ext3 (31).
+         */
+        n->max_pages = ctl->max_pages;
+        if (!n->max_pages)
+                n->max_pages = 32;
+
+        if (n->max_pages > 1024)
+                n->max_pages = 1024;
+
+        n->start = start;
+        n->size = ctl->size;
+
+        atomic_set(&n->refcnt, 1);
+        atomic_long_set(&n->gen, 0);
+        snprintf(n->name, sizeof(n->name), "%s", ctl->name);
+
+        err = dst_node_sysfs_init(n);
+        if (err)
+                goto err_out_free;
+
+        n->pool = thread_pool_create(num, n->name, dst_thread_network_init,
+                        dst_thread_network_cleanup, n);
+        if (IS_ERR(n->pool)) {
+                err = PTR_ERR(n->pool);
+                goto err_out_sysfs_exit;
+        }
+
+        dprintk("%s: n: %p, name: %s.\n", __func__, n, n->name);
+
+        return n;
+
+err_out_sysfs_exit:
+        dst_node_sysfs_exit(n);
+err_out_free:
+        kfree(n);
+        return NULL;
+}
+
+/*
+ * Starting a node, connected to the remote server:
+ * register block device and initialize transaction mechanism.
+ * In revers order though.
+ *
+ * It will autonegotiate some parameters with the remote node
+ * and update local if needed.
+ *
+ * Transaction initialization should be the last thing before
+ * starting the node, since transaction should include not only
+ * block IO, but also crypto related data (if any), which are
+ * initialized separately.
+ */
+static int dst_start_remote(struct dst_node *n)
+{
+        int err;
+
+        err = dst_node_trans_init(n, sizeof(struct dst_trans));
+        if (err)
+                return err;
+
+        err = dst_node_create_disk(n);
+        if (err)
+                return err;
+
+        dst_node_set_size(n);
+        add_disk(n->disk);
+
+        dprintk("DST: started remote node '%s', minor: %d.\n", n->name, n->disk->first_minor);
+
+        return 0;
+}
+
+/*
+ * Adding remote node and initialize connection.
+ */
+static int dst_add_remote(struct dst_node *n, struct dst_ctl *ctl,
+                void *data, unsigned int size)
+{
+        int err;
+        struct dst_network_ctl *rctl = data;
+
+        if (n)
+                return -EEXIST;
+
+        if (size != sizeof(struct dst_network_ctl))
+                return -EINVAL;
+
+        n = dst_alloc_node(ctl, dst_start_remote, 1);
+        if (!n)
+                return -ENOMEM;
+
+        memcpy(&n->info->net, rctl, sizeof(struct dst_network_ctl));
+        err = dst_node_init_connected(n, rctl);
+        if (err)
+                goto err_out_free;
+
+        dst_node_add(n);
+
+        return 0;
+
+err_out_free:
+        dst_node_put(n);
+        return err;
+}
+
+/*
+ * Adding export node: initializing block device and listening socket.
+ */
+static int dst_add_export(struct dst_node *n, struct dst_ctl *ctl,
+                void *data, unsigned int size)
+{
+        int err;
+        struct dst_export_ctl *le = data;
+
+        if (n)
+                return -EEXIST;
+
+        if (size != sizeof(struct dst_export_ctl))
+                return -EINVAL;
+
+        n = dst_alloc_node(ctl, dst_start_export, 2);
+        if (!n)
+                return -EINVAL;
+
+        err = dst_setup_export(n, ctl, le);
+        if (err)
+                goto err_out_free;
+
+        dst_node_add(n);
+
+        return 0;
+
+err_out_free:
+        dst_node_put(n);
+        return err;
+}
+
+static int dst_node_remove_unload(struct dst_node *n)
+{
+        printk(KERN_INFO "STOPPED name: '%s', size: %llu.\n",
+                        n->name, n->size);
+
+        if (n->disk)
+                del_gendisk(n->disk);
+
+        dst_node_remove(n);
+        dst_node_sysfs_exit(n);
+
+        /*
+         * This is not a hack. Really.
+         * Node's reference counter allows to implement fine grained
+         * node freeing, but since all transactions (which hold node's
+         * reference counter) are processed in the dedicated thread,
+         * it is possible that reference will hit zero in that thread,
+         * so we will not be able to exit thread and cleanup the node.
+         *
+         * So, we remove disk, so no new activity is possible, and
+         * wait until all pending transaction are completed (either
+         * in receiving thread or by timeout in workqueue), in this
+         * case reference counter will be less or equal to 2 (once set in
+         * dst_alloc_node() and then in connector message parser;
+         * or when we force module unloading, and connector message
+         * parser does not hold a reference, in this case reference
+         * counter will be equal to 1),
+         * and subsequent dst_node_put() calls will free the node.
+         */
+        dprintk("%s: going to sleep with %d refcnt.\n", __func__, atomic_read(&n->refcnt));
+        wait_event(n->wait, atomic_read(&n->refcnt) <= 2);
+
+        dst_node_put(n);
+        return 0;
+}
+
+/*
+ * Remove node from the hash table.
+ */
+static int dst_del_node(struct dst_node *n, struct dst_ctl *ctl,
+                void *data, unsigned int size)
+{
+        if (!n)
+                return -ENODEV;
+
+        return dst_node_remove_unload(n);
+}
+
+/*
+ * Initialize crypto processing for given node.
+ */
+static int dst_crypto_init(struct dst_node *n, struct dst_ctl *ctl,
+                void *data, unsigned int size)
+{
+        struct dst_crypto_ctl *crypto = data;
+
+        if (!n)
+                return -ENODEV;
+
+        if (size != sizeof(struct dst_crypto_ctl) + crypto->hash_keysize +
+                        crypto->cipher_keysize)
+                return -EINVAL;
+
+        if (n->trans_cache)
+                return -EEXIST;
+
+        return dst_node_crypto_init(n, crypto);
+}
+
+/*
+ * Security attributes for given node.
+ */
+static int dst_security_init(struct dst_node *n, struct dst_ctl *ctl,
+                void *data, unsigned int size)
+{
+        struct dst_secure *s;
+
+        if (!n)
+                return -ENODEV;
+
+        if (size != sizeof(struct dst_secure_user))
+                return -EINVAL;
+
+        s = kmalloc(sizeof(struct dst_secure), GFP_KERNEL);
+        if (!s)
+                return -ENOMEM;
+
+        memcpy(&s->sec, data, size);
+
+        mutex_lock(&n->security_lock);
+        list_add_tail(&s->sec_entry, &n->security_list);
+        mutex_unlock(&n->security_lock);
+
+        return 0;
+}
+
+/*
+ * Kill'em all!
+ */
+static int dst_start_node(struct dst_node *n, struct dst_ctl *ctl,
+                void *data, unsigned int size)
+{
+        int err;
+
+        if (!n)
+                return -ENODEV;
+
+        if (n->trans_cache)
+                return 0;
+
+        err = n->start(n);
+        if (err)
+                return err;
+
+        printk(KERN_INFO "STARTED name: '%s', size: %llu.\n", n->name, n->size);
+        return 0;
+}
+
+typedef int (*dst_command_func)(struct dst_node *n, struct dst_ctl *ctl,
+                void *data, unsigned int size);
+
+/*
+ * List of userspace commands.
+ */
+static dst_command_func dst_commands[] = {
+        [DST_ADD_REMOTE] = &dst_add_remote,
+        [DST_ADD_EXPORT] = &dst_add_export,
+        [DST_DEL_NODE] = &dst_del_node,
+        [DST_CRYPTO] = &dst_crypto_init,
+        [DST_SECURITY] = &dst_security_init,
+        [DST_START] = &dst_start_node,
+};
+
+/*
+ * Configuration parser.
+ */
+static void cn_dst_callback(void *data)
+{
+        struct dst_ctl *ctl;
+        struct cn_msg *msg = data;
+        int err;
+        struct dst_ctl_ack ack;
+        struct dst_node *n = NULL, *tmp;
+        unsigned int hash;
+
+        if (msg->len < sizeof(struct dst_ctl)) {
+                err = -EBADMSG;
+                goto out;
+        }
+
+        ctl = (struct dst_ctl *)msg->data;
+
+        if (ctl->cmd >= DST_CMD_MAX) {
+                err = -EINVAL;
+                goto out;
+        }
+        hash = dst_hash(ctl->name, sizeof(ctl->name));
+
+        mutex_lock(&dst_hash_lock);
+        list_for_each_entry(tmp, &dst_hashtable[hash], node_entry) {
+                if (!memcmp(tmp->name, ctl->name, sizeof(tmp->name))) {
+                        n = tmp;
+                        dst_node_get(n);
+                        break;
+                }
+        }
+        mutex_unlock(&dst_hash_lock);
+
+        err = dst_commands[ctl->cmd](n, ctl, msg->data + sizeof(struct dst_ctl),
+                        msg->len - sizeof(struct dst_ctl));
+
+        dst_node_put(n);
+out:
+        memcpy(&ack.msg, msg, sizeof(struct cn_msg));
+
+        ack.msg.ack = msg->ack + 1;
+        ack.msg.len = sizeof(struct dst_ctl_ack) - sizeof(struct cn_msg);
+
+        ack.error = err;
+
+        cn_netlink_send(&ack.msg, 0, GFP_KERNEL);
+}
+
+/*
+ * Global initialization: sysfs, hash table, block device registration,
+ * connector and various caches.
+ */
+static int __init dst_sysfs_init(void)
+{
+        return bus_register(&dst_dev_bus_type);
+}
+
+static void dst_sysfs_exit(void)
+{
+        bus_unregister(&dst_dev_bus_type);
+}
+
+static int __init dst_hashtable_init(void)
+{
+        unsigned int i;
+
+        dst_hashtable = kcalloc(dst_hashtable_size, sizeof(struct list_head),
+                        GFP_KERNEL);
+        if (!dst_hashtable)
+                return -ENOMEM;
+
+        for (i=0; i<dst_hashtable_size; ++i)
+                INIT_LIST_HEAD(&dst_hashtable[i]);
+
+        return 0;
+}
+
+static void dst_hashtable_exit(void)
+{
+        unsigned int i;
+        struct dst_node *n, *tmp;
+
+        for (i=0; i<dst_hashtable_size; ++i) {
+                list_for_each_entry_safe(n, tmp, &dst_hashtable[i], node_entry) {
+                        dst_node_remove_unload(n);
+                }
+        }
+
+        kfree(dst_hashtable);
+}
+
+static int __init dst_sys_init(void)
+{
+        int err = -ENOMEM;
+
+        err = dst_hashtable_init();
+        if (err)
+                goto err_out_exit;
+
+        err = dst_export_init();
+        if (err)
+                goto err_out_hashtable_exit;
+
+        err = register_blkdev(dst_major, DST_NAME);
+        if (err < 0)
+                goto err_out_export_exit;
+        if (err)
+                dst_major = err;
+
+        err = dst_sysfs_init();
+        if (err)
+                goto err_out_unregister;
+
+        err = cn_add_callback(&cn_dst_id, "DST", cn_dst_callback);
+        if (err)
+                goto err_out_sysfs_exit;
+
+        printk(KERN_INFO "Distributed storage, '%s' release.\n", dst_name);
+
+        return 0;
+
+err_out_sysfs_exit:
+        dst_sysfs_exit();
+err_out_unregister:
+        unregister_blkdev(dst_major, DST_NAME);
+err_out_export_exit:
+        dst_export_exit();
+err_out_hashtable_exit:
+        dst_hashtable_exit();
+err_out_exit:
+        return err;
+}
+
+static void __exit dst_sys_exit(void)
+{
+        cn_del_callback(&cn_dst_id);
+        unregister_blkdev(dst_major, DST_NAME);
+        dst_hashtable_exit();
+        dst_sysfs_exit();
+        dst_export_exit();
+}
+
+module_init(dst_sys_init);
+module_exit(dst_sys_exit);
+
+MODULE_DESCRIPTION("Distributed storage");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/connector.h b/include/linux/connector.h
index fc65d219d88c..b9966e64604e 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -39,8 +39,10 @@
 #define CN_IDX_V86D                     0x4
 #define CN_VAL_V86D_UVESAFB             0x1
 #define CN_IDX_BB                       0x5     /* BlackBoard, from the TSP GPL sampling framework */
+#define CN_DST_IDX                      0x6
+#define CN_DST_VAL                      0x1
 
-#define CN_NETLINK_USERS                6
+#define CN_NETLINK_USERS                7
 
 /*
  * Maximum connector's message size.
diff --git a/include/linux/dst.h b/include/linux/dst.h
new file mode 100644
index 000000000000..e26fed84b1aa
--- /dev/null
+++ b/include/linux/dst.h
@@ -0,0 +1,587 @@
+/*
+ * 2007+ Copyright (c) Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * All rights reserved.
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ */
+
+#ifndef __DST_H
+#define __DST_H
+
+#include <linux/types.h>
+#include <linux/connector.h>
+
+#define DST_NAMELEN             32
+#define DST_NAME                "dst"
+
+enum {
+        /* Remove node with given id from storage */
+        DST_DEL_NODE    = 0,
+        /* Add remote node with given id to the storage */
+        DST_ADD_REMOTE,
+        /* Add local node with given id to the storage to be exported and used by remote peers */
+        DST_ADD_EXPORT,
+        /* Crypto initialization command (hash/cipher used to protect the connection) */
+        DST_CRYPTO,
+        /* Security attributes for given connection (permissions for example) */
+        DST_SECURITY,
+        /* Register given node in the block layer subsystem */
+        DST_START,
+        DST_CMD_MAX
+};
+
+struct dst_ctl
+{
+        /* Storage name */
+        char                    name[DST_NAMELEN];
+        /* Command flags */
+        __u32                   flags;
+        /* Command itself (see above) */
+        __u32                   cmd;
+        /* Maximum number of pages per single request in this device */
+        __u32                   max_pages;
+        /* Stale/error transaction scanning timeout in milliseconds */
+        __u32                   trans_scan_timeout;
+        /* Maximum number of retry sends before completing transaction as broken */
+        __u32                   trans_max_retries;
+        /* Storage size */
+        __u64                   size;
+};
+
+/* Reply command carries completion status */
+struct dst_ctl_ack
+{
+        struct cn_msg           msg;
+        int                     error;
+        int                     unused[3];
+};
+
+/*
+ * Unfortunaltely socket address structure is not exported to userspace
+ * and is redefined there.
+ */
+#define SADDR_MAX_DATA  128
+
+struct saddr {
+        /* address family, AF_xxx       */
+        unsigned short          sa_family;
+        /* 14 bytes of protocol address */
+        char                    sa_data[SADDR_MAX_DATA];
+        /* Number of bytes used in sa_data */
+        unsigned short          sa_data_len;
+};
+
+/* Address structure */
+struct dst_network_ctl
+{
+        /* Socket type: datagram, stream...*/
+        unsigned int            type;
+        /* Let me guess, is it a Jupiter diameter? */
+        unsigned int            proto;
+        /* Peer's address */
+        struct saddr            addr;
+};
+
+struct dst_crypto_ctl
+{
+        /* Cipher and hash names */
+        char                    cipher_algo[DST_NAMELEN];
+        char                    hash_algo[DST_NAMELEN];
+
+        /* Key sizes. Can be zero for digest for example */
+        unsigned int            cipher_keysize, hash_keysize;
+        /* Alignment. Calculated by the DST itself. */
+        unsigned int            crypto_attached_size;
+        /* Number of threads to perform crypto operations */
+        int                     thread_num;
+};
+
+/* Export security attributes have this bits checked in when client connects */
+#define DST_PERM_READ           (1<<0)
+#define DST_PERM_WRITE          (1<<1)
+
+/*
+ * Right now it is simple model, where each remote address
+ * is assigned to set of permissions it is allowed to perform.
+ * In real world block device does not know anything but
+ * reading and writing, so it should be more than enough.
+ */
+struct dst_secure_user
+{
+        unsigned int            permissions;
+        struct saddr            addr;
+};
+
+/*
+ * Export control command: device to export and network address to accept
+ * clients to work with given device
+ */
+struct dst_export_ctl
+{
+        char                    device[DST_NAMELEN];
+        struct dst_network_ctl  ctl;
+};
+
+enum {
+        DST_CFG = 1,            /* Request remote configuration */
+        DST_IO,                 /* IO command */
+        DST_IO_RESPONSE,        /* IO response */
+        DST_PING,               /* Keepalive message */
+        DST_NCMD_MAX,
+};
+
+struct dst_cmd
+{
+        /* Network command itself, see above */
+        __u32                   cmd;
+        /*
+         * Size of the attached data
+         * (in most cases, for READ command it means how many bytes were requested)
+         */
+        __u32                   size;
+        /* Crypto size: number of attached bytes with digest/hmac */
+        __u32                   csize;
+        /* Here we can carry secret data */
+        __u32                   reserved;
+        /* Read/write bits, see how they are encoded in bio structure */
+        __u64                   rw;
+        /* BIO flags */
+        __u64                   flags;
+        /* Unique command id (like transaction ID) */
+        __u64                   id;
+        /* Sector to start IO from */
+        __u64                   sector;
+        /* Hash data is placed after this header */
+        __u8                    hash[0];
+};
+
+/*
+ * Convert command to/from network byte order.
+ * We do not use hton*() functions, since there is
+ * no 64-bit implementation.
+ */
+static inline void dst_convert_cmd(struct dst_cmd *c)
+{
+        c->cmd = __cpu_to_be32(c->cmd);
+        c->csize = __cpu_to_be32(c->csize);
+        c->size = __cpu_to_be32(c->size);
+        c->sector = __cpu_to_be64(c->sector);
+        c->id = __cpu_to_be64(c->id);
+        c->flags = __cpu_to_be64(c->flags);
+        c->rw = __cpu_to_be64(c->rw);
+}
+
+/* Transaction id */
+typedef __u64 dst_gen_t;
+
+#ifdef __KERNEL__
+
+#include <linux/blkdev.h>
+#include <linux/bio.h>
+#include <linux/device.h>
+#include <linux/mempool.h>
+#include <linux/net.h>
+#include <linux/poll.h>
+#include <linux/rbtree.h>
+
+#ifdef CONFIG_DST_DEBUG
+#define dprintk(f, a...) printk(KERN_NOTICE f, ##a)
+#else
+static inline void __attribute__ ((format (printf, 1, 2)))
+        dprintk(const char *fmt, ...) {}
+#endif
+
+struct dst_node;
+
+struct dst_trans
+{
+        /* DST node we are working with */
+        struct dst_node         *n;
+
+        /* Entry inside transaction tree */
+        struct rb_node          trans_entry;
+
+        /* Merlin kills this transaction when this memory cell equals zero */
+        atomic_t                refcnt;
+
+        /* How this transaction should be processed by crypto engine */
+        short                   enc;
+        /* How many times this transaction was resent */
+        short                   retries;
+        /* Completion status */
+        int                     error;
+
+        /* When did we send it to the remote peer */
+        long                    send_time;
+
+        /* My name is...
+         * Well, computers does not speak, they have unique id instead */
+        dst_gen_t               gen;
+
+        /* Block IO we are working with */
+        struct bio              *bio;
+
+        /* Network command for above block IO request */
+        struct dst_cmd          cmd;
+};
+
+struct dst_crypto_engine
+{
+        /* What should we do with all block requests */
+        struct crypto_hash      *hash;
+        struct crypto_ablkcipher        *cipher;
+
+        /* Pool of pages used to encrypt data into before sending */
+        int                     page_num;
+        struct page             **pages;
+
+        /* What to do with current request */
+        int                     enc;
+        /* Who we are and where do we go */
+        struct scatterlist      *src, *dst;
+
+        /* Maximum timeout waiting for encryption to be completed */
+        long                    timeout;
+        /* IV is a 64-bit sequential counter */
+        u64                     iv;
+
+        /* Secret data */
+        void                    *private;
+
+        /* Cached temporary data lives here */
+        int                     size;
+        void                    *data;
+};
+
+struct dst_state
+{
+        /* The main state protection */
+        struct mutex            state_lock;
+
+        /* Polling machinery for sockets */
+        wait_queue_t            wait;
+        wait_queue_head_t       *whead;
+        /* Most of events are being waited here */
+        wait_queue_head_t       thread_wait;
+
+        /* Who owns this? */
+        struct dst_node         *node;
+
+        /* Network address for this state */
+        struct dst_network_ctl  ctl;
+
+        /* Permissions to work with: read-only or rw connection */
+        u32                     permissions;
+
+        /* Called when we need to clean private data */
+        void                    (* cleanup)(struct dst_state *st);
+
+        /* Used by the server: BIO completion queues BIOs here */
+        struct list_head        request_list;
+        spinlock_t              request_lock;
+
+        /* Guess what? No, it is not number of planets */
+        atomic_t                refcnt;
+
+        /* This flags is set when connection should be dropped */
+        int                     need_exit;
+
+        /*
+         * Socket to work with. Second pointer is used for
+         * lockless check if socket was changed before performing
+         * next action (like working with cached polling result)
+         */
+        struct socket           *socket, *read_socket;
+
+        /* Cached preallocated data */
+        void                    *data;
+        unsigned int            size;
+
+        /* Currently processed command */
+        struct dst_cmd          cmd;
+};
+
+struct dst_info
+{
+        /* Device size */
+        u64                     size;
+
+        /* Local device name for export devices */
+        char                    local[DST_NAMELEN];
+
+        /* Network setup */
+        struct dst_network_ctl  net;
+
+        /* Sysfs bits use this */
+        struct device           device;
+};
+
+struct dst_node
+{
+        struct list_head        node_entry;
+
+        /* Hi, my name is stored here */
+        char                    name[DST_NAMELEN];
+        /* My cache name is stored here */
+        char                    cache_name[DST_NAMELEN];
+
+        /* Block device attached to given node.
+         * Only valid for exporting nodes */
+        struct block_device     *bdev;
+        /* Network state machine for given peer */
+        struct dst_state        *state;
+
+        /* Block IO machinery */
+        struct request_queue    *queue;
+        struct gendisk          *disk;
+
+        /* Number of threads in processing pool */
+        int                     thread_num;
+        /* Maximum number of pages in single IO */
+        int                     max_pages;
+
+        /* I'm that big in bytes */
+        loff_t                  size;
+
+        /* Exported to userspace node information */
+        struct dst_info         *info;
+
+        /*
+         * Security attribute list.
+         * Used only by exporting node currently.
+         */
+        struct list_head        security_list;
+        struct mutex            security_lock;
+
+        /*
+         * When this unerflows below zero, university collapses.
+         * But this will not happen, since node will be freed,
+         * when reference counter reaches zero.
+         */
+        atomic_t                refcnt;
+
+        /* How precisely should I be started? */
+        int                     (*start)(struct dst_node *);
+
+        /* Crypto capabilities */
+        struct dst_crypto_ctl   crypto;
+        u8                      *hash_key;
+        u8                      *cipher_key;
+
+        /* Pool of processing thread */
+        struct thread_pool      *pool;
+
+        /* Transaction IDs live here */
+        atomic_long_t           gen;
+
+        /*
+         * How frequently and how many times transaction
+         * tree should be scanned to drop stale objects.
+         */
+        long                    trans_scan_timeout;
+        int                     trans_max_retries;
+
+        /* Small gnomes live here */
+        struct rb_root          trans_root;
+        struct mutex            trans_lock;
+
+        /*
+         * Transaction cache/memory pool.
+         * It is big enough to contain not only transaction
+         * itself, but additional crypto data (digest/hmac).
+         */
+        struct kmem_cache       *trans_cache;
+        mempool_t               *trans_pool;
+
+        /* This entity scans transaction tree */
+        struct delayed_work     trans_work;
+
+        wait_queue_head_t       wait;
+};
+
+/* Kernel representation of the security attribute */
+struct dst_secure
+{
+        struct list_head        sec_entry;
+        struct dst_secure_user  sec;
+};
+
+int dst_process_bio(struct dst_node *n, struct bio *bio);
+
+int dst_node_init_connected(struct dst_node *n, struct dst_network_ctl *r);
+int dst_node_init_listened(struct dst_node *n, struct dst_export_ctl *le);
+
+static inline struct dst_state *dst_state_get(struct dst_state *st)
+{
+        BUG_ON(atomic_read(&st->refcnt) == 0);
+        atomic_inc(&st->refcnt);
+        return st;
+}
+
+void dst_state_put(struct dst_state *st);
+
+struct dst_state *dst_state_alloc(struct dst_node *n);
+int dst_state_socket_create(struct dst_state *st);
+void dst_state_socket_release(struct dst_state *st);
+
+void dst_state_exit_connected(struct dst_state *st);
+
+int dst_state_schedule_receiver(struct dst_state *st);
+
+void dst_dump_addr(struct socket *sk, struct sockaddr *sa, char *str);
+
+static inline void dst_state_lock(struct dst_state *st)
+{
+        mutex_lock(&st->state_lock);
+}
+
+static inline void dst_state_unlock(struct dst_state *st)
+{
+        mutex_unlock(&st->state_lock);
+}
+
+void dst_poll_exit(struct dst_state *st);
+int dst_poll_init(struct dst_state *st);
+
+static inline unsigned int dst_state_poll(struct dst_state *st)
+{
+        unsigned int revents = POLLHUP | POLLERR;
+
+        dst_state_lock(st);
+        if (st->socket)
+                revents = st->socket->ops->poll(NULL, st->socket, NULL);
+        dst_state_unlock(st);
+
+        return revents;
+}
+
+static inline int dst_thread_setup(void *private, void *data)
+{
+        return 0;
+}
+
+void dst_node_put(struct dst_node *n);
+
+static inline struct dst_node *dst_node_get(struct dst_node *n)
+{
+        atomic_inc(&n->refcnt);
+        return n;
+}
+
+int dst_data_recv(struct dst_state *st, void *data, unsigned int size);
+int dst_recv_cdata(struct dst_state *st, void *cdata);
+int dst_data_send_header(struct socket *sock,
+                void *data, unsigned int size, int more);
+
+int dst_send_bio(struct dst_state *st, struct dst_cmd *cmd, struct bio *bio);
+
+int dst_process_io(struct dst_state *st);
+int dst_export_crypto(struct dst_node *n, struct bio *bio);
+int dst_export_send_bio(struct bio *bio);
+int dst_start_export(struct dst_node *n);
+
+int __init dst_export_init(void);
+void dst_export_exit(void);
+
+/* Private structure for export block IO requests */
+struct dst_export_priv
+{
+        struct list_head                request_entry;
+        struct dst_state                *state;
+        struct bio                      *bio;
+        struct dst_cmd                  cmd;
+};
+
+static inline void dst_trans_get(struct dst_trans *t)
+{
+        atomic_inc(&t->refcnt);
+}
+
+struct dst_trans *dst_trans_search(struct dst_node *node, dst_gen_t gen);
+int dst_trans_remove(struct dst_trans *t);
+int dst_trans_remove_nolock(struct dst_trans *t);
+void dst_trans_put(struct dst_trans *t);
+
+/*
+ * Convert bio into network command.
+ */
+static inline void dst_bio_to_cmd(struct bio *bio, struct dst_cmd *cmd,
+                u32 command, u64 id)
+{
+        cmd->cmd = command;
+        cmd->flags = (bio->bi_flags << BIO_POOL_BITS) >> BIO_POOL_BITS;
+        cmd->rw = bio->bi_rw;
+        cmd->size = bio->bi_size;
+        cmd->csize = 0;
+        cmd->id = id;
+        cmd->sector = bio->bi_sector;
+};
+
+int dst_trans_send(struct dst_trans *t);
+int dst_trans_crypto(struct dst_trans *t);
+
+int dst_node_crypto_init(struct dst_node *n, struct dst_crypto_ctl *ctl);
+void dst_node_crypto_exit(struct dst_node *n);
+
+static inline int dst_need_crypto(struct dst_node *n)
+{
+        struct dst_crypto_ctl *c = &n->crypto;
+        /*
+         * Logical OR is appropriate here, but boolean one produces
+         * more optimal code, so it is used instead.
+         */
+        return (c->hash_algo[0] | c->cipher_algo[0]);
+}
+
+int dst_node_trans_init(struct dst_node *n, unsigned int size);
+void dst_node_trans_exit(struct dst_node *n);
+
+/*
+ * Pool of threads.
+ * Ready list contains threads currently free to be used,
+ * active one contains threads with some work scheduled for them.
+ * Caller can wait in given queue when thread is ready.
+ */
+struct thread_pool
+{
+        int                     thread_num;
+        struct mutex            thread_lock;
+        struct list_head        ready_list, active_list;
+
+        wait_queue_head_t       wait;
+};
+
+void thread_pool_del_worker(struct thread_pool *p);
+void thread_pool_del_worker_id(struct thread_pool *p, unsigned int id);
+int thread_pool_add_worker(struct thread_pool *p,
+                char *name,
+                unsigned int id,
+                void *(* init)(void *data),
+                void (* cleanup)(void *data),
+                void *data);
+
+void thread_pool_destroy(struct thread_pool *p);
+struct thread_pool *thread_pool_create(int num, char *name,
+                void *(* init)(void *data),
+                void (* cleanup)(void *data),
+                void *data);
+
+int thread_pool_schedule(struct thread_pool *p,
+                int (* setup)(void *stored_private, void *setup_data),
+                int (* action)(void *stored_private, void *setup_data),
+                void *setup_data, long timeout);
+int thread_pool_schedule_private(struct thread_pool *p,
+                int (* setup)(void *private, void *data),
+                int (* action)(void *private, void *data),
+                void *data, long timeout, void *id);
+
+#endif /* __KERNEL__ */
+#endif /* __DST_H */