lkml.org 
[lkml]   [2008]   [Sep]   [8]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: New distributed storage release.
On Mon, 8 Sep 2008, Evgeniy Polyakov wrote:

> Hi.
>
> I am pleased to announce new Distributed Storage (DST) project release.
>
> DST is a block layer network device, which among others has following
> features:
>
> * Kernel-side client and server. No need for any special tools for
> data processing (like special userspace applications) except
> for configuration.
> * Bullet-proof memory allocations via memory pools for all temporary
> objects (transaction and so on).
> * Zero-copy sending (except header) if supported by device
> using sendpage().
> * Failover recovery in case of broken link
> (reconnection if remote node is down).
> * Full transaction support (resending of the failed transactions
> on timeout of after reconnect to failed node).
> * Dynamically resizeable pool of threads used for data receiving
> and crypto processing.
> * Initial autoconfiguration. Ability to extend it with additional
> attributes if needed.
> * Support for any kind of network media (not limited to tcp or inet
> protocols) higher MAC layer (socket layer). Out of the box
> kernel-side IPv6 support (needs to extend configuration utility,
> check how it was done in POHMELFS [1]).
> * Security attributes for local export nodes (list of allowed to
> connect addresses with permissions).
> * Ability to use any supported cryptographically strong checksums.
> Ability to encrypt data channel.
>
> This release brings following changes:
> * Permission checks in export node. Read-only connections.
> * Remove DST node from the global table not only when it is freed, but
> also on demand with node del command.
>
> I belive project is completed. Consider for inclusion.

Some warnings:

CC [M] drivers/block/dst/state.o
drivers/block/dst/state.c: In function 'dst_recv_bio':
drivers/block/dst/state.c:396: warning: format '%llu' expects type 'long long unsigned int', but argument 3 has type 'sector_t'
drivers/block/dst/state.c: In function 'dst_process_io_response':
drivers/block/dst/state.c:434: warning: format '%llu' expects type 'long long unsigned int', but argument 3 has type 'sector_t'
CC [M] drivers/block/dst/export.o
drivers/block/dst/export.c: In function 'dst_accept':
drivers/block/dst/export.c:249: warning: 'main' is usually a function
drivers/block/dst/export.c: In function 'dst_export_read_request':
drivers/block/dst/export.c:405: warning: format '%llu' expects type 'long long unsigned int', but argument 3 has type 'sector_t'
drivers/block/dst/export.c: In function 'dst_process_io':
drivers/block/dst/export.c:520: warning: format '%llu' expects type 'long long unsigned int', but argument 3 has type 'sector_t'
drivers/block/dst/export.c: In function 'dst_export_send_bio':
drivers/block/dst/export.c:541: warning: format '%llu' expects type 'long long unsigned int', but argument 4 has type 'sector_t'
CC [M] drivers/block/dst/crypto.o
drivers/block/dst/crypto.c: In function 'dst_export_crypto_action':
drivers/block/dst/crypto.c:623: warning: format '%llu' expects type 'long long unsigned int', but argument 5 has type 'sector_t'
CC [M] drivers/block/dst/trans.o
drivers/block/dst/trans.c: In function 'dst_trans_insert':
drivers/block/dst/trans.c:87: warning: format '%llu' expects type 'long long unsigned int', but argument 4 has type 'sector_t'
drivers/block/dst/trans.c:87: warning: format '%llu' expects type 'long long unsigned int', but argument 8 has type 'sector_t'
drivers/block/dst/trans.c:95: warning: format '%llu' expects type 'long long unsigned int', but argument 4 has type 'sector_t'
drivers/block/dst/trans.c: In function 'dst_process_bio':
drivers/block/dst/trans.c:160: warning: format '%llu' expects type 'long long unsigned int', but argument 4 has type 'sector_t'

Also please run the code through checkpatch.pl. Some more comments down in the
code below.

> One can grab sources (various configuration examples can be found
> in 'userspace' dir) from archive, or via kernel and userspace GIT trees.
>
> 1. POHMELFS homepage.
> http://tservice.net.ru/~s0mbre/old/?section=projects&item=pohmelfs
>
> 2. DST homepage.
> http://tservice.net.ru/~s0mbre/old/?section=projects&item=dst
>
> 3. DST archive.
> http://tservice.net.ru/~s0mbre/archive/dst/
>
> 4. DST git trees.
> http://tservice.net.ru/~s0mbre/archive/dst/dst.git/
> http://tservice.net.ru/~s0mbre/archive/dst/dst-userspace.git/
>
> Signed-off-by: Evgeniy Polyakov <johnpol@2ka.mipt.ru>
>
> diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
> index 0d1d213..56a64fe 100644
> --- a/drivers/block/Kconfig
> +++ b/drivers/block/Kconfig
> @@ -433,4 +433,6 @@ config VIRTIO_BLK
> This is the virtual block driver for virtio. It can be used with
> lguest or QEMU based VMMs (like KVM or Xen). Say Y or M.
>
> +source "drivers/block/dst/Kconfig"
> +
> endif # BLK_DEV
> diff --git a/drivers/block/Makefile b/drivers/block/Makefile
> index 5e58430..26bcf8a 100644
> --- a/drivers/block/Makefile
> +++ b/drivers/block/Makefile
> @@ -31,3 +31,5 @@ obj-$(CONFIG_BLK_DEV_SX8) += sx8.o
> obj-$(CONFIG_BLK_DEV_UB) += ub.o
>
> obj-$(CONFIG_XEN_BLKDEV_FRONTEND) += xen-blkfront.o
> +
> +obj-$(CONFIG_DST) += dst/
> diff --git a/drivers/block/dst/Kconfig b/drivers/block/dst/Kconfig
> new file mode 100644
> index 0000000..0b641f0
> --- /dev/null
> +++ b/drivers/block/dst/Kconfig
> @@ -0,0 +1,18 @@
> +menuconfig DST

uhm, menuconfig, and then just the debug option there seems wrong.

