lkml.org 
[lkml]   [2008]   [Nov]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[resend take 3 1/4] DST core files.
    Date
    Signed-off-by: Evgeniy Polyakov <zbr@ioremap.net>

    diff --git a/drivers/block/dst/dcore.c b/drivers/block/dst/dcore.c
    new file mode 100644
    index 0000000..fea201b
    --- /dev/null
    +++ b/drivers/block/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[] = "Sik tee or kunem kez";
    +
    +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 inode *inode, struct file *filp)
    +{
    + struct dst_node *n = inode->i_bdev->bd_disk->private_data;
    +
    + dst_node_get(n);
    + return 0;
    +}
    +
    +static int dst_bdev_release(struct inode *inode, struct file *filp)
    +{
    + struct dst_node *n = inode->i_bdev->bd_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_alloc_queue(GFP_KERNEL);
    + 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,
    + "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%d\n",
    + NIP6(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);
    + }
    +
    + 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);
    + 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/drivers/block/dst/trans.c b/drivers/block/dst/trans.c
    new file mode 100644
    index 0000000..557d372
    --- /dev/null
    +++ b/drivers/block/dst/trans.c
    @@ -0,0 +1,335 @@
    +/*
    + * 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/bio.h>
    +#include <linux/dst.h>
    +#include <linux/slab.h>
    +#include <linux/mempool.h>
    +
    +/*
    + * Transaction memory pool size.
    + */
    +static int dst_mempool_num = 32;
    +module_param(dst_mempool_num, int, 0644);
    +
    +/*
    + * Transaction tree management.
    + */
    +static inline int dst_trans_cmp(dst_gen_t gen, dst_gen_t new)
    +{
    + if (gen < new)
    + return 1;
    + if (gen > new)
    + return -1;
    + return 0;
    +}
    +
    +struct dst_trans *dst_trans_search(struct dst_node *node, dst_gen_t gen)
    +{
    + struct rb_root *root = &node->trans_root;
    + struct rb_node *n = root->rb_node;
    + struct dst_trans *t, *ret = NULL;
    + int cmp;
    +
    + while (n) {
    + t = rb_entry(n, struct dst_trans, trans_entry);
    +
    + cmp = dst_trans_cmp(t->gen, gen);
    + if (cmp < 0)
    + n = n->rb_left;
    + else if (cmp > 0)
    + n = n->rb_right;
    + else {
    + ret = t;
    + break;
    + }
    + }
    +
    + dprintk("%s: %s transaction: id: %llu.\n", __func__,
    + (ret)?"found":"not found", gen);
    +
    + return ret;
    +}
    +
    +static int dst_trans_insert(struct dst_trans *new)
    +{
    + struct rb_root *root = &new->n->trans_root;
    + struct rb_node **n = &root->rb_node, *parent = NULL;
    + struct dst_trans *ret = NULL, *t;
    + int cmp;
    +
    + while (*n) {
    + parent = *n;
    +
    + t = rb_entry(parent, struct dst_trans, trans_entry);
    +
    + cmp = dst_trans_cmp(t->gen, new->gen);
    + if (cmp < 0)
    + n = &parent->rb_left;
    + else if (cmp > 0)
    + n = &parent->rb_right;
    + else {
    + ret = t;
    + break;
    + }
    + }
    +
    + new->send_time = jiffies;
    + if (ret) {
    + printk("%s: exist: old: gen: %llu, bio: %llu/%u, send_time: %lu, "
    + "new: gen: %llu, bio: %llu/%u, send_time: %lu.\n",
    + __func__,
    + ret->gen, (u64)ret->bio->bi_sector,
    + ret->bio->bi_size, ret->send_time,
    + new->gen, (u64)new->bio->bi_sector,
    + new->bio->bi_size, new->send_time);
    + return -EEXIST;
    + }
    +
    + rb_link_node(&new->trans_entry, parent, n);
    + rb_insert_color(&new->trans_entry, root);
    +
    + dprintk("%s: inserted: gen: %llu, bio: %llu/%u, send_time: %lu.\n",
    + __func__, new->gen, (u64)new->bio->bi_sector,
    + new->bio->bi_size, new->send_time);
    +
    + return 0;
    +}
    +
    +int dst_trans_remove_nolock(struct dst_trans *t)
    +{
    + struct dst_node *n = t->n;
    +
    + if (t->trans_entry.rb_parent_color) {
    + rb_erase(&t->trans_entry, &n->trans_root);
    + t->trans_entry.rb_parent_color = 0;
    + }
    + return 0;
    +}
    +
    +int dst_trans_remove(struct dst_trans *t)
    +{
    + int ret;
    + struct dst_node *n = t->n;
    +
    + mutex_lock(&n->trans_lock);
    + ret = dst_trans_remove_nolock(t);
    + mutex_unlock(&n->trans_lock);
    +
    + return ret;
    +}
    +
    +/*
    + * When transaction is completed and there are no more users,
    + * we complete appriate block IO request with given error status.
    + */
    +void dst_trans_put(struct dst_trans *t)
    +{
    + if (atomic_dec_and_test(&t->refcnt)) {
    + struct bio *bio = t->bio;
    +
    + dprintk("%s: completed t: %p, gen: %llu, bio: %p.\n",
    + __func__, t, t->gen, bio);
    +
    + bio_endio(bio, t->error);
    + bio_put(bio);
    +
    + dst_node_put(t->n);
    + mempool_free(t, t->n->trans_pool);
    + }
    +}
    +
    +/*
    + * Process given block IO request: allocate transaction, insert it into the tree
    + * and send/schedule crypto processing.
    + */
    +int dst_process_bio(struct dst_node *n, struct bio *bio)
    +{
    + struct dst_trans *t;
    + int err = -ENOMEM;
    +
    + t = mempool_alloc(n->trans_pool, GFP_NOFS);
    + if (!t)
    + goto err_out_exit;
    +
    + t->n = dst_node_get(n);
    + t->bio = bio;
    + t->error = 0;
    + t->retries = 0;
    + atomic_set(&t->refcnt, 1);
    + t->gen = atomic_long_inc_return(&n->gen);
    +
    + t->enc = bio_data_dir(bio);
    + dst_bio_to_cmd(bio, &t->cmd, DST_IO, t->gen);
    +
    + mutex_lock(&n->trans_lock);
    + err = dst_trans_insert(t);
    + mutex_unlock(&n->trans_lock);
    + if (err)
    + goto err_out_free;
    +
    + dprintk("%s: gen: %llu, bio: %llu/%u, dir/enc: %d, need_crypto: %d.\n",
    + __func__, t->gen, (u64)bio->bi_sector,
    + bio->bi_size, t->enc, dst_need_crypto(n));
    +
    + if (dst_need_crypto(n) && t->enc)
    + dst_trans_crypto(t);
    + else
    + dst_trans_send(t);
    +
    + return 0;
    +
    +err_out_free:
    + dst_node_put(n);
    + mempool_free(t, n->trans_pool);
    +err_out_exit:
    + bio_endio(bio, err);
    + bio_put(bio);
    + return err;
    +}
    +
    +/*
    + * Scan for timeout/stale transactions.
    + * Each transaction is being resent multiple times before error completion.
    + */
    +static void dst_trans_scan(struct work_struct *work)
    +{
    + struct dst_node *n = container_of(work, struct dst_node, trans_work.work);
    + struct rb_node *rb_node;
    + struct dst_trans *t;
    + unsigned long timeout = n->trans_scan_timeout;
    + int num = 10 * n->trans_max_retries;
    +
    + mutex_lock(&n->trans_lock);
    +
    + for (rb_node = rb_first(&n->trans_root); rb_node; ) {
    + t = rb_entry(rb_node, struct dst_trans, trans_entry);
    +
    + if (timeout && time_after(t->send_time + timeout, jiffies)
    + && t->retries == 0)
    + break;
    +#if 0
    + dprintk("%s: t: %p, gen: %llu, n: %s, retries: %u, max: %u.\n",
    + __func__, t, t->gen, n->name,
    + t->retries, n->trans_max_retries);
    +#endif
    + if (--num == 0)
    + break;
    +
    + dst_trans_get(t);
    +
    + rb_node = rb_next(rb_node);
    +
    + if (timeout && (++t->retries < n->trans_max_retries)) {
    + dst_trans_send(t);
    + } else {
    + t->error = -ETIMEDOUT;
    + dst_trans_remove_nolock(t);
    + dst_trans_put(t);
    + }
    +
    + dst_trans_put(t);
    + }
    +
    + mutex_unlock(&n->trans_lock);
    +
    + /*
    + * If no timeout specified then system is in the middle of exiting process,
    + * so no need to reschedule scanning process again.
    + */
    + if (timeout) {
    + if (!num)
    + timeout = HZ;
    + schedule_delayed_work(&n->trans_work, timeout);
    + }
    +}
    +
    +/*
    + * Flush all transactions and mark them as timed out.
    + * Destroy transaction pools.
    + */
    +void dst_node_trans_exit(struct dst_node *n)
    +{
    + struct dst_trans *t;
    + struct rb_node *rb_node;
    +
    + if (!n->trans_cache)
    + return;
    +
    + dprintk("%s: n: %p, cancelling the work.\n", __func__, n);
    + cancel_delayed_work_sync(&n->trans_work);
    + flush_scheduled_work();
    + dprintk("%s: n: %p, work has been cancelled.\n", __func__, n);
    +
    + for (rb_node = rb_first(&n->trans_root); rb_node; ) {
    + t = rb_entry(rb_node, struct dst_trans, trans_entry);
    +
    + dprintk("%s: t: %p, gen: %llu, n: %s.\n",
    + __func__, t, t->gen, n->name);
    +
    + rb_node = rb_next(rb_node);
    +
    + t->error = -ETIMEDOUT;
    + dst_trans_remove_nolock(t);
    + dst_trans_put(t);
    + }
    +
    + mempool_destroy(n->trans_pool);
    + kmem_cache_destroy(n->trans_cache);
    +}
    +
    +/*
    + * Initialize transaction storage for given node.
    + * Transaction stores not only control information,
    + * but also network command and crypto data (if needed)
    + * to reduce number of allocations. Thus transaction size
    + * differs from node to node.
    + */
    +int dst_node_trans_init(struct dst_node *n, unsigned int size)
    +{
    + /*
    + * We need this, since node with given name can be dropped from the
    + * hash table, but be still alive, so subsequent creation of the node
    + * with the same name may collide with existing cache name.
    + */
    +
    + snprintf(n->cache_name, sizeof(n->cache_name), "%s-%p", n->name, n);
    +
    + n->trans_cache = kmem_cache_create(n->cache_name,
    + size + n->crypto.crypto_attached_size,
    + 0, 0, NULL);
    + if (!n->trans_cache)
    + goto err_out_exit;
    +
    + n->trans_pool = mempool_create_slab_pool(dst_mempool_num, n->trans_cache);
    + if (!n->trans_pool)
    + goto err_out_cache_destroy;
    +
    + mutex_init(&n->trans_lock);
    + n->trans_root = RB_ROOT;
    +
    + INIT_DELAYED_WORK(&n->trans_work, dst_trans_scan);
    + schedule_delayed_work(&n->trans_work, n->trans_scan_timeout);
    +
    + dprintk("%s: n: %p, size: %u, crypto: %u.\n",
    + __func__, n, size, n->crypto.crypto_attached_size);
    +
    + return 0;
    +
    +err_out_cache_destroy:
    + kmem_cache_destroy(n->trans_cache);
    +err_out_exit:
    + return -ENOMEM;
    +}
    diff --git a/include/linux/connector.h b/include/linux/connector.h
    index 5c7f946..1980f08 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 0000000..83b2ba0
    --- /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 */

    \
     
     \ /
      Last update: 2008-11-25 15:53    [W:0.134 / U:64.504 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site