> + tristate "Distributed storage"
> + depends on NET
> + select CONNECTOR
> + select LIBCRC32C
> + ---help---
> + This driver allows to create a distributed storage block device.
> +
> +if DST
> +
> +config DST_DEBUG
> + bool "DST debug"
> + depends on DST
> + ---help---
> + This option will turn HEAVY debugging of the DST.
> + Turn it on ONLY if you have to debug some really obscure problem.
> +
> +endif # DST
> diff --git a/drivers/block/dst/Makefile b/drivers/block/dst/Makefile
> new file mode 100644
> index 0000000..526fc62
> --- /dev/null
> +++ b/drivers/block/dst/Makefile
> @@ -0,0 +1,3 @@
> +obj-$(CONFIG_DST) += dst.o
> +
> +dst-y := dcore.o state.o export.o thread_pool.o crypto.o trans.o
> diff --git a/drivers/block/dst/crypto.c b/drivers/block/dst/crypto.c
> new file mode 100644
> index 0000000..7d86fae
> --- /dev/null
> +++ b/drivers/block/dst/crypto.c
> @@ -0,0 +1,767 @@
> +/*
> + * 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.
> + */
> +
> +#include <linux/bio.h>
> +#include <linux/crypto.h>
> +#include <linux/dst.h>
> +#include <linux/kernel.h>
> +#include <linux/scatterlist.h>
> +#include <linux/slab.h>
> +
> +static inline u64 dst_gen_iv(struct dst_trans *t)
> +{
> + return t->gen;
> +}
> +
> +static struct crypto_hash *dst_init_hash(struct dst_crypto_ctl *ctl, u8 *key)
> +{
> + int err;
> + struct crypto_hash *hash;
> +
> + hash = crypto_alloc_hash(ctl->hash_algo, 0, CRYPTO_ALG_ASYNC);
> + if (IS_ERR(hash)) {
> + err = PTR_ERR(hash);
> + dprintk("%s: failed to allocate hash '%s', err: %d.\n",
> + __func__, ctl->hash_algo, err);
> + goto err_out_exit;
> + }
> +
> + ctl->crypto_attached_size = crypto_hash_digestsize(hash);
> +
> + dprintk("%s: keysize: %u, key: ", __func__, ctl->hash_keysize);
> + for (err = 0; err < ctl->hash_keysize; ++err)
> + printk("%02x ", key[err]);
> + printk("\n");

You don't want to print the key unconditional.

> +
> + if (!ctl->hash_keysize)
> + return hash;
> +
> + err = crypto_hash_setkey(hash, key, ctl->hash_keysize);
> + if (err) {
> + dprintk("%s: failed to set key for hash '%s', err: %d.\n",
> + __func__, ctl->hash_algo, err);
> + goto err_out_free;
> + }
> +
> + return hash;
> +
> +err_out_free:
> + crypto_free_hash(hash);
> +err_out_exit:
> + return ERR_PTR(err);
> +}
> +
> +static struct crypto_ablkcipher *dst_init_cipher(struct dst_crypto_ctl *ctl, u8 *key)
> +{
> + int err = -EINVAL;

Needless initialization. There are more in the code.

> + struct crypto_ablkcipher *cipher;
> +
> + if (!ctl->cipher_keysize)
> + goto err_out_exit;
> +
> + cipher = crypto_alloc_ablkcipher(ctl->cipher_algo, 0, 0);
> + if (IS_ERR(cipher)) {
> + err = PTR_ERR(cipher);
> + dprintk("%s: failed to allocate cipher '%s', err: %d.\n",
> + __func__, ctl->cipher_algo, err);
> + goto err_out_exit;
> + }
> +
> + crypto_ablkcipher_clear_flags(cipher, ~0);
> +
> + err = crypto_ablkcipher_setkey(cipher, key, ctl->cipher_keysize);
> + if (err) {
> + dprintk("%s: failed to set key for cipher '%s', err: %d.\n",
> + __func__, ctl->cipher_algo, err);
> + goto err_out_free;
> + }
> +
> + return cipher;
> +
> +err_out_free:
> + crypto_free_ablkcipher(cipher);
> +err_out_exit:
> + return ERR_PTR(err);
> +}
> +
> +static void dst_crypto_pages_free(struct dst_crypto_engine *e)
> +{
> + unsigned int i;
> +
> + for (i=0; i<e->page_num; ++i)
> + __free_page(e->pages[i]);
> + kfree(e->pages);
> +}
> +
> +static int dst_crypto_pages_alloc(struct dst_crypto_engine *e, int num)
> +{
> + int i;
> +
> + e->pages = kmalloc(num * sizeof(struct page **), GFP_KERNEL);
> + if (!e->pages)
> + return -ENOMEM;
> +
> + for (i=0; i<num; ++i) {
> + e->pages[i] = alloc_page(GFP_KERNEL);
> + if (!e->pages[i])
> + goto err_out_free_pages;
> + }
> +
> + e->page_num = num;
> + return 0;
> +
> +err_out_free_pages:
> + while (--i >= 0)
> + __free_page(e->pages[i]);
> +
> + kfree(e->pages);
> + return -ENOMEM;
> +}
> +
> +static int dst_crypto_engine_init(struct dst_crypto_engine *e, struct dst_node *n)
> +{
> + int err;
> + struct dst_crypto_ctl *ctl = &n->crypto;
> +
> + err = dst_crypto_pages_alloc(e, n->max_pages);
> + if (err)
> + goto err_out_exit;
> +
> + e->size = PAGE_SIZE;
> + e->data = kmalloc(e->size, GFP_KERNEL);
> + if (!e->data) {
> + err = -ENOMEM;
> + goto err_out_free_pages;
> + }
> +
> + if (ctl->hash_algo[0]) {
> + e->hash = dst_init_hash(ctl, n->hash_key);
> + if (IS_ERR(e->hash)) {
> + err = PTR_ERR(e->hash);
> + e->hash = NULL;
> + goto err_out_free;
> + }
> + }
> +
> + if (ctl->cipher_algo[0]) {
> + e->cipher = dst_init_cipher(ctl, n->cipher_key);
> + if (IS_ERR(e->cipher)) {
> + err = PTR_ERR(e->cipher);
> + e->cipher = NULL;
> + goto err_out_free_hash;
> + }
> + }
> +
> + return 0;
> +
> +err_out_free_hash:
> + crypto_free_hash(e->hash);
> +err_out_free:
> + kfree(e->data);
> +err_out_free_pages:
> + dst_crypto_pages_free(e);
> +err_out_exit:
> + return err;
> +}
> +
> +static void dst_crypto_engine_exit(struct dst_crypto_engine *e)
> +{
> + if (e->hash)
> + crypto_free_hash(e->hash);
> + if (e->cipher)
> + crypto_free_ablkcipher(e->cipher);
> + dst_crypto_pages_free(e);
> + kfree(e->data);
> +}
> +
> +struct dst_crypto_completion
> +{
> + struct completion complete;
> + int error;
> +};
> +
> +static void dst_crypto_complete(struct crypto_async_request *req, int err)
> +{
> + struct dst_crypto_completion *c = req->data;
> +
> + if (err == -EINPROGRESS)
> + return;
> +
> + dprintk("%s: req: %p, err: %d.\n", __func__, req, err);
> + c->error = err;
> + complete(&c->complete);
> +}
> +
> +static int dst_crypto_process(struct ablkcipher_request *req,
> + struct scatterlist *sg_dst, struct scatterlist *sg_src,
> + void *iv, int enc, unsigned long timeout)
> +{
> + struct dst_crypto_completion c;
> + int err;
> +
> + init_completion(&c.complete);
> + c.error = -EINPROGRESS;
> +
> + ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
> + dst_crypto_complete, &c);
> +
> + ablkcipher_request_set_crypt(req, sg_src, sg_dst, sg_src->length, iv);
> +
> + if (enc)
> + err = crypto_ablkcipher_encrypt(req);
> + else
> + err = crypto_ablkcipher_decrypt(req);
> +
> + switch (err) {
> + case -EINPROGRESS:
> + case -EBUSY:
> + err = wait_for_completion_interruptible_timeout(&c.complete,
> + timeout);
> + if (!err)
> + err = -ETIMEDOUT;
> + else
> + err = c.error;
> + break;
> + default:
> + break;
> + }
> +
> + return err;
> +}
> +
> +static int dst_trans_iter_out(struct bio *bio, struct dst_crypto_engine *e,
> + int (* iterator) (struct dst_crypto_engine *e,
> + struct scatterlist *dst,
> + struct scatterlist *src))
> +{
> + struct bio_vec *bv;
> + int err, i;
> +
> + sg_init_table(e->src, bio->bi_vcnt);
> + sg_init_table(e->dst, bio->bi_vcnt);
> +
> + bio_for_each_segment(bv, bio, i) {
> + sg_set_page(&e->src[i], bv->bv_page, bv->bv_len, bv->bv_offset);
> + sg_set_page(&e->dst[i], e->pages[i], bv->bv_len, bv->bv_offset);
> +
> + err = iterator(e, &e->dst[i], &e->src[i]);
> + if (err)
> + return err;
> + }
> +
> + return 0;
> +}
> +
> +static int dst_trans_iter_in(struct bio *bio, struct dst_crypto_engine *e,
> + int (* iterator) (struct dst_crypto_engine *e,
> + struct scatterlist *dst,
> + struct scatterlist *src))
> +{
> + struct bio_vec *bv;
> + int err, i;
> +
> + sg_init_table(e->src, bio->bi_vcnt);
> + sg_init_table(e->dst, bio->bi_vcnt);
> +
> + bio_for_each_segment(bv, bio, i) {
> + sg_set_page(&e->src[i], bv->bv_page, bv->bv_len, bv->bv_offset);
> + sg_set_page(&e->dst[i], bv->bv_page, bv->bv_len, bv->bv_offset);
> +
> + err = iterator(e, &e->dst[i], &e->src[i]);
> + if (err)
> + return err;
> + }
> +
> + return 0;
> +}
> +
> +static int dst_crypt_iterator(struct dst_crypto_engine *e,
> + struct scatterlist *sg_dst, struct scatterlist *sg_src)
> +{
> + struct ablkcipher_request *req = e->data;
> + u8 iv[32];
> +
> + memset(iv, 0, sizeof(iv));
> +
> + memcpy(iv, &e->iv, sizeof(e->iv));
> +
> + return dst_crypto_process(req, sg_dst, sg_src, iv, e->enc, e->timeout);
> +}
> +
> +static int dst_crypt(struct dst_crypto_engine *e, struct bio *bio)
> +{
> + struct ablkcipher_request *req = e->data;
> +
> + memset(req, 0, sizeof(struct ablkcipher_request));

sizeof(*req) is preferred, likewise for other sizeof() uses in the code.

> + ablkcipher_request_set_tfm(req, e->cipher);
> +
> + if (e->enc)
> + return dst_trans_iter_out(bio, e, dst_crypt_iterator);
> + else
> + return dst_trans_iter_in(bio, e, dst_crypt_iterator);
> +}
> +
> +static int dst_hash_iterator(struct dst_crypto_engine *e,
> + struct scatterlist *sg_dst, struct scatterlist *sg_src)
> +{
> + return crypto_hash_update(e->data, sg_src, sg_src->length);
> +}
> +
> +static int dst_hash(struct dst_crypto_engine *e, struct bio *bio, void *dst)
> +{
> + struct hash_desc *desc = e->data;
> + int err;
> +
> + desc->tfm = e->hash;
> + desc->flags = 0;
> +
> + err = crypto_hash_init(desc);
> + if (err)
> + return err;
> +
> + err = dst_trans_iter_in(bio, e, dst_hash_iterator);
> + if (err)
> + return err;
> +
> + err = crypto_hash_final(desc, dst);
> + if (err)
> + return err;
> +
> + return 0;
> +}
> +
> +static void *dst_crypto_thread_init(void *data)
> +{
> + struct dst_node *n = data;
> + struct dst_crypto_engine *e;
> + int err = -ENOMEM;
> +
> + e = kzalloc(sizeof(struct dst_crypto_engine), GFP_KERNEL);
> + if (!e)
> + goto err_out_exit;
> + e->src = kzalloc(sizeof(struct scatterlist) * 2 * n->max_pages, GFP_KERNEL);
> + if (!e->src)
> + goto err_out_free;
> +
> + e->dst = e->src + n->max_pages;
> +
> + err = dst_crypto_engine_init(e, n);
> + if (err)
> + goto err_out_free;
> +
> + return e;
> +
> +err_out_free:
> + kfree(e->src);
> +err_out_exit:
> + return ERR_PTR(err);
> +}
> +
> +static void dst_crypto_thread_cleanup(void *private)
> +{
> + struct dst_crypto_engine *e = private;
> +
> + dst_crypto_engine_exit(e);
> + kfree(e->src);
> + kfree(e);
> +}
> +
> +int dst_node_crypto_init(struct dst_node *n, struct dst_crypto_ctl *ctl)
> +{
> + void *key = (ctl + 1);
> + int err = -ENOMEM, i;
> + char name[32];
> +
> + if (ctl->hash_keysize) {
> + n->hash_key = kmalloc(ctl->hash_keysize, GFP_KERNEL);
> + if (!n->hash_key)
> + goto err_out_exit;
> + memcpy(n->hash_key, key, ctl->hash_keysize);
> + }
> +
> + if (ctl->cipher_keysize) {
> + n->cipher_key = kmalloc(ctl->cipher_keysize, GFP_KERNEL);
> + if (!n->cipher_key)
> + goto err_out_free_hash;
> + memcpy(n->cipher_key, key, ctl->cipher_keysize);
> + }
> + memcpy(&n->crypto, ctl, sizeof(struct dst_crypto_ctl));
> +
> + for (i=0; i<ctl->thread_num; ++i) {
> + snprintf(name, sizeof(name), "%s-crypto-%d", n->name, i);
> + /* Unique ids... */
> + err = thread_pool_add_worker(n->pool, name, i+10,
> + dst_crypto_thread_init, dst_crypto_thread_cleanup, n);
> + if (err)
> + goto err_out_free_threads;
> + }
> +
> + return 0;
> +
> +err_out_free_threads:
> + while (--i >= 0)
> + thread_pool_del_worker_id(n->pool, i+10);
> +
> + if (ctl->cipher_keysize)
> + kfree(n->cipher_key);
> + ctl->cipher_keysize = 0;
> +err_out_free_hash:
> + if (ctl->hash_keysize)
> + kfree(n->hash_key);
> + ctl->hash_keysize = 0;
> +err_out_exit:
> + return err;
> +}
> +
> +void dst_node_crypto_exit(struct dst_node *n)
> +{
> + struct dst_crypto_ctl *ctl = &n->crypto;
> +
> + if (ctl->cipher_algo[0] || ctl->hash_algo[0]) {

other code uses hash_keysize and cipher_keysize for checking

> + kfree(n->hash_key);
> + kfree(n->cipher_key);
> + }
> +}
> +
> +static int dst_trans_crypto_setup(void *crypto_engine, void *trans)
> +{
> + struct dst_crypto_engine *e = crypto_engine;
> +
> + e->private = trans;
> + return 0;
> +}
> +
> +#if 0
> +static void dst_dump_bio(struct bio *bio)
> +{
> + u8 *p;
> + struct bio_vec *bv;
> + int i;
> +
> + bio_for_each_segment(bv, bio, i) {
> + printk("%s: %llu/%u: size: %u, offset: %u, data: ",
> + __func__, bio->bi_sector, bio->bi_size,
> + bv->bv_len, bv->bv_offset);
> +
> + p = kmap(bv->bv_page) + bv->bv_offset;
> + for (i=0; i<bv->bv_len; ++i)
> + printk("%02x ", p[i]);
> + kunmap(bv->bv_page);
> + printk("\n");
> + }
> +}
> +#endif
> +
> +static int dst_crypto_process_sending(struct dst_crypto_engine *e, struct bio *bio, u8 *hash)
> +{
> + int err;
> +
> + if (e->cipher) {
> + err = dst_crypt(e, bio);
> + if (err)
> + goto err_out_exit;
> + }
> +
> + if (e->hash) {
> + err = dst_hash(e, bio, hash);
> + if (err)
> + goto err_out_exit;
> +
> +#if defined CONFIG_DST_DEBUG
> + {
> + unsigned int i;
> +
> + //dst_dump_bio(bio);
> +
> + printk("%s: bio: %llu/%u, rw: %lu, hash: ",
> + __func__, bio->bi_sector, bio->bi_size, bio_data_dir(bio));
> + for (i=0; i<crypto_hash_digestsize(e->hash); ++i)
> + printk("%02x ", hash[i]);
> + printk("\n");
> + }
> +#endif
> + }
> +
> + return 0;
> +
> +err_out_exit:
> + return err;
> +}
> +
> +static int dst_crypto_process_receiving(struct dst_crypto_engine *e, struct bio *bio, u8 *hash, u8 *recv_hash)
> +{
> + int err;
> +
> + if (e->hash) {
> + int mismatch;
> +
> + err = dst_hash(e, bio, hash);
> + if (err)
> + goto err_out_exit;
> +
> + mismatch = !!memcmp(recv_hash, hash, crypto_hash_digestsize(e->hash));
> +#if defined CONFIG_DST_DEBUG
> + //dst_dump_bio(bio);
> +
> + printk("%s: bio: %llu/%u, rw: %lu, hash mismatch: %d",
> + __func__, bio->bi_sector, bio->bi_size, bio_data_dir(bio), mismatch);
> + if (mismatch) {
> + unsigned int i;
> +
> + printk(", recv/calc: ");
> + for (i=0; i<crypto_hash_digestsize(e->hash); ++i) {
> + printk("%02x/%02x ", recv_hash[i], hash[i]);
> + }
> + }
> + printk("\n");
> +#endif
> + err = -1;
> + if (mismatch)
> + goto err_out_exit;
> + }
> +
> + if (e->cipher) {
> + err = dst_crypt(e, bio);
> + if (err)
> + goto err_out_exit;
> + }
> +
> + return 0;
> +
> +err_out_exit:
> + return err;
> +}
> +
> +static int dst_trans_crypto_action(void *crypto_engine, void *schedule_data)
> +{
> + struct dst_crypto_engine *e = crypto_engine;
> + struct dst_trans *t = schedule_data;
> + struct bio *bio = t->bio;
> + int err;
> +
> + dprintk("%s: t: %p, gen: %llu, cipher: %p, hash: %p.\n", __func__, t, t->gen, e->cipher, e->hash);
> +
> + e->enc = t->enc;
> + e->iv = dst_gen_iv(t);
> +
> + if (bio_data_dir(bio) == WRITE) {
> + err = dst_crypto_process_sending(e, bio, t->cmd.hash);
> + if (err)
> + goto err_out_exit;
> +
> + if (e->hash) {
> + t->cmd.csize = crypto_hash_digestsize(e->hash);
> + t->cmd.size += t->cmd.csize;
> + }
> +
> + return dst_trans_send(t);
> + } else {
> + u8 *hash = e->data + e->size/2;
> +
> + err = dst_crypto_process_receiving(e, bio, hash, t->cmd.hash);
> + if (err)
> + goto err_out_exit;
> +
> + dst_trans_remove(t);
> + dst_trans_put(t);
> + }
> +
> + return 0;
> +
> +err_out_exit:
> + t->error = err;
> + dst_trans_put(t);
> + return err;
> +}
> +
> +int dst_trans_crypto(struct dst_trans *t)
> +{
> + struct dst_node *n = t->n;
> + int err;
> +
> + err = thread_pool_schedule(n->pool,
> + dst_trans_crypto_setup, dst_trans_crypto_action,
> + t, MAX_SCHEDULE_TIMEOUT);
> + if (err)
> + goto err_out_exit;
> +
> + return 0;
> +
> +err_out_exit:
> + dst_trans_put(t);
> + return err;
> +}
> +
> +static int dst_export_crypto_setup(void *crypto_engine, void *bio)
> +{
> + struct dst_crypto_engine *e = crypto_engine;
> +
> + e->private = bio;
> + return 0;
> +}
> +
> +static int dst_export_crypto_action(void *crypto_engine, void *schedule_data)
> +{
> + struct dst_crypto_engine *e = crypto_engine;
> + struct bio *bio = schedule_data;
> + struct dst_export_priv *p = bio->bi_private;
> + int err;
> +
> + dprintk("%s: e: %p, data: %p, bio: %llu/%u, dir: %lu.\n", __func__,
> + e, e->data, bio->bi_sector, bio->bi_size, bio_data_dir(bio));
> +
> + e->enc = (bio_data_dir(bio) == READ);
> + e->iv = p->cmd.id;
> +
> + if (bio_data_dir(bio) == WRITE) {
> + u8 *hash = e->data + e->size/2;
> +
> + err = dst_crypto_process_receiving(e, bio, hash, p->cmd.hash);
> + if (err)
> + goto err_out_exit;
> +
> + generic_make_request(bio);
> + } else {
> + err = dst_crypto_process_sending(e, bio, p->cmd.hash);
> + if (err)
> + goto err_out_exit;
> +
> + if (e->hash) {
> + p->cmd.csize = crypto_hash_digestsize(e->hash);
> + p->cmd.size += p->cmd.csize;
> + }
> +
> + err = dst_export_send_bio(bio);
> + }
> + return 0;
> +
> +err_out_exit:
> + bio_put(bio);
> + return err;
> +}
> +
> +int dst_export_crypto(struct dst_node *n, struct bio *bio)
> +{
> + int err;
> +
> + err = thread_pool_schedule(n->pool,
> + dst_export_crypto_setup, dst_export_crypto_action,
> + bio, MAX_SCHEDULE_TIMEOUT);
> + if (err)
> + goto err_out_exit;
> +
> + return 0;
> +
> +err_out_exit:
> + bio_put(bio);
> + return err;
> +}
> +
> +#if 0
> +static int pohmelfs_crypto_init_handshake(struct pohmelfs_sb *psb)
> +{
> + struct netfs_trans *t;
> + struct netfs_capabilities *cap;
> + struct netfs_cmd *cmd;
> + char *str;
> + int err = -ENOMEM, size;
> +
> + size = sizeof(struct netfs_capabilities) +
> + psb->cipher_strlen + psb->hash_strlen + 2; /* 0 bytes */
> +
> + t = netfs_trans_alloc(psb, size, 0, 0);
> + if (!t)
> + goto err_out_exit;
> +
> + t->complete = pohmelfs_crypt_init_complete;
> + t->private = psb;
> +
> + cmd = netfs_trans_current(t);
> + cap = (struct netfs_capabilities *)(cmd + 1);
> + str = (char *)(cap + 1);
> +
> + cmd->cmd = NETFS_CAPABILITIES;
> + cmd->id = psb->idx;
> + cmd->size = size;
> + cmd->start = 0;
> + cmd->ext = 0;
> + cmd->csize = 0;
> +
> + netfs_convert_cmd(cmd);
> + netfs_trans_update(cmd, t, size);
> +
> + cap->hash_strlen = psb->hash_strlen;
> + if (cap->hash_strlen) {
> + sprintf(str, "%s", psb->hash_algo);
> + str += cap->hash_strlen;
> + }
> +
> + cap->cipher_strlen = psb->cipher_strlen;
> + cap->cipher_keysize = psb->cipher_keysize;
> + if (cap->cipher_strlen)
> + sprintf(str, "%s", psb->cipher_algo);
> +
> + netfs_convert_capabilities(cap);
> +
> + psb->flags = ~0;
> + err = netfs_trans_finish(t, psb);
> + if (err)
> + goto err_out_exit;
> +
> + err = wait_event_interruptible_timeout(psb->wait, (psb->flags != ~0),
> + psb->wait_on_page_timeout);
> + if (!err)
> + err = -ETIMEDOUT;
> + else
> + err = -psb->flags;
> +
> + if (!err)
> + psb->perform_crypto = 1;
> + psb->flags = 0;
> +
> + /*
> + * At this point NETFS_CAPABILITIES response command
> + * should setup superblock in a way, which is acceptible
> + * for both client and server, so if server refuses connection,
> + * it will send error in transaction response.
> + */
> +
> + if (err)
> + goto err_out_exit;
> +
> + return 0;
> +
> +err_out_exit:
> + return err;
> +}
> +
> +int pohmelfs_crypto_init(struct pohmelfs_sb *psb)
> +{
> + int err;
> +
> + if (!psb->cipher_algo && !psb->hash_algo)
> + return 0;
> +
> + err = pohmelfs_crypto_init_handshake(psb);
> + if (err)
> + return err;
> +
> + err = pohmelfs_sys_crypto_init(psb);
> + if (err)
> + return err;
> +
> + return 0;
> +}
> +#endif

Guess this code can be removed, instead of #if 0.

> diff --git a/drivers/block/dst/dcore.c b/drivers/block/dst/dcore.c
> new file mode 100644
> index 0000000..87a8493
> --- /dev/null
> +++ b/drivers/block/dst/dcore.c
> @@ -0,0 +1,815 @@
> +/*
> + * 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.
> + */
> +
> +#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/init.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[] = "Succumbed to live ant.";

const

> +
> +/*
> + * 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)
> +{
> +}
> +
> +static struct device dst_node_dev = {
> + .bus = &dst_dev_bus_type,
> + .release = &dst_node_release
> +};
> +
> +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);
> +}
> +
> +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;
> +
> + n->queue = blk_alloc_queue(GFP_KERNEL);
> + if (!n->queue)
> + goto err_out_exit;
> +
> + n->queue->queuedata = n;
> + blk_queue_max_phys_segments(n->queue, n->max_pages);
> + blk_queue_make_request(n->queue, dst_request);
> + blk_queue_bounce_limit(n->queue, BLK_BOUNCE_ANY);
> +
> + err = -EINVAL;
> + 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);
> + }
> +
> + n->disk->major = dst_major;
> + n->disk->first_minor = (((unsigned long)n->disk) ^
> + (((unsigned long)n->disk) >> 31)) & 0xff;
> + 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-%d", n->name, n->disk->first_minor);
> +
> + return 0;
> +
> +err_out_free_queue:
> + blk_cleanup_queue(n->queue);
> +err_out_exit:
> + return err;
> +}
> +
> +static ssize_t dst_show_size(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + struct dst_node *n = container_of(dev, struct dst_node, device);
> +
> + return sprintf(buf, "%llu\n", n->size);
> +}
> +
> +/*
> + * 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_node *n = container_of(dev, struct dst_node, device);
> + struct sockaddr addr;
> + struct socket *sock;
> + int addrlen;
> +
> + sock = n->state->socket;
> + if (sock->ops->getname(sock, &addr, &addrlen, 2))
> + return 0;
> +
> + if (sock->ops->family == AF_INET) {
> + struct sockaddr_in *sin = (struct sockaddr_in *)&addr;
> + return sprintf(buf, "%u.%u.%u.%u:%d\n",
> + NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
> + } else if (sock->ops->family == AF_INET6) {
> + struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&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;
> + unsigned char *a = (unsigned char *)&addr;
> + char *buf_orig = buf;
> +
> + size = snprintf(buf, sz, "family: %d, addrlen: %u, addr: ",
> + addr.sa_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),
> +};
> +
> +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->device,
> + &dst_node_attrs[i]);

If you really want to ignore the return value, use

(void) device_create_file(...)

> + return 0;
> +}
> +
> +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->device,
> + &dst_node_attrs[i]);
> +}
> +
> +static void dst_node_sysfs_exit(struct dst_node *n)
> +{
> + if (n->device.bus_id[0]) {
> + dst_remove_node_attributes(n);
> + device_unregister(&n->device);
> + memset(&n->device, 0, sizeof(n->device));
> + }
> +}
> +
> +static int dst_node_sysfs_init(struct dst_node *n)
> +{
> + int err;
> +
> + memcpy(&n->device, &dst_node_dev, sizeof(struct device));
> +
> + snprintf(n->device.bus_id, sizeof(n->device.bus_id), "dst-%s", n->name);
> + err = device_register(&n->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:
> + return err;
> +}
> +
> +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);
> +}
> +
> +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);
> + 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;
> +}
> +
> +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);
> + }
> +}
> +
> +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);
> + }
> +}
> +
> +/*
> + * 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;
> +}
> +
> +static int dst_setup_export(struct dst_node *n, struct dst_ctl *ctl,
> + struct dst_export_ctl *le)
> +{
> + int err;
> + dev_t dev;
> +
> + 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;
> +
> + err = dst_node_init_listened(n, le);
> + if (err)
> + goto err_out_cleanup;
> +
> + return 0;
> +
> +err_out_cleanup:
> + sync_blockdev(n->bdev);
> + blkdev_put(n->bdev);
> + n->bdev = NULL;
> +
> + return err;
> +}
> +
> +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);
> +}
> +
> +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);
> +
> + 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;
> +
> + n->max_pages = ctl->max_pages;
> + if (!n->max_pages)
> + n->max_pages = 30;
> +
> + 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;
> +}
> +
> +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);
> + return 0;
> +}
> +
> +/*
> + * Control callback for userspace commands to setup
> + * different nodes and start/stop array.
> + */
> +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;
> +
> + 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;
> +}
> +
> +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);
> +
> + dst_node_put(n);
> + return 0;
> +}
> +
> +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);
> +}
> +
> +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);
> +}
> +
> +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;
> +}
> +
> +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:
> + ack = kmalloc(sizeof(struct dst_ctl_ack), GFP_KERNEL);

struct dst_ctl_ack seems to be quite small, guess there's no need for
dynamic allocation.

> + if (!ack)
> + return;
> +
> + 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);
> + kfree(ack);
> +}
> +
> +static int dst_sysfs_init(void)

__init

> +{
> + 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 = kzalloc(sizeof(struct list_head) * dst_hashtable_size, 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;
> + struct cb_id cn_dst_id = { CN_DST_IDX, CN_DST_VAL };
> +
> + 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)
> +{
> + struct cb_id cn_dst_id = { CN_DST_IDX, CN_DST_VAL };
> +
> + 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 <johnpol@2ka.mipt.ru>");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/block/dst/export.c b/drivers/block/dst/export.c
> new file mode 100644
> index 0000000..09c3326
> --- /dev/null
> +++ b/drivers/block/dst/export.c
> @@ -0,0 +1,572 @@
> +/*
> + * 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.
> + */
> +
> +#include <linux/blkdev.h>
> +#include <linux/bio.h>
> +#include <linux/dst.h>
> +#include <linux/in.h>
> +#include <linux/in6.h>
> +#include <linux/poll.h>
> +#include <linux/slab.h>
> +#include <linux/socket.h>
> +
> +#include <net/sock.h>
> +
> +static struct bio_set *dst_bio_set;
> +
> +int __init dst_export_init(void)
> +{
> + int err = -ENOMEM;
> +
> + dst_bio_set = bioset_create(32, 32);
> + if (!dst_bio_set)
> + goto err_out_exit;
> +
> + return 0;
> +
> +err_out_exit:
> + return err;
> +}
> +
> +void dst_export_exit(void)
> +{
> + bioset_free(dst_bio_set);
> +}
> +
> +static unsigned int dst_check_permissions(struct dst_state *main, struct dst_state *st)
> +{
> + struct dst_node *n = main->node;
> + struct dst_secure *sentry;
> + struct dst_secure_user *s;
> + struct saddr *sa = &st->ctl.addr;
> + unsigned int perm = 0;
> +
> + mutex_lock(&n->security_lock);
> + list_for_each_entry(sentry, &n->security_list, sec_entry) {
> + s = &sentry->sec;
> +
> + if (s->addr.sa_family != sa->sa_family)
> + continue;
> +
> + if (s->addr.sa_data_len != sa->sa_data_len)
> + continue;
> +
> + /*
> + * This '2' below is a port field. This may be very wrong to do
> + * in atalk for example though. If there will be any need to extent
> + * protocol to something else, I can create per-family helpers and
> + * use them instead of this memcmp.
> + */
> + if (memcmp(s->addr.sa_data + 2, sa->sa_data + 2, sa->sa_data_len - 2))
> + continue;
> +
> + perm = s->permissions;
> + }
> + mutex_unlock(&n->security_lock);
> +
> + return perm;
> +}
> +
> +static struct dst_state *dst_accept_client(struct dst_state *st)
> +{
> + unsigned int revents = 0;
> + unsigned int err_mask = POLLERR | POLLHUP | POLLRDHUP;
> + unsigned int mask = err_mask | POLLIN;
> + struct dst_node *n = st->node;
> + int err = 0;
> + struct socket *sock = NULL;
> + struct dst_state *new;
> +
> + while (!err && !sock) {
> + revents = dst_state_poll(st);
> +
> + if (!(revents & mask)) {
> + DEFINE_WAIT(wait);
> +
> + for (;;) {
> + prepare_to_wait(&st->thread_wait, &wait, TASK_INTERRUPTIBLE);
> + if (!n->trans_scan_timeout || st->need_exit)
> + break;
> +
> + revents = dst_state_poll(st);
> +
> + if (revents & mask)
> + break;
> +
> + if (signal_pending(current))
> + break;
> +
> + schedule_timeout(HZ);
> + }
> + finish_wait(&st->thread_wait, &wait);
> + }
> +
> + err = -ECONNRESET;
> + dst_state_lock(st);
> +
> + dprintk("%s: st: %p, revents: %x [err: %d, in: %d].\n",
> + __func__, st, revents, revents & err_mask, revents & POLLIN);
> +
> + if (revents & err_mask) {
> + printk("%s: revents: %x, socket: %p, err: %d.\n",
> + __func__, revents, st->socket, err);
> + err = -ECONNRESET;
> + }
> +
> + if (!n->trans_scan_timeout || st->need_exit)
> + err = -ENODEV;
> +
> + if (st->socket && (revents & POLLIN))
> + err = kernel_accept(st->socket, &sock, 0);
> +
> + dst_state_unlock(st);
> + }
> +
> + if (err)
> + goto err_out_exit;
> +
> + new = dst_state_alloc(st->node);
> + if (!new) {
> + err = -ENOMEM;
> + goto err_out_release;
> + }
> + new->socket = sock;
> +
> + new->ctl.addr.sa_data_len = sizeof(struct sockaddr);
> + err = kernel_getpeername(sock, (struct sockaddr *)&new->ctl.addr,
> + (int *)&new->ctl.addr.sa_data_len);
> + if (err)
> + goto err_out_put;
> +
> + new->permissions = dst_check_permissions(st, new);
> + if (new->permissions == 0) {
> + err = -EPERM;
> + dst_dump_addr(sock, (struct sockaddr *)&new->ctl.addr, "Client is not allowed to connect");
> + goto err_out_put;
> + }
> +
> + err = dst_poll_init(new);
> + if (err)
> + goto err_out_put;
> +
> + dst_dump_addr(sock, (struct sockaddr *)&new->ctl.addr, "Connected client");
> +
> + return new;
> +
> +err_out_put:
> + dst_state_put(new);
> +err_out_release:
> + sock_release(sock);
> +err_out_exit:
> + return ERR_PTR(err);
> +}
> +
> +static int dst_export_process_request_queue(struct dst_state *st)
> +{
> + unsigned long flags;
> + struct dst_export_priv *p = NULL;
> + struct bio *bio;
> + int err = 0;
> +
> + while (!list_empty(&st->request_list)) {
> + spin_lock_irqsave(&st->request_lock, flags);
> + if (!list_empty(&st->request_list)) {
> + p = list_first_entry(&st->request_list, struct dst_export_priv, request_entry);
> + list_del(&p->request_entry);
> + }
> + spin_unlock_irqrestore(&st->request_lock, flags);
> +
> + if (!p)
> + break;
> +
> + bio = p->bio;
> +
> + if (dst_need_crypto(st->node) && (bio_data_dir(bio) == READ))
> + err = dst_export_crypto(st->node, bio);
> + else
> + err = dst_export_send_bio(bio);
> +
> + if (err)
> + break;
> + }
> +
> + return err;
> +}
> +
> +static void dst_state_cleanup_export(struct dst_state *st)
> +{
> + struct dst_export_priv *p;
> + unsigned long flags;
> +
> + /*
> + * This loop waits for all pending bios to be completed and freed.
> + */
> + while (atomic_read(&st->refcnt) > 1) {
> + dprintk("%s: st: %p, refcnt: %d, list_empty: %d.\n",
> + __func__, st, atomic_read(&st->refcnt),
> + list_empty(&st->request_list));
> + wait_event_timeout(st->thread_wait,
> + (atomic_read(&st->refcnt) == 1) ||
> + !list_empty(&st->request_list),
> + HZ/2);
> +
> + while (!list_empty(&st->request_list)) {
> + p = NULL;
> + spin_lock_irqsave(&st->request_lock, flags);
> + if (!list_empty(&st->request_list)) {
> + p = list_first_entry(&st->request_list,
> + struct dst_export_priv, request_entry);
> + list_del(&p->request_entry);
> + }
> + spin_unlock_irqrestore(&st->request_lock, flags);
> +
> + if (p)
> + bio_put(p->bio);
> +
> + dprintk("%s: st: %p, refcnt: %d, list_empty: %d, p: %p.\n",
> + __func__, st, atomic_read(&st->refcnt),
> + list_empty(&st->request_list), p);
> + }
> + }
> +
> + dst_state_put(st);
> +}
> +
> +static int dst_accept(void *init_data, void *schedule_data)
> +{
> + struct dst_state *main = schedule_data;
> + struct dst_node *n = init_data;
> + struct dst_state *st;
> + int err;
> +
> + while (n->trans_scan_timeout && !main->need_exit) {
> + dprintk("%s: main: %p, n: %p.\n", __func__, main, n);
> + st = dst_accept_client(main);
> + if (IS_ERR(st))
> + continue;
> +
> + err = dst_state_schedule_receiver(st);
> + if (!err) {
> + while (n->trans_scan_timeout) {
> + err = wait_event_interruptible_timeout(st->thread_wait,
> + !list_empty(&st->request_list) ||
> + !n->trans_scan_timeout ||
> + st->need_exit,
> + HZ);
> +
> + if (!n->trans_scan_timeout || st->need_exit)
> + break;
> +
> + if (list_empty(&st->request_list))
> + continue;
> +
> + err = dst_export_process_request_queue(st);
> + if (err)
> + break;
> + }
> +
> + st->need_exit = 1;
> + wake_up(&st->thread_wait);
> + }
> +
> + dst_state_cleanup_export(st);
> + }
> +
> + dprintk("%s: freeing listening socket st: %p.\n", __func__, main);
> +
> + dst_state_lock(main);
> + dst_poll_exit(main);
> + dst_state_socket_release(main);
> + dst_state_unlock(main);
> + dst_state_put(main);
> + dprintk("%s: freed listening socket st: %p.\n", __func__, main);
> +
> + return 0;
> +}
> +
> +int dst_start_export(struct dst_node *n)
> +{
> + return dst_node_trans_init(n, sizeof(struct dst_export_priv));
> +}
> +
> +int dst_node_init_listened(struct dst_node *n, struct dst_export_ctl *le)
> +{
> + struct dst_state *st;
> + int err = -ENOMEM;
> + struct dst_network_ctl *ctl = &le->ctl;
> +
> + st = dst_state_alloc(n);
> + if (IS_ERR(st)) {
> + err = PTR_ERR(st);
> + goto err_out_exit;
> + }
> + memcpy(&st->ctl, ctl, sizeof(struct dst_network_ctl));
> +
> + err = dst_state_socket_create(st);
> + if (err)
> + goto err_out_put;
> +
> + err = kernel_bind(st->socket, (struct sockaddr *)&ctl->addr, ctl->addr.sa_data_len);
> + if (err)
> + goto err_out_socket_release;
> +
> + err = kernel_listen(st->socket, 1024);
> + if (err)
> + goto err_out_socket_release;
> + n->state = st;
> +
> + err = dst_poll_init(st);
> + if (err)
> + goto err_out_socket_release;
> +
> + dst_state_get(st);
> +
> + err = thread_pool_schedule(n->pool, dst_thread_setup,
> + dst_accept, st, MAX_SCHEDULE_TIMEOUT);
> + if (err)
> + goto err_out_poll_exit;
> +
> + return 0;
> +
> +err_out_poll_exit:
> + dst_poll_exit(st);
> +err_out_socket_release:
> + dst_state_socket_release(st);
> +err_out_put:
> + dst_state_put(st);
> +err_out_exit:
> + n->state = NULL;
> + return err;
> +}
> +
> +static void dst_bio_destructor(struct bio *bio)
> +{
> + struct bio_vec *bv;
> + struct dst_export_priv *priv = bio->bi_private;
> + int i;
> +
> + bio_for_each_segment(bv, bio, i) {
> + if (!bv->bv_page)
> + break;
> +
> + __free_page(bv->bv_page);
> + }
> +
> + if (priv) {
> + struct dst_node *n = priv->state->node;
> +
> + dst_state_put(priv->state);
> + mempool_free(priv, n->trans_pool);
> + }
> + bio_free(bio, dst_bio_set);
> +}
> +
> +static void dst_bio_end_io(struct bio *bio, int err)
> +{
> + struct dst_export_priv *p = bio->bi_private;
> + struct dst_state *st = p->state;
> + unsigned long flags;
> +
> + spin_lock_irqsave(&st->request_lock, flags);
> + list_add_tail(&p->request_entry, &st->request_list);
> + spin_unlock_irqrestore(&st->request_lock, flags);
> +
> + wake_up(&st->thread_wait);
> +}
> +
> +static int dst_export_read_request(struct bio *bio, unsigned int total_size)
> +{
> + unsigned int size;
> + struct page *page;
> + int err;
> +
> + while (total_size) {
> + err = -ENOMEM;
> + page = alloc_page(GFP_KERNEL);
> + if (!page)
> + goto err_out_exit;
> +
> + size = min_t(unsigned int, PAGE_SIZE, total_size);
> +
> + err = bio_add_page(bio, page, size, 0);
> + dprintk("%s: bio: %llu/%u, size: %u, err: %d.\n",
> + __func__, bio->bi_sector, bio->bi_size, size, err);
> + if (err <= 0)
> + goto err_out_free_page;
> +
> + total_size -= size;
> + }
> +
> + return 0;
> +
> +err_out_free_page:
> + __free_page(page);
> +err_out_exit:
> + return err;
> +}
> +
> +static int dst_export_write_request(struct dst_state *st, struct bio *bio, unsigned int total_size)
> +{
> + unsigned int size;
> + struct page *page;
> + void *data;
> + int err;
> +
> + while (total_size) {
> + err = -ENOMEM;
> + page = alloc_page(GFP_KERNEL);
> + if (!page)
> + goto err_out_exit;
> +
> + data = kmap(page);
> + if (!data)
> + goto err_out_free_page;
> +
> + size = min_t(unsigned int, PAGE_SIZE, total_size);
> +
> + err = dst_data_recv(st, data, size);
> + if (err)
> + goto err_out_unmap_page;
> +
> + err = bio_add_page(bio, page, size, 0);
> + if (err <= 0)
> + goto err_out_unmap_page;
> +
> + kunmap(page);
> +
> + total_size -= size;
> + }
> +
> + return 0;
> +
> +err_out_unmap_page:
> + kunmap(page);
> +err_out_free_page:
> + __free_page(page);
> +err_out_exit:
> + return err;
> +}
> +
> +int dst_process_io(struct dst_state *st)
> +{
> + struct dst_node *n = st->node;
> + struct dst_cmd *cmd = st->data;
> + struct bio *bio;
> + struct dst_export_priv *priv;
> + int err = -ENOMEM;
> +
> + if (unlikely(!n->bdev)) {
> + err = -EINVAL;
> + goto err_out_exit;
> + }
> +
> + bio = bio_alloc_bioset(GFP_KERNEL, PAGE_ALIGN(cmd->size) >> PAGE_SHIFT, dst_bio_set);
> + if (!bio)
> + goto err_out_exit;
> + bio->bi_private = NULL;
> +
> + priv = mempool_alloc(st->node->trans_pool, GFP_KERNEL);
> + if (!priv)
> + goto err_out_free;
> +
> + priv->state = dst_state_get(st);
> + priv->bio = bio;
> +
> + bio->bi_private = priv;
> + bio->bi_end_io = dst_bio_end_io;
> + bio->bi_destructor = dst_bio_destructor;
> + bio->bi_bdev = n->bdev;
> + bio->bi_flags |= cmd->flags;
> + bio->bi_rw = cmd->rw;
> + bio->bi_size = 0;
> + bio->bi_sector = cmd->sector;
> +
> + dst_bio_to_cmd(bio, &priv->cmd, DST_IO_RESPONSE, cmd->id);
> +
> + priv->cmd.flags = 0;
> + priv->cmd.size = cmd->size;
> +
> + if (bio_data_dir(bio) == WRITE) {
> + err = dst_recv_cdata(st, priv->cmd.hash);
> + if (err)
> + goto err_out_free;
> +
> + err = dst_export_write_request(st, bio, cmd->size);
> + if (err)
> + goto err_out_free;
> +
> + if (dst_need_crypto(n))
> + return dst_export_crypto(n, bio);
> + } else {
> + err = dst_export_read_request(bio, cmd->size);
> + if (err)
> + goto err_out_free;
> + }
> +
> + dprintk("%s: bio: %llu/%u, rw: %lu, dir: %lu.\n",
> + __func__, bio->bi_sector, bio->bi_size,
> + bio->bi_rw, bio_data_dir(bio));
> +
> + generic_make_request(bio);
> +
> + return 0;
> +
> +err_out_free:
> + bio_put(bio);
> +err_out_exit:
> + return err;
> +}
> +
> +int dst_export_send_bio(struct bio *bio)
> +{
> + struct dst_export_priv *p = bio->bi_private;
> + struct dst_state *st = p->state;
> + struct dst_cmd *cmd = &p->cmd;
> + int err;
> +
> + dprintk("%s: id: %llu, bio: %llu/%u, csize: %u, flags: %lu, rw: %lu.\n",
> + __func__, cmd->id, bio->bi_sector, bio->bi_size,
> + cmd->csize, bio->bi_flags, bio->bi_rw);
> +
> + dst_convert_cmd(cmd);
> +
> + dst_state_lock(st);
> + if (!st->socket) {
> + err = -ECONNRESET;
> + goto err_out_unlock;
> + }
> +
> + if (bio_data_dir(bio) == WRITE) {
> + cmd->size = cmd->csize = 0;
> + err = dst_data_send_header(st->socket, cmd, sizeof(struct dst_cmd), 0);
> + if (err)
> + goto err_out_unlock;
> + } else {
> + err = dst_send_bio(st, cmd, bio);
> + if (err)
> + goto err_out_unlock;
> + }
> +
> + dst_state_unlock(st);
> +
> + bio_put(bio);
> + return 0;
> +
> +err_out_unlock:
> + dst_state_unlock(st);
> +
> + bio_put(bio);
> + return err;
> +}
> diff --git a/drivers/block/dst/state.c b/drivers/block/dst/state.c
> new file mode 100644
> index 0000000..2809b51
> --- /dev/null
> +++ b/drivers/block/dst/state.c
> @@ -0,0 +1,742 @@
> +/*
> + * 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.
> + */
> +
> +#include <linux/buffer_head.h>
> +#include <linux/blkdev.h>
> +#include <linux/bio.h>
> +#include <linux/connector.h>
> +#include <linux/dst.h>
> +#include <linux/device.h>
> +#include <linux/in.h>
> +#include <linux/in6.h>
> +#include <linux/socket.h>
> +#include <linux/slab.h>
> +
> +#include <net/sock.h>
> +
> +/*
> + * Polling machinery.
> + */
> +
> +struct dst_poll_helper
> +{
> + poll_table pt;
> + struct dst_state *st;
> +};
> +
> +static int dst_queue_wake(wait_queue_t *wait, unsigned mode, int sync, void *key)
> +{
> + struct dst_state *st = container_of(wait, struct dst_state, wait);
> +
> + wake_up(&st->thread_wait);
> + return 1;
> +}
> +
> +static void dst_queue_func(struct file *file, wait_queue_head_t *whead,
> + poll_table *pt)
> +{
> + struct dst_state *st = container_of(pt, struct dst_poll_helper, pt)->st;
> +
> + st->whead = whead;
> + init_waitqueue_func_entry(&st->wait, dst_queue_wake);
> + add_wait_queue(whead, &st->wait);
> +}
> +
> +void dst_poll_exit(struct dst_state *st)
> +{
> + if (st->whead) {
> + remove_wait_queue(st->whead, &st->wait);
> + st->whead = NULL;
> + }
> +}
> +
> +int dst_poll_init(struct dst_state *st)
> +{
> + struct dst_poll_helper ph;
> +
> + ph.st = st;
> + init_poll_funcptr(&ph.pt, &dst_queue_func);
> +
> + st->socket->ops->poll(NULL, st->socket, &ph.pt);
> + return 0;
> +}
> +
> +/*
> + * Header receiving function - may block.
> + */
> +static int dst_data_recv_header(struct socket *sock,
> + void *data, unsigned int size, int block)
> +{
> + struct msghdr msg;
> + struct kvec iov;
> + int err;
> +
> + iov.iov_base = data;
> + iov.iov_len = size;
> +
> + msg.msg_iov = (struct iovec *)&iov;
> + msg.msg_iovlen = 1;
> + msg.msg_name = NULL;
> + msg.msg_namelen = 0;
> + msg.msg_control = NULL;
> + msg.msg_controllen = 0;
> + msg.msg_flags = (block)?MSG_WAITALL:MSG_DONTWAIT;
> +
> + err = kernel_recvmsg(sock, &msg, &iov, 1, iov.iov_len,
> + msg.msg_flags);
> + if (err != size)
> + return -1;
> +
> + return 0;
> +}
> +
> +/*
> + * Header sending function - may block.
> + */
> +int dst_data_send_header(struct socket *sock,
> + void *data, unsigned int size, int more)
> +{
> + struct msghdr msg;
> + struct kvec iov;
> + int err;
> +
> + iov.iov_base = data;
> + iov.iov_len = size;
> +
> + msg.msg_iov = (struct iovec *)&iov;
> + msg.msg_iovlen = 1;
> + msg.msg_name = NULL;
> + msg.msg_namelen = 0;
> + msg.msg_control = NULL;
> + msg.msg_controllen = 0;
> + msg.msg_flags = MSG_WAITALL | (more)?MSG_MORE:0;
> +
> + err = kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len);
> + if (err != size) {
> + dprintk("%s: size: %u, more: %d, err: %d.\n", __func__, size, more, err);
> + return -1;
> + }
> +
> + return 0;
> +}
> +
> +static int dst_request_remote_config(struct dst_state *st)
> +{
> + struct dst_node *n = st->node;
> + int err = -EINVAL;
> + struct dst_cmd *cmd = st->data;
> +
> + memset(cmd, 0, sizeof(struct dst_cmd));
> + cmd->cmd = DST_CFG;
> +
> + dst_convert_cmd(cmd);
> +
> + err = dst_data_send_header(st->socket, cmd, sizeof(struct dst_cmd), 0);
> + if (err)
> + goto out;
> +
> + err = dst_data_recv_header(st->socket, cmd, sizeof(struct dst_cmd), 1);
> + if (err)
> + goto out;
> +
> + dst_convert_cmd(cmd);
> +
> + if (cmd->cmd != DST_CFG) {
> + err = -EINVAL;
> + printk("%s: checking result: cmd: %d, size reported: %llu.\n",
> + __func__, cmd->cmd, cmd->sector);
> + goto out;
> + }
> +
> + if (n->size != 0)
> + n->size = min_t(loff_t, n->size, cmd->sector);
> + else
> + n->size = cmd->sector;
> +
> + st->permissions = cmd->rw;
> +
> +out:
> + dprintk("%s: n: %p, err: %d, size: %llu, permission: %x.\n",
> + __func__, n, err, n->size, st->permissions);
> + return err;
> +}
> +
> +#define DST_DEFAULT_TIMEO 20000
> +
> +int dst_state_socket_create(struct dst_state *st)
> +{
> + int err;
> + struct socket *sock;
> + struct dst_network_ctl *ctl = &st->ctl;
> +
> + err = sock_create(ctl->addr.sa_family, ctl->type, ctl->proto, &sock);
> + if (err < 0)
> + return err;
> +
> + sock->sk->sk_sndtimeo = sock->sk->sk_rcvtimeo = msecs_to_jiffies(DST_DEFAULT_TIMEO);
> + sock->sk->sk_allocation = GFP_NOIO;
> +
> + st->socket = st->read_socket = sock;
> + return 0;
> +}
> +
> +void dst_state_socket_release(struct dst_state *st)
> +{
> + dprintk("%s: st: %p, socket: %p, n: %p.\n", __func__, st, st->socket, st->node);
> + if (st->socket) {
> + sock_release(st->socket);
> + st->socket = NULL;
> + st->read_socket = NULL;
> + }
> +}
> +
> +void dst_dump_addr(struct socket *sk, struct sockaddr *sa, char *str)
> +{
> + if (sk->ops->family == AF_INET) {
> + struct sockaddr_in *sin = (struct sockaddr_in *)sa;
> + printk(KERN_INFO "%s %u.%u.%u.%u:%d.\n",
> + str, NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
> + } else if (sk->ops->family == AF_INET6) {
> + struct sockaddr_in6 *sin = (struct sockaddr_in6 *)sa;
> + printk(KERN_INFO "%s %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%d",
> + str, NIP6(sin->sin6_addr), ntohs(sin->sin6_port));
> + }
> +}
> +
> +void dst_state_exit_connected(struct dst_state *st)
> +{
> + if (st->socket) {
> + dst_poll_exit(st);
> + st->socket->ops->shutdown(st->socket, 2);
> +
> + dst_dump_addr(st->socket, (struct sockaddr *)&st->ctl.addr, "Disconnected peer");
> + dst_state_socket_release(st);
> + }
> +}
> +
> +static int dst_state_init_connected(struct dst_state *st)
> +{
> + int err;
> + struct dst_network_ctl *ctl = &st->ctl;
> +
> + err = dst_state_socket_create(st);
> + if (err)
> + goto err_out_exit;
> +
> + err = kernel_connect(st->socket, (struct sockaddr *)&st->ctl.addr,
> + st->ctl.addr.sa_data_len, 0);
> + if (err)
> + goto err_out_release;
> +
> + err = dst_poll_init(st);
> + if (err)
> + goto err_out_release;
> +
> + dst_dump_addr(st->socket, (struct sockaddr *)&ctl->addr, "Connected to peer");
> +
> + return 0;
> +
> +err_out_release:
> + dst_state_socket_release(st);
> +err_out_exit:
> + return err;
> +}
> +
> +static void __inline__ dst_state_reset_nolock(struct dst_state *st)
> +{
> + dst_state_exit_connected(st);
> + dst_state_init_connected(st);
> +}
> +
> +static void __inline__ dst_state_reset(struct dst_state *st)
> +{
> + dst_state_lock(st);
> + dst_state_reset_nolock(st);
> + dst_state_unlock(st);
> +}
> +
> +/*
> + * Basic network sending/receiving functions.
> + * Blocked mode is used.
> + */
> +static int dst_data_recv_raw(struct dst_state *st, void *buf, u64 size)
> +{
> + struct msghdr msg;
> + struct kvec iov;
> + int err;
> +
> + BUG_ON(!size);
> +
> + iov.iov_base = buf;
> + iov.iov_len = size;
> +
> + msg.msg_iov = (struct iovec *)&iov;
> + msg.msg_iovlen = 1;
> + msg.msg_name = NULL;
> + msg.msg_namelen = 0;
> + msg.msg_control = NULL;
> + msg.msg_controllen = 0;
> + msg.msg_flags = MSG_DONTWAIT;
> +
> + err = kernel_recvmsg(st->socket, &msg, &iov, 1, iov.iov_len,
> + msg.msg_flags);
> + if (err <= 0) {
> + printk("%s: failed to recv data: size: %llu, err: %d.\n", __func__, size, err);
> + if (err == 0)
> + err = -ECONNRESET;
> +
> + dst_state_exit_connected(st);
> + }
> +
> + return err;
> +}
> +
> +int dst_data_recv(struct dst_state *st, void *data, unsigned int size)
> +{
> + unsigned int revents = 0;
> + unsigned int err_mask = POLLERR | POLLHUP | POLLRDHUP;
> + unsigned int mask = err_mask | POLLIN;
> + struct dst_node *n = st->node;
> + int err = 0;
> +
> + while (size && !err) {
> + revents = dst_state_poll(st);
> +
> + if (!(revents & mask)) {
> + DEFINE_WAIT(wait);
> +
> + for (;;) {
> + prepare_to_wait(&st->thread_wait, &wait, TASK_INTERRUPTIBLE);
> + if (!n->trans_scan_timeout || st->need_exit)
> + break;
> +
> + revents = dst_state_poll(st);
> +
> + if (revents & mask)
> + break;
> +
> + if (signal_pending(current))
> + break;
> +
> + schedule_timeout(HZ);
> + continue;
> + }
> + finish_wait(&st->thread_wait, &wait);
> + }
> +
> + err = -ECONNRESET;
> + dst_state_lock(st);
> +
> + if (st->socket && (st->read_socket == st->socket) && (revents & POLLIN)) {
> + err = dst_data_recv_raw(st, data, size);
> + if (err > 0) {
> + data += err;
> + size -= err;
> + err = 0;
> + }
> + }
> +
> + if (revents & err_mask || !st->socket) {
> + printk("%s: revents: %x, socket: %p, size: %u, err: %d.\n",
> + __func__, revents, st->socket, size, err);
> + err = -ECONNRESET;
> + }
> +
> + dst_state_unlock(st);
> +
> + if (!n->trans_scan_timeout)
> + err = -ENODEV;
> + }
> +
> + return err;
> +}
> +
> +static int dst_process_cfg(struct dst_state *st)
> +{
> + struct dst_node *n = st->node;
> + struct dst_cmd *cmd = st->data;
> + int err;
> +
> + cmd->sector = n->size;
> + cmd->rw = st->permissions;
> +
> + dst_convert_cmd(cmd);
> +
> + dst_state_lock(st);
> + err = dst_data_send_header(st->socket, cmd, sizeof(struct dst_cmd), 0);
> + dst_state_unlock(st);
> +
> + return err;
> +}
> +
> +static int dst_recv_bio(struct dst_state *st, struct bio *bio, unsigned int total_size)
> +{
> + struct bio_vec *bv;
> + int i, err;
> + void *data;
> + unsigned int sz;
> +
> + bio_for_each_segment(bv, bio, i) {
> + sz = min(total_size, bv->bv_len);
> +
> + dprintk("%s: bio: %llu/%u, total: %u, len: %u, sz: %u, off: %u.\n",
> + __func__, bio->bi_sector, bio->bi_size, total_size,
> + bv->bv_len, sz, bv->bv_offset);
> +
> + data = kmap(bv->bv_page) + bv->bv_offset;
> + err = dst_data_recv(st, data, sz);
> + kunmap(bv->bv_page);
> +
> + bv->bv_len = sz;
> +
> + if (err)
> + return err;
> +
> + total_size -= sz;
> + if (total_size == 0)
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static int dst_process_io_response(struct dst_state *st)
> +{
> + struct dst_node *n = st->node;
> + struct dst_cmd *cmd = st->data;
> + struct dst_trans *t;
> + int err = 0;
> + struct bio *bio;
> +
> + mutex_lock(&n->trans_lock);
> + t = dst_trans_search(n, cmd->id);
> + mutex_unlock(&n->trans_lock);
> +
> + if (!t)
> + goto err_out_exit;
> +
> + bio = t->bio;
> +
> + dprintk("%s: bio: %llu/%u, cmd_size: %u, csize: %u, dir: %lu.\n",
> + __func__, bio->bi_sector, bio->bi_size, cmd->size,
> + cmd->csize, bio_data_dir(bio));
> +
> + if (bio_data_dir(bio) == READ) {
> + if (bio->bi_size != cmd->size - cmd->csize)
> + goto err_out_exit;
> +
> + if (dst_need_crypto(n)) {
> + err = dst_recv_cdata(st, t->cmd.hash);
> + if (err)
> + goto err_out_exit;
> + }
> +
> + err = dst_recv_bio(st, t->bio, bio->bi_size);
> + if (err)
> + goto err_out_exit;
> +
> + if (dst_need_crypto(n))
> + return dst_trans_crypto(t);
> + } else {
> + err = -EBADMSG;
> + if (cmd->size || cmd->csize)
> + goto err_out_exit;
> + }
> +
> + dst_trans_remove(t);
> + dst_trans_put(t);
> +
> + return 0;
> +
> +err_out_exit:
> + return err;
> +}
> +
> +int dst_recv_cdata(struct dst_state *st, void *cdata)
> +{
> + struct dst_cmd *cmd = st->data;
> + struct dst_node *n = st->node;
> + struct dst_crypto_ctl *c = &n->crypto;
> + int err;
> +
> + if (cmd->csize != c->crypto_attached_size) {
> + dprintk("%s: cmd: cmd: %u, sector: %llu, size: %u, "
> + "csize: %u != digest size %u.\n",
> + __func__, cmd->cmd, cmd->sector, cmd->size,
> + cmd->csize, c->crypto_attached_size);
> + err = -EINVAL;
> + goto err_out_exit;
> + }
> +
> + err = dst_data_recv(st, cdata, cmd->csize);
> + if (err)
> + goto err_out_exit;
> +
> + cmd->size -= cmd->csize;
> + return 0;
> +
> +err_out_exit:
> + return err;
> +}
> +
> +static int dst_recv_processing(struct dst_state *st)
> +{
> + int err = -EINTR;
> + struct dst_cmd *cmd = st->data;
> +
> + /*
> + * If socket will be reset after this statement, then
> + * dst_data_recv() will just fail and loop will
> + * start again, so it can be done without any locks.
> + *
> + * st->read_socket is needed to prevents state machine
> + * breaking between this data reading and subsequent one
> + * in protocol specific functions during connection reset.
> + * In case of reset we have to read next command and do
> + * not expect data for old command to magically appear in
> + * new connection.
> + */
> + st->read_socket = st->socket;
> + err = dst_data_recv(st, cmd, sizeof(struct dst_cmd));
> + if (err)
> + goto out_exit;
> +
> + dst_convert_cmd(cmd);
> +
> + dprintk("%s: cmd: %u, size: %u, csize: %u, id: %llu, sector: %llu, flags: %llx, rw: %llx.\n",
> + __func__, cmd->cmd, cmd->size,
> + cmd->csize, cmd->id, cmd->sector,
> + cmd->flags, cmd->rw);
> +
> + /*
> + * This should catch protocol breakage and random garbage instead of commands.
> + */
> + if (unlikely(cmd->csize > st->size - sizeof(struct dst_cmd))) {
> + err = -EBADMSG;
> + goto out_exit;
> + }
> +
> + err = -EPROTO;
> + switch (cmd->cmd) {
> + case DST_IO_RESPONSE:
> + err = dst_process_io_response(st);
> + break;
> + case DST_IO:
> + err = dst_process_io(st);
> + break;
> + case DST_CFG:
> + err = dst_process_cfg(st);
> + break;
> + default:
> + break;
> + }
> +
> +out_exit:
> + return err;
> +}
> +
> +static int dst_recv(void *init_data, void *schedule_data)
> +{
> + struct dst_state *st = schedule_data;
> + struct dst_node *n = init_data;
> + int err = 0;
> +
> + dprintk("%s: start st: %p, n: %p, scan: %lu, need_exit: %d.\n",
> + __func__, st, n, n->trans_scan_timeout, st->need_exit);
> +
> + while (n->trans_scan_timeout && !st->need_exit) {
> + err = dst_recv_processing(st);
> + if (err < 0) {
> + if (!st->ctl.type)
> + break;
> +
> + if (!n->trans_scan_timeout || st->need_exit)
> + break;
> +
> + dst_state_reset(st);
> + msleep(1000);
> + }
> + }
> +
> + st->need_exit = 1;
> + wake_up(&st->thread_wait);
> +
> + dprintk("%s: freeing receiving socket st: %p.\n", __func__, st);
> + dst_state_exit_connected(st);
> + dst_state_put(st);
> +
> + dprintk("%s: freed receiving socket st: %p.\n", __func__, st);
> +
> + return err;
> +}
> +
> +static void dst_state_free(struct dst_state *st)
> +{
> + dprintk("%s: st: %p.\n", __func__, st);
> + if (st->cleanup)
> + st->cleanup(st);
> + kfree(st->data);
> + kfree(st);
> +}
> +
> +struct dst_state *dst_state_alloc(struct dst_node *n)
> +{
> + struct dst_state *st;
> + int err = -ENOMEM;
> +
> + st = kzalloc(sizeof(struct dst_state), GFP_KERNEL);
> + if (!st)
> + goto err_out_exit;
> +
> + st->node = n;
> + st->need_exit = 0;
> +
> + st->size = PAGE_SIZE;
> + st->data = kmalloc(st->size, GFP_KERNEL);
> + if (!st->data)
> + goto err_out_free;
> +
> + spin_lock_init(&st->request_lock);
> + INIT_LIST_HEAD(&st->request_list);
> +
> + mutex_init(&st->state_lock);
> + init_waitqueue_head(&st->thread_wait);
> +
> + /*
> + * One for processing thread, another one for node itself.
> + */
> + atomic_set(&st->refcnt, 2);
> +
> + dprintk("%s: st: %p, n: %p.\n", __func__, st, st->node);
> +
> + return st;
> +
> +err_out_free:
> + kfree(st);
> +err_out_exit:
> + return ERR_PTR(err);
> +}
> +
> +int dst_state_schedule_receiver(struct dst_state *st)
> +{
> + return thread_pool_schedule_private(st->node->pool, dst_thread_setup,
> + dst_recv, st, MAX_SCHEDULE_TIMEOUT, st->node);
> +}
> +
> +int dst_node_init_connected(struct dst_node *n, struct dst_network_ctl *r)
> +{
> + struct dst_state *st;
> + int err = -ENOMEM;
> +
> + st = dst_state_alloc(n);
> + if (IS_ERR(st)) {
> + err = PTR_ERR(st);
> + goto err_out_exit;
> + }
> + memcpy(&st->ctl, r, sizeof(struct dst_network_ctl));
> +
> + err = dst_state_init_connected(st);
> + if (err)
> + goto err_out_free_data;
> +
> + err = dst_request_remote_config(st);
> + if (err)
> + goto err_out_exit_connected;
> + n->state = st;
> +
> + err = dst_state_schedule_receiver(st);
> + if (err)
> + goto err_out_exit_connected;
> +
> + return 0;
> +
> +err_out_exit_connected:
> + dst_state_exit_connected(st);
> +err_out_free_data:
> + dst_state_free(st);
> +err_out_exit:
> + n->state = NULL;
> + return err;
> +}
> +
> +void dst_state_put(struct dst_state *st)
> +{
> + dprintk("%s: st: %p, refcnt: %d.\n", __func__, st, atomic_read(&st->refcnt));
> + if (atomic_dec_and_test(&st->refcnt))
> + dst_state_free(st);
> +}
> +
> +int dst_send_bio(struct dst_state *st, struct dst_cmd *cmd, struct bio *bio)
> +{
> + struct bio_vec *bv;
> + struct dst_crypto_ctl *c = &st->node->crypto;
> + int err, i = 0;
> + int flags = MSG_WAITALL;
> +
> + err = dst_data_send_header(st->socket, cmd,
> + sizeof(struct dst_cmd) + c->crypto_attached_size, bio->bi_vcnt);
> + if (err)
> + goto err_out_exit;
> +
> + bio_for_each_segment(bv, bio, i) {
> + if (i < bio->bi_vcnt - 1)
> + flags |= MSG_MORE;
> +
> + err = kernel_sendpage(st->socket, bv->bv_page, bv->bv_offset,
> + bv->bv_len, flags);
> + if (err <= 0)
> + goto err_out_exit;
> + }
> +
> + return 0;
> +
> +err_out_exit:
> + dprintk("%s: %d/%d, flags: %x, err: %d.\n", __func__, i, bio->bi_vcnt, flags, err);
> + return err;
> +}
> +
> +int dst_trans_send(struct dst_trans *t)
> +{
> + int err;
> + struct dst_state *st = t->n->state;
> + struct bio *bio = t->bio;
> +
> + dst_convert_cmd(&t->cmd);
> +
> + dst_state_lock(st);
> + if (!st->socket) {
> + err = dst_state_init_connected(st);
> + if (err)
> + goto err_out_unlock;
> + }
> +
> + if (bio_data_dir(bio) == WRITE) {
> + err = dst_send_bio(st, &t->cmd, t->bio);
> + } else {
> + err = dst_data_send_header(st->socket, &t->cmd, sizeof(struct dst_cmd), 0);
> + }
> + if (err)
> + goto err_out_reset;
> +
> + dst_state_unlock(st);
> + return 0;
> +
> +err_out_reset:
> + dst_state_reset_nolock(st);
> +err_out_unlock:
> + dst_state_unlock(st);
> +
> + return err;
> +}
> diff --git a/drivers/block/dst/thread_pool.c b/drivers/block/dst/thread_pool.c
> new file mode 100644
> index 0000000..6a14cb5
> --- /dev/null
> +++ b/drivers/block/dst/thread_pool.c
> @@ -0,0 +1,302 @@
> +/*
> + * 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.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/dst.h>
> +#include <linux/kthread.h>
> +#include <linux/slab.h>
> +
> +struct thread_pool_worker
> +{
> + struct list_head worker_entry;
> +
> + struct task_struct *thread;
> +
> + struct thread_pool *pool;
> +
> + int error;
> + int has_data;
> + int need_exit;
> + unsigned int id;
> +
> + wait_queue_head_t wait;
> +
> + void *private;
> + void *schedule_data;
> +
> + int (* action)(void *private, void *schedule_data);
> + void (* cleanup)(void *private);
> +};
> +
> +static void thread_pool_exit_worker(struct thread_pool_worker *w)
> +{
> + dprintk("%s: 1 w: %p, need_exit: %d.\n", __func__, w, w->need_exit);
> + kthread_stop(w->thread);
> + dprintk("%s: 2 w: %p, need_exit: %d.\n", __func__, w, w->need_exit);
> +
> + w->cleanup(w->private);
> + kfree(w);
> +}
> +
> +static void thread_pool_worker_make_ready(struct thread_pool_worker *w)
> +{
> + struct thread_pool *p = w->pool;
> +
> + dprintk("%s: w: %p, need_exit: %d.\n", __func__, w, w->need_exit);
> +
> + mutex_lock(&p->thread_lock);
> +
> + if (!w->need_exit) {
> + list_move_tail(&w->worker_entry, &p->ready_list);
> + w->has_data = 0;
> + mutex_unlock(&p->thread_lock);
> +
> + wake_up(&p->wait);
> + } else {
> + p->thread_num--;
> + list_del(&w->worker_entry);
> + mutex_unlock(&p->thread_lock);
> +
> + thread_pool_exit_worker(w);
> + }
> +
> + dprintk("%s: w: %p.\n", __func__, w);
> +}
> +
> +static int thread_pool_worker_func(void *data)
> +{
> + struct thread_pool_worker *w = data;
> +
> + while (!kthread_should_stop()) {
> + wait_event_interruptible(w->wait, kthread_should_stop() || w->has_data);
> +
> + if (kthread_should_stop())
> + break;
> +
> + if (!w->has_data)
> + continue;
> +
> + w->action(w->private, w->schedule_data);
> + thread_pool_worker_make_ready(w);
> + }
> +
> + return 0;
> +}
> +
> +void thread_pool_del_worker(struct thread_pool *p)
> +{
> + struct thread_pool_worker *w = NULL;
> +
> + while (!w) {
> + wait_event(p->wait, !list_empty(&p->ready_list) || !p->thread_num);
> +
> + dprintk("%s: locking list_empty: %d, thread_num: %d.\n",
> + __func__, list_empty(&p->ready_list), p->thread_num);
> +
> + mutex_lock(&p->thread_lock);
> + if (!list_empty(&p->ready_list)) {
> + w = list_first_entry(&p->ready_list,
> + struct thread_pool_worker,
> + worker_entry);
> +
> + dprintk("%s: deleting w: %p, thread_num: %d, list: %p [%p.%p].\n",
> + __func__, w, p->thread_num, &p->ready_list,
> + p->ready_list.prev, p->ready_list.next);
> +
> + p->thread_num--;
> + list_del(&w->worker_entry);
> + }
> + mutex_unlock(&p->thread_lock);
> + }
> +
> + if (w)
> + thread_pool_exit_worker(w);
> + dprintk("%s: deleted w: %p, thread_num: %d.\n", __func__, w, p->thread_num);
> +}
> +
> +void thread_pool_del_worker_id(struct thread_pool *p, unsigned int id)
> +{
> + struct thread_pool_worker *w, *tmp;
> + int found = 0;
> +
> + mutex_lock(&p->thread_lock);
> + list_for_each_entry_safe(w, tmp, &p->ready_list, worker_entry) {
> + if (w->id == id) {
> + found = 1;
> + p->thread_num--;
> + list_del(&w->worker_entry);
> + break;

I don't think you need the safe loop version, if you directly break the
loop.

> + }
> + }
> +
> + if (!found) {
> + list_for_each_entry_safe(w, tmp, &p->active_list, worker_entry) {

You don't modify the list inside the loop, no need for the safe version.

> + if (w->id == id) {
> + w->need_exit = 1;
> + break;
> + }
> + }
> + }
> + mutex_unlock(&p->thread_lock);
> +
> + if (found)
> + thread_pool_exit_worker(w);
> +}
> +
> +int thread_pool_add_worker(struct thread_pool *p,
> + char *name,
> + unsigned int id,
> + void *(* init)(void *private),
> + void (* cleanup)(void *private),
> + void *private)
> +{
> + struct thread_pool_worker *w;
> + int err = -ENOMEM;
> +
> + w = kzalloc(sizeof(struct thread_pool_worker), GFP_KERNEL);
> + if (!w)
> + goto err_out_exit;
> +
> + w->pool = p;
> + init_waitqueue_head(&w->wait);
> + w->cleanup = cleanup;
> + w->id = id;
> +
> + w->thread = kthread_run(thread_pool_worker_func, w, "%s", name);
> + if (IS_ERR(w->thread)) {
> + err = PTR_ERR(w->thread);
> + goto err_out_free;
> + }
> +
> + w->private = init(private);
> + if (IS_ERR(w->private)) {
> + err = PTR_ERR(w->private);
> + goto err_out_stop_thread;
> + }
> +
> + mutex_lock(&p->thread_lock);
> + list_add_tail(&w->worker_entry, &p->ready_list);
> + p->thread_num++;
> + mutex_unlock(&p->thread_lock);
> +
> + return 0;
> +
> +err_out_stop_thread:
> + kthread_stop(w->thread);
> +err_out_free:
> + kfree(w);
> +err_out_exit:
> + return err;
> +}
> +
> +void thread_pool_destroy(struct thread_pool *p)
> +{
> + while (p->thread_num) {
> + dprintk("%s: num: %d.\n", __func__, p->thread_num);
> + thread_pool_del_worker(p);
> + }
> +}
> +
> +struct thread_pool *thread_pool_create(int num, char *name,
> + void *(* init)(void *private),
> + void (* cleanup)(void *private),
> + void *private)
> +{
> + struct thread_pool_worker *w, *tmp;
> + struct thread_pool *p;
> + int err = -ENOMEM;
> + int i;
> +
> + p = kzalloc(sizeof(struct thread_pool), GFP_KERNEL);
> + if (!p)
> + goto err_out_exit;
> +
> + init_waitqueue_head(&p->wait);
> + mutex_init(&p->thread_lock);
> + INIT_LIST_HEAD(&p->ready_list);
> + INIT_LIST_HEAD(&p->active_list);
> + p->thread_num = 0;
> +
> + for (i=0; i<num; ++i) {
> + err = thread_pool_add_worker(p, name, i, init, cleanup, private);
> + if (err)
> + goto err_out_free_all;
> + }
> +
> + return p;
> +
> +err_out_free_all:
> + list_for_each_entry_safe(w, tmp, &p->ready_list, worker_entry) {
> + list_del(&w->worker_entry);
> + thread_pool_exit_worker(w);
> + }
> + kfree(p);
> +err_out_exit:
> + return ERR_PTR(err);
> +}
> +
> +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)
> +{
> + struct thread_pool_worker *w, *tmp, *worker = NULL;
> + int err = 0;
> +
> + while (!worker && !err) {
> + timeout = wait_event_interruptible_timeout(p->wait,
> + !list_empty(&p->ready_list),
> + timeout);
> +
> + if (!timeout) {
> + err = -ETIMEDOUT;
> + break;
> + }
> +
> + worker = NULL;
> + mutex_lock(&p->thread_lock);
> + list_for_each_entry_safe(w, tmp, &p->ready_list, worker_entry) {
> + if (id && id != w->private)
> + continue;
> +
> + worker = w;
> +
> + list_move_tail(&w->worker_entry, &p->active_list);
> +
> + err = setup(w->private, data);
> + if (!err) {
> + w->schedule_data = data;
> + w->action = action;
> + w->has_data = 1;
> + wake_up(&w->wait);
> + } else {
> + list_move_tail(&w->worker_entry, &p->ready_list);
> + }
> +
> + break;
> + }
> + mutex_unlock(&p->thread_lock);
> + }
> +
> + return err;
> +}
> +
> +int thread_pool_schedule(struct thread_pool *p,
> + int (* setup)(void *private, void *data),
> + int (* action)(void *private, void *data),
> + void *data, long timeout)
> +{
> + return thread_pool_schedule_private(p, setup, action, data, timeout, NULL);
> +}
> diff --git a/drivers/block/dst/trans.c b/drivers/block/dst/trans.c
> new file mode 100644
> index 0000000..6122a9f
> --- /dev/null
> +++ b/drivers/block/dst/trans.c
> @@ -0,0 +1,288 @@
> +/*
> + * 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.
> + */
> +
> +#include <linux/bio.h>
> +#include <linux/dst.h>
> +#include <linux/slab.h>
> +#include <linux/mempool.h>
> +
> +static int dst_mempool_num = 32;
> +module_param(dst_mempool_num, int, 0644);
> +
> +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__, t->gen, t->bio->bi_sector, t->bio->bi_size, ret->send_time,
> + new->gen, 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, 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;
> +
> + rb_erase(&t->trans_entry, &n->trans_root);
> + 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;
> +}
> +
> +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);
> + }
> +}
> +
> +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);
> +
> + err = dst_trans_insert(t);
> + if (err)
> + goto err_out_free;
> +
> + dprintk("%s: gen: %llu, bio: %llu/%u, dir/enc: %d, need_crypto: %d.\n",
> + __func__, t->gen, 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;
> +}
> +
> +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);
> +
> + //dprintk("%s: processed: %d.\n", __func__, 10 * n->trans_max_retries - num);
> +
> + /*
> + * 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);
> + }
> +}
> +
> +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);
> +}
> +
> +int dst_node_trans_init(struct dst_node *n, unsigned int size)
> +{
> + n->trans_cache = kmem_cache_create(n->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 96a89d3..cfc5ce7 100644
> --- a/include/linux/connector.h
> +++ b/include/linux/connector.h
> @@ -38,8 +38,10 @@
> #define CN_W1_VAL 0x1
> #define CN_IDX_V86D 0x4
> #define CN_VAL_V86D_UVESAFB 0x1
> +#define CN_DST_IDX 0x5
> +#define CN_DST_VAL 0x1
>
> -#define CN_NETLINK_USERS 5
> +#define CN_NETLINK_USERS 6
>
> /*
> * Maximum connector's message size.
> diff --git a/include/linux/dst.h b/include/linux/dst.h
> new file mode 100644
> index 0000000..1609cd1
> --- /dev/null
> +++ b/include/linux/dst.h
> @@ -0,0 +1,431 @@
> +/*
> + * 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 {
> + DST_DEL_NODE = 0, /* Remove node with given id from storage */
> + DST_ADD_REMOTE, /* Add remote node with given id to the storage */
> + DST_ADD_EXPORT, /* Add local node with given id to the storage to be exported and used by remote peers */
> + DST_CRYPTO, /* Crypto initialization command (hash/cipher used to protect the connection) */
> + DST_SECURITY, /* Security attributes for given connection (permissions for example) */
> + DST_START, /* Register given node in the block layer subsystem */
> + DST_CMD_MAX
> +};
> +
> +struct dst_ctl
> +{
> + char name[DST_NAMELEN];
> + __u32 flags;
> + __u32 cmd;
> + __u32 max_pages;
> + __u32 trans_scan_timeout;
> + __u32 trans_max_retries;
> + __u64 size;
> +};
> +
> +struct dst_ctl_ack
> +{
> + struct cn_msg msg;
> + int error;
> + int unused[3];
> +};
> +
> +#define SADDR_MAX_DATA 128
> +
> +struct saddr {
> + unsigned short sa_family; /* address family, AF_xxx */
> + char sa_data[SADDR_MAX_DATA]; /* 14 bytes of protocol address */
> + unsigned short sa_data_len; /* Number of bytes used in sa_data */
> +};
> +
> +struct dst_network_ctl
> +{
> + unsigned int type;
> + unsigned int proto;
> + struct saddr addr;
> +};
> +
> +struct dst_crypto_ctl
> +{
> + char cipher_algo[DST_NAMELEN];
> + char hash_algo[DST_NAMELEN];
> +
> + unsigned int cipher_keysize, hash_keysize;
> + unsigned int crypto_attached_size;
> + int thread_num;
> +};
> +
> +#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;
> +};
> +
> +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_NCMD_MAX,
> +};
> +
> +struct dst_cmd
> +{
> + __u32 cmd;
> + __u32 size;
> + __u32 csize;
> + __u64 rw;
> + __u64 flags;
> + __u64 id;
> + __u64 sector;
> + __u8 hash[0];
> +};
> +
> +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);
> +}
> +
> +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>
> +
> +//#define CONFIG_DST_DEBUG
> +
> +#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
> +{
> + struct dst_node *n;
> +
> + struct rb_node trans_entry;
> +
> + atomic_t refcnt;
> +
> + short enc;
> + short retries;
> + int error;
> +
> + long send_time;
> +
> + dst_gen_t gen;
> +
> + struct bio *bio;
> +
> + struct dst_cmd cmd;
> +};
> +
> +struct dst_crypto_engine
> +{
> + struct crypto_hash *hash;
> + struct crypto_ablkcipher *cipher;
> +
> + int page_num;
> + struct page **pages;
> +
> + int enc;
> + struct scatterlist *src, *dst;
> +
> + long timeout;
> + u64 iv;
> +
> + void *private;
> +
> + int size;
> + void *data;
> +};
> +
> +struct dst_state
> +{
> + struct mutex state_lock;
> +
> + wait_queue_t wait;
> + wait_queue_head_t *whead;
> + wait_queue_head_t thread_wait;
> +
> + struct dst_node *node;
> +
> + struct dst_network_ctl ctl;
> +
> + u32 permissions;
> +
> + void (* cleanup)(struct dst_state *st);
> +
> + struct list_head request_list;
> + spinlock_t request_lock;
> +
> + atomic_t refcnt;
> +
> + int need_exit;
> +
> + struct socket *socket, *read_socket;
> +
> + void *data;
> + unsigned int size;
> +
> + struct dst_cmd cmd;
> +};
> +
> +struct dst_node
> +{
> + struct list_head node_entry;
> +
> + char name[DST_NAMELEN];
> +
> + struct block_device *bdev;
> + struct dst_state *state;
> +
> + struct request_queue *queue;
> + struct gendisk *disk;
> +
> + int thread_num;
> + int max_pages;
> +
> + loff_t size;
> +
> + struct device device;
> +
> + struct list_head security_list;
> + struct mutex security_lock;
> +
> + atomic_t refcnt;
> +
> + int (*start)(struct dst_node *);
> +
> + struct dst_crypto_ctl crypto;
> + u8 *hash_key;
> + u8 *cipher_key;
> +
> + struct thread_pool *pool;
> +
> + atomic_long_t gen;
> +
> + long trans_scan_timeout;
> + int trans_max_retries;
> +
> + struct rb_root trans_root;
> + struct mutex trans_lock;
> +
> + struct kmem_cache *trans_cache;
> + mempool_t *trans_pool;
> + struct delayed_work trans_work;
> +};
> +
> +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)
> +{
> + BUG_ON(!mutex_is_locked(&st->state_lock));
> +
> + 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);
> +
> +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);
> +
> +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;
> + 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);
> +
> +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-09-08 19:23    [W:0.351 / U:5.860 seconds]
©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site