From ca517f7309f238091cb60cbfa495577810870ed6 Mon Sep 17 00:00:00 2001 From: Thomas Schoebel-Theuer Date: Mon, 14 Jun 2010 15:27:40 +0100 Subject: [PATCH] import mars-02.tgz --- Kconfig | 36 +++ Makefile | 12 + mars.h | 530 +++++++++++++++++++++++++++++++++++++++++++++ mars_device_sync.c | 84 +++++++ mars_device_sync.h | 14 ++ mars_dummy.c | 104 +++++++++ mars_generic.c | 305 ++++++++++++++++++++++++++ mars_if_device.c | 256 ++++++++++++++++++++++ mars_if_device.h | 18 ++ mars_test.c | 89 ++++++++ 10 files changed, 1448 insertions(+) create mode 100644 Kconfig create mode 100644 Makefile create mode 100644 mars.h create mode 100644 mars_device_sync.c create mode 100644 mars_device_sync.h create mode 100644 mars_dummy.c create mode 100644 mars_generic.c create mode 100644 mars_if_device.c create mode 100644 mars_if_device.h create mode 100644 mars_test.c diff --git a/Kconfig b/Kconfig new file mode 100644 index 00000000..3da90e15 --- /dev/null +++ b/Kconfig @@ -0,0 +1,36 @@ +# +# MARS configuration +# +config MARS + tristate "storage system MARS" + default n + ---help--- + Experimental storage System. + +config MARS_DUMMY + tristate "MARS dummy brick" + depends on MARS + default m + ---help--- + Experimental storage System. + +config MARS_IF_DEVICE + tristate "interface to a linux device" + depends on MARS + default m + ---help--- + Experimental storage System. + +config MARS_DEVICE_SYNC + tristate "interface to a linux file, synchronous" + depends on MARS + default m + ---help--- + Experimental storage System. + +config MARS_TEST + tristate "provisionary" + depends on MARS + default m + ---help--- + Experimental storage System. diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..c32a5757 --- /dev/null +++ b/Makefile @@ -0,0 +1,12 @@ +# +# Makefile for MARS +# + +obj-$(CONFIG_MARS) += mars_generic.o +obj-$(CONFIG_MARS_DUMMY) += mars_dummy.o +obj-$(CONFIG_MARS_IF_DEVICE) += mars_if_device.o +obj-$(CONFIG_MARS_DEVICE_SYNC) += mars_device_sync.o + +obj-$(CONFIG_MARS_TEST) += mars_test.o + +#mars-objs := mars_generic.o diff --git a/mars.h b/mars.h new file mode 100644 index 00000000..1b212839 --- /dev/null +++ b/mars.h @@ -0,0 +1,530 @@ +// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG +#ifndef MARS_H +#define MARS_H + +#include + +#ifdef _STRATEGY +#define _STRATEGY_CODE(X) X +#define _NORMAL_CODE(X) /**/ +#else +#define _STRATEGY_CODE(X) /**/ +#define _NORMAL_CODE(X) X +#endif + +#define MARS_INFO "MARS_INFO: " +#define MARS_ERROR "MARS_ERROR: " + +#define MARS_ERR(args...) printk(MARS_ERROR args) +#define MARS_DBG(args...) printk("MARS_DEBUG: " args) + +///////////////////////////////////////////////////////////////////////// + +// definitions for generic objects + +#define MAX_DEFAULT_ASPECTS 8 + +#define GENERIC_OBJECT_LAYOUT(PREFIX) \ + int max_size; \ + int rest_size; \ + int max_aspects; \ + int nr_aspects; \ + int *aspect_sizes; \ + int *aspect_offsets; \ + void *alloc_ptr; \ + +struct generic_object_layout { + GENERIC_OBJECT_LAYOUT(generic); +}; + +#ifdef _STRATEGY +#define GENERIC_OBJECT_LAYOUT_FUNCTIONS(PREFIX) \ +extern inline struct PREFIX##_object_layout *PREFIX##_init_object_layout(void *data, int size, int max_aspects) \ +{ \ + struct PREFIX##_object_layout *object_layout = data; \ + size -= sizeof(struct PREFIX##_object_layout); \ + if (size < 0) \ + return NULL; \ + object_layout->max_aspects = max_aspects; \ + object_layout->nr_aspects = 0; \ + object_layout->max_size = sizeof(struct PREFIX##_object_layout); \ + data += sizeof(struct PREFIX##_object_layout); \ + size -= max_aspects * sizeof(void*) * 2; \ + if (size < 0) \ + return NULL; \ + object_layout->rest_size = size; \ + object_layout->aspect_sizes = data; \ + data += max_aspects * sizeof(void*); \ + object_layout->aspect_offsets = data; \ + data += max_aspects * sizeof(void*); \ + object_layout->alloc_ptr = data; \ + return object_layout; \ +} \ + \ +extern int PREFIX##_add_aspect(struct PREFIX##_object_layout *object_layout, int aspect_size) \ +{ \ + int slot = object_layout->nr_aspects; \ + int max_aspects = object_layout->max_aspects; \ + if (unlikely(slot >= max_aspects)) { \ + void *data = object_layout->alloc_ptr; \ + void *old; \ + int size = object_layout->rest_size; \ + max_aspects <<= 1; \ + size -= max_aspects * sizeof(void*) * 2; \ + if (size < 0) \ + return -ENOMEM; \ + object_layout->rest_size = size; \ + old = object_layout->aspect_sizes; \ + object_layout->aspect_sizes = data; \ + memcpy(data, old, max_aspects * sizeof(void*)); \ + data += max_aspects * sizeof(void*); \ + old = object_layout->aspect_offsets; \ + object_layout->aspect_offsets = data; \ + memcpy(data, old, max_aspects * sizeof(void*)); \ + data += max_aspects * sizeof(void*); \ + object_layout->alloc_ptr = data; \ + object_layout->max_aspects = max_aspects; \ + } \ + object_layout->aspect_sizes[slot] = aspect_size; \ + object_layout->aspect_offsets[slot] = object_layout->max_size; \ + object_layout->max_size += aspect_size; \ + object_layout->nr_aspects++; \ + return slot; \ +} \ + +#endif + +#define GENERIC_OBJECT(PREFIX) \ + struct PREFIX##_object_layout *object_layout; \ + int object_size; \ + +struct generic_object { + GENERIC_OBJECT(generic); +}; + +#define GENERIC_ASPECT(PREFIX) \ + struct PREFIX##_object *object; \ + +struct generic_aspect { + GENERIC_ASPECT(generic); +}; + +#define GENERIC_OBJECT_FUNCTIONS(PREFIX) \ +extern inline struct PREFIX##_object *PREFIX##_construct(void *data, struct PREFIX##_object_layout *object_layout) \ +{ \ + int i; \ + struct PREFIX##_object *obj = data; \ + obj->object_layout = object_layout; \ + for (i = 0; i < object_layout->nr_aspects; i++) { \ + struct PREFIX##_aspect *aspect = data + object_layout->aspect_offsets[i]; \ + aspect->object = obj; \ + } \ + return obj; \ +} \ + \ +extern inline void *PREFIX##_get_aspect(struct PREFIX##_object *obj, int slot) \ +{ \ + if (slot < 0 || slot >= obj->object_layout->nr_aspects) \ + return NULL; \ + return (void*)obj + obj->object_layout->aspect_offsets[slot]; \ +} \ + \ + + +///////////////////////////////////////////////////////////////////////// + +// definitions for generic bricks + +struct generic_input; +struct generic_output; +struct generic_brick_ops; +struct generic_output_ops; +struct generic_brick_type; + +#define GENERIC_BRICK(PREFIX) \ + char *brick_name; \ + struct PREFIX##_brick_type *type; \ + struct PREFIX##_brick_ops *ops; \ + int nr_inputs; \ + int nr_outputs; \ + struct PREFIX##_input **inputs; \ + struct PREFIX##_output **outputs; \ + struct list_head tmp_head; \ + +struct generic_brick { + GENERIC_BRICK(generic); +}; + +#define GENERIC_INPUT(PREFIX) \ + char *input_name; \ + struct PREFIX##_brick *brick; \ + struct PREFIX##_input_type *type; \ + struct PREFIX##_output *connect; \ + +struct generic_input { + GENERIC_INPUT(generic); +}; + +#define GENERIC_OUTPUT(PREFIX) \ + char *output_name; \ + struct PREFIX##_brick *brick; \ + struct PREFIX##_output_type *type; \ + struct PREFIX##_output_ops *ops; \ + int nr_connected; \ + +struct generic_output { + GENERIC_OUTPUT(generic); +}; + +#define _GENERIC_CALL(ERROR,PTR,OP,...) \ + ((PTR)->ops->OP ? (PTR)->ops->OP(__VA_ARGS__) : ERROR) + +#define GENERIC_CALL(PTR,OP,...) \ + _GENERIC_CALL(0, PTR, OP, __VA_ARGS__) + +#define GENERIC_CALL_FORCE(PTR,OP,...) \ + _GENERIC_CALL(-ENOSYS, PTR, OP, __VA_ARGS__) + +#define GENERIC_BRICK_OPS(PREFIX) \ + int (*brick_start)(struct PREFIX##_brick *brick); \ + int (*brick_stop)(struct PREFIX##_brick *brick); \ + +struct generic_brick_ops { + GENERIC_BRICK_OPS(generic); +}; + +#define GENERIC_OUTPUT_OPS(PREFIX) \ + int (*output_start)(struct PREFIX##_output *output); \ + int (*output_stop)(struct PREFIX##_output *output); \ + +struct generic_output_ops { + GENERIC_OUTPUT_OPS(generic) +}; + +// although possible, *_type should never be extended +#define GENERIC_BRICK_TYPE(PREFIX) \ + char type_name[32]; \ + int brick_size; \ + int max_inputs; \ + int max_outputs; \ + struct PREFIX##_input_type **default_input_types; \ + char **default_input_names; \ + struct PREFIX##_output_type **default_output_types; \ + char **default_output_names; \ + struct PREFIX##_brick_ops *master_ops; \ + struct PREFIX##input_types **default_type; \ + int (*brick_construct)(struct PREFIX##_brick *brick); \ + int (*brick_destruct)(struct PREFIX##_brick *brick); \ + +struct generic_brick_type { + GENERIC_BRICK_TYPE(generic); +}; + +#define GENERIC_INPUT_TYPE(PREFIX) \ + char type_name[32]; \ + int input_size; \ + int (*input_construct)(struct PREFIX##_input *input); \ + int (*input_destruct)(struct PREFIX##_input *input); \ + +struct generic_input_type { + GENERIC_INPUT_TYPE(generic); +}; + +#define GENERIC_OUTPUT_TYPE(PREFIX) \ + char type_name[32]; \ + int output_size; \ + struct PREFIX##_output_ops *master_ops; \ + int (*output_construct)(struct PREFIX##_output *output); \ + int (*output_destruct)(struct PREFIX##_output *output); \ + +struct generic_output_type { + GENERIC_OUTPUT_TYPE(generic); +}; + +int generic_register_brick_type(struct generic_brick_type *new_type); +int generic_unregister_brick_type(struct generic_brick_type *old_type); + +#ifdef _STRATEGY // call this only in strategy bricks, never in ordinary bricks + +// you need this only if you circumvent generic_brick_init_full() +extern inline int generic_brick_init(struct generic_brick_type *type, struct generic_brick *brick, char *brick_name) +{ + brick->brick_name = brick_name; + brick->type = type; + brick->ops = type->master_ops; + brick->nr_inputs = 0; + brick->nr_outputs = 0; + brick->tmp_head.next = brick->tmp_head.prev = &brick->tmp_head; + return 0; +} + +extern inline int generic_input_init(struct generic_brick *brick, int index, struct generic_input_type *type, struct generic_input *input, char *input_name) +{ + if (index < 0 || index >= brick->type->max_inputs) + return -ENOMEM; + if (brick->inputs[index]) + return -EEXIST; + input->input_name = input_name; + input->brick = brick; + input->type = type; + input->connect = NULL; + brick->inputs[index] = input; + brick->nr_inputs++; + return 0; +} + +extern inline int generic_output_init(struct generic_brick *brick, int index, struct generic_output_type *type, struct generic_output *output, char *output_name) +{ + if (index < 0 || index >= brick->type->max_outputs) + return -ENOMEM; + if (brick->outputs[index]) + return -EEXIST; + output->output_name = output_name; + output->brick = brick; + output->type = type; + output->ops = type->master_ops; + output->nr_connected = 0; + brick->outputs[index] = output; + brick->nr_outputs++; + return 0; +} + +extern inline int generic_size(struct generic_brick_type *brick_type) +{ + int size = brick_type->brick_size; + int i; + size += brick_type->max_inputs * sizeof(void*); + for (i = 0; i < brick_type->max_inputs; i++) { + size += brick_type->default_input_types[i]->input_size; + } + size += brick_type->max_outputs * sizeof(void*); + for (i = 0; i < brick_type->max_outputs; i++) { + size += brick_type->default_output_types[i]->output_size; + } + return size; +} + +/* If possible, use this instead of generic_*_init(). + * input_types and output_types may be NULL => use default_*_types + */ +int generic_brick_init_full( + void *data, + int size, + struct generic_brick_type *brick_type, + struct generic_input_type **input_types, + struct generic_output_type **output_types, + char **names); +int generic_brick_exit_full( + struct generic_brick *brick); + +extern inline int generic_connect(struct generic_input *input, struct generic_output *output) +{ + MARS_DBG("generic_connect(input=%p, output=%p)\n", input, output); + if (!input || !output) + return -EINVAL; + if (input->connect) + return -EEXIST; + input->connect = output; + output->nr_connected++; //TODO: protect against races, e.g. atomic_t + MARS_DBG("now nr_connected=%d\n", output->nr_connected); + return 0; +} + +extern inline int generic_disconnect(struct generic_input *input) +{ + MARS_DBG("generic_disconnect(input=%p)\n", input); + if (!input) + return -EINVAL; + if (input->connect) { + input->connect->nr_connected--; //TODO: protect against races, e.g. atomic_t + MARS_DBG("now nr_connected=%d\n", input->connect->nr_connected); + input->connect = NULL; + } + return 0; +} + +#endif // _STRATEGY + +// simple wrappers for type safety +#define GENERIC_MAKE_FUNCTIONS(PREFIX) \ +extern inline int PREFIX##_register_brick_type(void) \ +{ \ + extern struct PREFIX##_brick_type PREFIX##_brick_type; \ + return generic_register_brick_type((struct generic_brick_type*)&PREFIX##_brick_type); \ +}\ + \ +extern inline int PREFIX##_unregister_brick_type(void) \ +{ \ + extern struct PREFIX##_brick_type PREFIX##_brick_type; \ + return generic_unregister_brick_type((struct generic_brick_type*)&PREFIX##_brick_type); \ +} \ + \ +_STRATEGY_CODE( \ +extern struct PREFIX##_brick_type PREFIX##_brick_type; \ +extern struct PREFIX##_input_type PREFIX##_input_type; \ +extern struct PREFIX##_output_type PREFIX##_output_type; \ + \ +static inline int PREFIX##_brick_init(struct PREFIX##_brick *brick, char *brick_name) \ +{ \ + return generic_brick_init((struct generic_brick_type*)&PREFIX##_brick_type, (struct generic_brick*)brick, brick_name); \ +} \ + \ +static inline int PREFIX##_input_init(struct PREFIX##_brick *brick, int index, struct PREFIX##_input *input, char *input_name) \ +{ \ + return generic_input_init( \ + (struct generic_brick*)brick, \ + index, \ + (struct generic_input_type*)&PREFIX##_input_type, \ + (struct generic_input*)input, \ + input_name); \ +} \ + \ +static inline int PREFIX##_output_init(struct PREFIX##_brick *brick, int index, struct PREFIX##_input *output, char *output_name) \ +{ \ + return generic_output_init( \ + (struct generic_brick*)brick, \ + index, \ + (struct generic_output_type*)&PREFIX##_output_type, \ + (struct generic_output*)output, \ + output_name); \ +} \ + \ +extern inline int PREFIX##_size(struct PREFIX##_brick_type *brick_type) \ +{ \ + return generic_size((struct generic_brick_type*)brick_type); \ +} \ + \ +extern inline int PREFIX##_brick_init_full( \ + void *data, \ + int size, \ + struct PREFIX##_brick_type *brick_type, \ + struct PREFIX##_input_type **input_types, \ + struct PREFIX##_output_type **output_types, \ + char **names) \ +{ \ + return generic_brick_init_full( \ + data, \ + size, \ + (struct generic_brick_type*)brick_type, \ + (struct generic_input_type**)input_types, \ + (struct generic_output_type**)output_types, \ + (char**)names); \ +} \ + \ +extern inline int PREFIX##_brick_exit_full( \ + struct PREFIX##_brick *brick) \ +{ \ + return generic_brick_exit_full( \ + (struct generic_brick*)brick); \ +} \ +) + +/* Define a pair of connectable subtypes. + * For type safety, use this for all possible combinations. + * Yes, this may become quadratic in large type systems, but + * (a) thou shalt not define many types, + * (b) these macros generate only definitions, no code by itself + */ +#define GENERIC_MAKE_CONNECT(INPUT_PREFIX,OUTPUT_PREFIX) \ + \ +_STRATEGY_CODE( \ + \ +extern inline int INPUT_PREFIX##_##OUTPUT_PREFIX##_connect( \ + struct INPUT_PREFIX##_input *input, \ + struct OUTPUT_PREFIX##_output *output) \ +{ \ + return generic_connect((struct generic_input*)input, (struct generic_output*)output); \ +} \ + \ +extern inline int INPUT_PREFIX##_##OUTPUT_PREFIX####_disconnect( \ + struct INPUT_PREFIX##_input *input) \ +{ \ + return generic_disconnect((struct generic_input*)input); \ +} \ +) + +///////////////////////////////////////////////////////////////////////// + +// MARS-specific definitions + +#define HT_SHIFT 6 //???? +#define MARS_MAX_SEGMENT_SIZE (1U << (9+HT_SHIFT)) + +#define MARS_IO(PREFIX) \ + GENERIC_OBJECT(PREFIX); \ + struct bio *orig_bio; \ + struct bio *mars_bio; \ + int (*mars_endio)(struct mars_io *mio); \ + +struct mars_io { + MARS_IO(mars); +}; + +#define MARS_BRICK(PREFIX) \ + GENERIC_BRICK(PREFIX); \ + +struct mars_brick { + MARS_BRICK(mars); +}; + +#define MARS_INPUT(PREFIX) \ + GENERIC_INPUT(PREFIX); \ + +struct mars_input { + MARS_INPUT(mars); +}; + +#define MARS_OUTPUT(PREFIX) \ + GENERIC_OUTPUT(PREFIX); \ + +struct mars_output { + MARS_OUTPUT(mars); +}; + +#define MARS_BRICK_OPS(PREFIX) \ + GENERIC_BRICK_OPS(PREFIX); \ + int (*mars_dummy_op)(int); \ + +#define MARS_OUTPUT_OPS(PREFIX) \ + GENERIC_OUTPUT_OPS(PREFIX); \ + int (*mars_io)(struct PREFIX##_output *output, struct mars_io *mio); \ + +// all non-extendable types +#define _MARS_TYPES(PREFIX) \ +struct PREFIX##_brick_ops { \ + MARS_BRICK_OPS(PREFIX); \ +}; \ + \ +struct PREFIX##_output_ops { \ + MARS_OUTPUT_OPS(PREFIX); \ +}; \ + \ +struct PREFIX##_brick_type { \ + GENERIC_BRICK_TYPE(PREFIX); \ +}; \ + \ +struct PREFIX##_input_type { \ + GENERIC_INPUT_TYPE(PREFIX); \ +}; \ + \ +struct PREFIX##_output_type { \ + GENERIC_OUTPUT_TYPE(PREFIX); \ +}; \ + \ +GENERIC_MAKE_FUNCTIONS(PREFIX); \ +GENERIC_MAKE_CONNECT(PREFIX,PREFIX); \ + +#define MARS_TYPES(PREFIX) \ +_MARS_TYPES(PREFIX) \ +GENERIC_MAKE_CONNECT(generic,PREFIX); \ +GENERIC_MAKE_CONNECT(mars,PREFIX); \ + + +///////////////////////////////////////////////////////////////////////// + +// MARS-specific helper functions + +_MARS_TYPES(mars); +GENERIC_MAKE_CONNECT(generic,mars); + +#endif diff --git a/mars_device_sync.c b/mars_device_sync.c new file mode 100644 index 00000000..76431c91 --- /dev/null +++ b/mars_device_sync.c @@ -0,0 +1,84 @@ +// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG + +#include +#include +#include + +#include "mars.h" + +///////////////////////// own type definitions //////////////////////// + +#include "mars_device_sync.h" + +////////////////// own brick / input / output operations ////////////////// + +static int device_sync_mars_io(struct device_sync_output *output, struct mars_io *mio) +{ + struct bio *bio = mio->orig_bio; + mio->mars_endio(mio); + return 0; +} + +///////////////////////// contructors / destructors //////////////////////// + +static int device_sync_brick_construct(struct device_sync_brick *brick) +{ + return 0; +} + +static int device_sync_output_construct(struct device_sync_output *output) +{ + return 0; +} + +///////////////////////// static structs //////////////////////// + +static struct device_sync_brick_ops device_sync_brick_ops = { +}; + +static struct device_sync_output_ops device_sync_output_ops = { + .mars_io = device_sync_mars_io, +}; + +static struct device_sync_output_type device_sync_output_type = { + .type_name = "device_sync_output", + .output_size = sizeof(struct device_sync_output), + .master_ops = &device_sync_output_ops, + .output_construct = &device_sync_output_construct, +}; + +static struct device_sync_output_type *device_sync_output_types[] = { + &device_sync_output_type, +}; + +struct device_sync_brick_type device_sync_brick_type = { + .type_name = "device_sync_brick", + .brick_size = sizeof(struct device_sync_brick), + .max_inputs = 0, + .max_outputs = 1, + .master_ops = &device_sync_brick_ops, + .default_output_types = device_sync_output_types, + .brick_construct = &device_sync_brick_construct, +}; +EXPORT_SYMBOL_GPL(device_sync_brick_type); + +////////////////// module init stuff ///////////////////////// + +static int __init init_device_sync(void) +{ + printk(MARS_INFO "init_device_sync()\n"); + return device_sync_register_brick_type(); +} + +static void __exit exit_device_sync(void) +{ + printk(MARS_INFO "exit_device_sync()\n"); + device_sync_unregister_brick_type(); +} + +MODULE_DESCRIPTION("MARS device_sync brick"); +MODULE_AUTHOR("Thomas Schoebel-Theuer "); +MODULE_LICENSE("GPL"); + +module_init(init_device_sync); +module_exit(exit_device_sync); diff --git a/mars_device_sync.h b/mars_device_sync.h new file mode 100644 index 00000000..1ad5fc47 --- /dev/null +++ b/mars_device_sync.h @@ -0,0 +1,14 @@ +// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG +struct device_sync_brick { + MARS_BRICK(device_sync); +}; + +struct device_sync_input { + MARS_INPUT(device_sync); +}; + +struct device_sync_output { + MARS_OUTPUT(device_sync); +}; + +MARS_TYPES(device_sync); diff --git a/mars_dummy.c b/mars_dummy.c new file mode 100644 index 00000000..f05630b9 --- /dev/null +++ b/mars_dummy.c @@ -0,0 +1,104 @@ +// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG + +// Dummy brick (just for demonstration) + +#include +#include +#include + +#include "mars.h" + +///////////////////////// own type definitions //////////////////////// + +struct dummy_brick { + MARS_BRICK(dummy); + int my_own; +}; + +struct dummy_input { + MARS_INPUT(dummy); +}; + +struct dummy_output { + MARS_OUTPUT(dummy); + int my_own; +}; + +MARS_TYPES(dummy); + +////////////////// own brick / input / output operations ////////////////// + +///////////////////////// contructors / destructors //////////////////////// + +static int dummy_brick_construct(struct dummy_brick *brick) +{ + brick->my_own = 0; + return 0; +} + +static int dummy_output_construct(struct dummy_output *output) +{ + output->my_own = 0; + return 0; +} + +///////////////////////// static structs //////////////////////// + +static struct dummy_brick_ops dummy_brick_ops = { +}; + +static struct dummy_output_ops dummy_output_ops = { +}; + +static struct dummy_input_type dummy_input_type = { + .type_name = "dummy_input", + .input_size = sizeof(struct dummy_input), +}; + +static struct dummy_input_type *dummy_input_types[] = { + &dummy_input_type, +}; + +static struct dummy_output_type dummy_output_type = { + .type_name = "dummy_output", + .output_size = sizeof(struct dummy_output), + .master_ops = &dummy_output_ops, + .output_construct = &dummy_output_construct, +}; + +static struct dummy_output_type *dummy_output_types[] = { + &dummy_output_type, +}; + +struct dummy_brick_type dummy_brick_type = { + .type_name = "dummy_brick", + .brick_size = sizeof(struct dummy_brick), + .max_inputs = 1, + .max_outputs = 1, + .master_ops = &dummy_brick_ops, + .default_input_types = dummy_input_types, + .default_output_types = dummy_output_types, + .brick_construct = &dummy_brick_construct, +}; +EXPORT_SYMBOL_GPL(dummy_brick_type); + +////////////////// module init stuff ///////////////////////// + +static int __init init_dummy(void) +{ + printk(MARS_INFO "init_dummy()\n"); + return dummy_register_brick_type(); +} + +static void __exit exit_dummy(void) +{ + printk(MARS_INFO "exit_dummy()\n"); + dummy_unregister_brick_type(); +} + +MODULE_DESCRIPTION("MARS dummy brick"); +MODULE_AUTHOR("Thomas Schoebel-Theuer "); +MODULE_LICENSE("GPL"); + +module_init(init_dummy); +module_exit(exit_dummy); diff --git a/mars_generic.c b/mars_generic.c new file mode 100644 index 00000000..30f0531d --- /dev/null +++ b/mars_generic.c @@ -0,0 +1,305 @@ +// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG + +#include +#include +#include + +#define _STRATEGY +#include "mars.h" + +////////////////////////////////////////////////////////////// + +// testing..... + +#if 1 +#include + +GENERIC_OBJECT_LAYOUT_FUNCTIONS(generic); +GENERIC_OBJECT_FUNCTIONS(generic); + +void test(void) +{ + char data[1024]; + struct generic_object *obj; + struct generic_object_layout *t = generic_init_object_layout(data, sizeof(data), 4); + int slot = generic_add_aspect(t, 17); + char *my_aspect; + obj = kmalloc(t->max_size, GFP_KERNEL); + obj = generic_construct(obj, t); + my_aspect = (void*)obj + obj->object_layout->aspect_offsets[slot]; + my_aspect = generic_get_aspect(obj, slot); +} +#endif + +////////////////////////////////////////////////////////////// + +#define MAX_BRICK_TYPES 64 + +static int nr_brick_types = 0; +static struct generic_brick_type *brick_types[MAX_BRICK_TYPES] = {}; + +int generic_register_brick_type(struct generic_brick_type *new_type) +{ + int i; + int found = -1; + MARS_DBG("generic_register_brick_type()\n"); + for (i = 0; i < nr_brick_types; i++) { + if (!brick_types[i]) { + found = i; + continue; + } + if (!strcmp(brick_types[i]->type_name, new_type->type_name)) { + printk("sorry, bricktype %s is already registered.\n", new_type->type_name); + return -EEXIST; + } + } + if (found < 0) { + if (nr_brick_types >= MAX_BRICK_TYPES) { + printk("sorry, cannot register bricktype %s.\n", new_type->type_name); + return -EEXIST; + } + found = nr_brick_types++; + } + brick_types[found] = new_type; + MARS_DBG("generic_register_brick_type() done.\n"); + return 0; +} +EXPORT_SYMBOL_GPL(generic_register_brick_type); + +int generic_unregister_brick_type(struct generic_brick_type *old_type) +{ + MARS_DBG("generic_unregister_brick_type()\n"); + return -1; // NYI +} +EXPORT_SYMBOL_GPL(generic_unregister_brick_type); + +int generic_brick_init_full( + void *data, + int size, + struct generic_brick_type *brick_type, + struct generic_input_type **input_types, + struct generic_output_type **output_types, + char **names) +{ + struct generic_brick *brick = data; + int status; + int i; + + MARS_DBG("generic_brick_init_full()\n"); + // first, call the generic constructors + + status = generic_brick_init(brick_type, brick, *names++); + if (status) + return status; + data += brick_type->brick_size; + size -= brick_type->brick_size; + if (size < 0) + return -ENOMEM; + if (!input_types) { + MARS_DBG("generic_brick_init_full: switch to default input_types\n"); + input_types = brick_type->default_input_types; + names = brick_type->default_input_names; + } + if (input_types) { + MARS_DBG("generic_brick_init_full: input_types\n"); + brick->inputs = data; + data += sizeof(void*) * brick_type->max_inputs; + size -= sizeof(void*) * brick_type->max_inputs; + if (size < 0) + return -1; + for (i = 0; i < brick_type->max_inputs; i++) { + struct generic_input *input = data; + struct generic_input_type *type = *input_types++; + MARS_DBG("generic_brick_init_full: calling generic_input_init()\n"); + status = generic_input_init(brick, i, type, input, names ? *names++ : type->type_name); + if (status) + return status; + data += type->input_size; + size -= type->input_size; + if (size < 0) + return -ENOMEM; + } + } + if (!output_types) { + MARS_DBG("generic_brick_init_full: switch to default output_types\n"); + output_types = brick_type->default_output_types; + names = brick_type->default_output_names; + } + if (output_types) { + MARS_DBG("generic_brick_init_full: output_types\n"); + brick->outputs = data; + data += sizeof(void*) * brick_type->max_outputs; + size -= sizeof(void*) * brick_type->max_outputs; + if (size < 0) + return -1; + for (i = 0; i < brick_type->max_outputs; i++) { + struct generic_output *output = data; + struct generic_output_type *type = *output_types++; + MARS_DBG("generic_brick_init_full: calling generic_output_init()\n"); + generic_output_init(brick, i, type, output, names ? *names++ : type->type_name); + if (status) + return status; + data += type->output_size; + size -= type->output_size; + if (size < 0) + return -ENOMEM; + } + } + + // call the specific constructors + MARS_DBG("generic_brick_init_full: call specific contructors.\n"); + if (brick_type->brick_construct) { + MARS_DBG("generic_brick_init_full: calling brick_construct()\n"); + status = brick_type->brick_construct(brick); + if (status) + return status; + } + for (i = 0; i < brick_type->max_inputs; i++) { + struct generic_input *input = brick->inputs[i]; + if (!input) + continue; + if (!input->type) { + MARS_ERR("input has no associated type!\n"); + continue; + } + if (input->type->input_construct) { + MARS_DBG("generic_brick_init_full: calling input_construct()\n"); + status = input->type->input_construct(input); + if (status) + return status; + } + } + for (i = 0; i < brick_type->max_outputs; i++) { + struct generic_output *output = brick->outputs[i]; + if (!output) + continue; + if (!output->type) { + MARS_ERR("output has no associated type!\n"); + continue; + } + if (output->type->output_construct) { + MARS_DBG("generic_brick_init_full: calling output_construct()\n"); + status = output->type->output_construct(output); + if (status) + return status; + } + } + return 0; +} +EXPORT_SYMBOL_GPL(generic_brick_init_full); + +int generic_brick_exit_full(struct generic_brick *brick) +{ + int i; + int status; + // first, check all outputs + for (i = 0; i < brick->nr_outputs; i++) { + struct generic_output *output = brick->outputs[i]; + if (!output) + continue; + if (!output->type) { + MARS_ERR("output has no associated type!\n"); + continue; + } + if (output->nr_connected) { + MARS_DBG("output is connected!\n"); + return -EPERM; + } + } + // ok, test succeeded. start desctruction... + for (i = 0; i < brick->type->max_outputs; i++) { + struct generic_output *output = brick->outputs[i]; + if (!output) + continue; + if (!output->type) { + MARS_ERR("output has no associated type!\n"); + continue; + } + if (output->type->output_destruct) { + MARS_DBG("generic_brick_exit_full: calling output_destruct()\n"); + status = output->type->output_destruct(output); + if (status) + return status; + brick->outputs[i] = NULL; // others may remain leftover + } + } + for (i = 0; i < brick->type->max_inputs; i++) { + struct generic_input *input = brick->inputs[i]; + if (!input) + continue; + if (!input->type) { + MARS_ERR("input has no associated type!\n"); + continue; + } + if (input->type->input_destruct) { + MARS_DBG("generic_brick_exit_full: calling input_destruct()\n"); + status = input->type->input_destruct(input); + if (status) + return status; + brick->inputs[i] = NULL; // others may remain leftover + status = generic_disconnect(input); + if (status) + return status; + } + } + if (brick->type->brick_destruct) { + MARS_DBG("generic_brick_exit_full: calling brick_destruct()\n"); + status = brick->type->brick_destruct(brick); + if (status) + return status; + } + return 0; +} +EXPORT_SYMBOL_GPL(generic_brick_exit_full); + +int generic_brick_exit_recursively(struct generic_brick *brick) +{ + int final_status = 0; + LIST_HEAD(head); + list_add(&brick->tmp_head, &head); + while (!list_empty(&head)) { + int i; + int status; + brick = container_of(head.next, struct generic_brick, tmp_head); + for (i = 0; i < brick->nr_outputs; i++) { + struct generic_output *output = brick->outputs[i]; + if (output->nr_connected) { + list_del(&brick->tmp_head); + continue; + } + } + list_del(&brick->tmp_head); + for (i = 0; i < brick->nr_inputs; i++) { + struct generic_input *input = brick->inputs[i]; + if (input->connect) { + struct generic_brick *other = input->connect->brick; + list_add(&other->tmp_head, &head); + } + } + status = generic_brick_exit_full(brick); + if (status) + final_status = status; + } + return final_status; +} +EXPORT_SYMBOL_GPL(generic_brick_exit_recursively); + +///////////////////////////////////////////////////////////////////// + +static int __init init_mars(void) +{ + printk(MARS_INFO "init_mars()\n"); + return 0; +} + +static void __exit exit_mars(void) +{ + printk(MARS_INFO "exit_mars()\n"); +} + +MODULE_DESCRIPTION("MARS block storage"); +MODULE_AUTHOR("Thomas Schoebel-Theuer "); +MODULE_LICENSE("GPL"); + +module_init(init_mars); +module_exit(exit_mars); diff --git a/mars_if_device.c b/mars_if_device.c new file mode 100644 index 00000000..31e39c4e --- /dev/null +++ b/mars_if_device.c @@ -0,0 +1,256 @@ +// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG + +/* Interface to a Linux device. + * 1 Input, 0 Outputs. + */ + +#include +#include +#include + +#include +#include +#include + +#include "mars.h" + +///////////////////////// own type definitions //////////////////////// + +#include "mars_if_device.h" + +///////////////////////// own static definitions //////////////////////// + +static int device_minor = 0; + +///////////////////////// linux operations //////////////////////// + +/* callback + */ +static int if_device_endio(struct mars_io *mio) +{ + struct bio *bio = mio->orig_bio; + if (bio) { + if (!bio->bi_size) { + bio_endio(bio, 0); + } else { + MARS_ERR("NYI: RETRY LOGIC\n"); + bio_endio(bio, -EIO); + } + } // else lower layers have already signalled the orig_bio + + return 0; +} + +/* accept a linux bio, wrap it into struct mars_io and call mars_io() on it. + */ +static int if_device_make_request(struct request_queue *q, struct bio *bio) +{ + struct if_device_input *input = q->queuedata; + struct if_device_output *output; + struct mars_io *mio; + int error = -ENOSYS; + + MARS_DBG("make_request(%d)\n", bio->bi_size); +#if 0 + bio->bi_size = 0; + bio_endio(bio, 0); +#else + if (!input || !input->connect) + goto err; + + output = input->connect; + if (!output->ops || !output->ops->mars_io) + goto err; + + error = -ENOMEM; + mio = kzalloc(input->mio_size, GFP_KERNEL); + if (!mio) + goto err; + + mio->orig_bio = bio; + mio->mars_bio = NULL; + mio->mars_endio = if_device_endio; + + error = output->ops->mars_io(output, mio); + if (error) + goto err_free; +#endif + return 0; + +err_free: + kfree(mio); +err: + bio_endio(bio, error); + return 0; +} + +static int if_device_open(struct block_device *bdev, fmode_t mode) +{ + struct if_device_input *input = bdev->bd_disk->private_data; + (void)input; + MARS_DBG("if_device_open()\n"); + return 0; +} + +static int if_device_release(struct gendisk *gd, fmode_t mode) +{ + MARS_DBG("if_device_close()\n"); + return 0; +} + +static const struct block_device_operations if_device_blkdev_ops = { + .owner = THIS_MODULE, + .open = if_device_open, + .release = if_device_release, + +}; + +////////////////// own brick / input / output operations ////////////////// + +//////////////////////// contructors / destructors //////////////////////// + +static int if_device_brick_construct(struct if_device_brick *brick) +{ + return 0; +} + +static int if_device_brick_destruct(struct if_device_brick *brick) +{ + return 0; +} + +static int if_device_input_construct(struct if_device_input *input) +{ + struct request_queue *q; + struct gendisk *disk; + int minor; + + MARS_DBG("1\n"); + q = blk_alloc_queue(GFP_KERNEL); + if (!q) { + MARS_ERR("cannot allocate device request queue\n"); + return -ENOMEM; + } + q->queuedata = input; + input->q = q; + + MARS_DBG("2\n"); + disk = alloc_disk(1); + if (!disk) { + MARS_ERR("cannot allocate gendisk\n"); + return -ENOMEM; + } + + MARS_DBG("3\n"); + minor = device_minor++; //TODO: protect against races (e.g. atomic_t) + disk->queue = q; + disk->major = MARS_MAJOR; //TODO: make this dynamic for >256 devices + disk->first_minor = minor; + disk->fops = &if_device_blkdev_ops; + sprintf(disk->disk_name, "mars%d", minor); + MARS_DBG("created device name %s\n", disk->disk_name); + disk->private_data = input; + set_capacity(disk, 1024); //XXX + + blk_queue_make_request(q, if_device_make_request); + blk_queue_max_segment_size(q, MARS_MAX_SEGMENT_SIZE); + blk_queue_bounce_limit(q, BLK_BOUNCE_ANY); + + MARS_DBG("4\n"); + input->bdev = bdget(MKDEV(disk->major, minor)); + /* we have no partitions. we contain only ourselves. */ + input->bdev->bd_contains = input->bdev; + +#if 0 // ??? + q->backing_dev_info.congested_fn = mars_congested; + q->backing_dev_info.congested_data = input; +#endif + +#if 0 // ??? + blk_queue_merge_bvec(q, mars_merge_bvec); + q->queue_lock = &input->req_lock; /* needed since we use */ + /* plugging on a queue, that actually has no requests! */ + q->unplug_fn = mars_unplug_fn; +#endif + + MARS_DBG("99999\n"); + add_disk(disk); + input->disk = disk; + input->mio_size = 1024; //TODO: make this dynamic + return 0; +} + +static int if_device_input_destruct(struct if_device_input *input) +{ + if (input->bdev) + bdput(input->bdev); + if (input->disk) { + del_gendisk(input->disk); + //put_disk(input->disk); + } + if (input->q) + blk_cleanup_queue(input->q); + return 0; +} + +///////////////////////// static structs //////////////////////// + +static struct if_device_brick_ops if_device_brick_ops = { +}; + +static struct if_device_input_type if_device_input_type = { + .type_name = "if_device_input", + .input_size = sizeof(struct if_device_input), + .input_construct = &if_device_input_construct, + .input_destruct = &if_device_input_destruct, +}; + +static struct if_device_input_type *if_device_input_types[] = { + &if_device_input_type, +}; + +struct if_device_brick_type if_device_brick_type = { + .type_name = "if_device_brick", + .brick_size = sizeof(struct if_device_brick), + .max_inputs = 1, + .max_outputs = 0, + .master_ops = &if_device_brick_ops, + .default_input_types = if_device_input_types, + .brick_construct = &if_device_brick_construct, + .brick_destruct = &if_device_brick_destruct, +}; +EXPORT_SYMBOL_GPL(if_device_brick_type); + +////////////////// module init stuff ///////////////////////// + +static void __exit exit_if_device(void) +{ + int status; + printk(MARS_INFO "exit_if_device()\n"); + status = if_device_unregister_brick_type(); + unregister_blkdev(DRBD_MAJOR, "mars"); +} + +static int __init init_if_device(void) +{ + int status; + printk(MARS_INFO "init_if_device()\n"); + status = register_blkdev(DRBD_MAJOR, "mars"); + if (status) + return status; + status = if_device_register_brick_type(); + if (status) + goto err_device; + return status; +err_device: + MARS_ERR("init_if_device() status=%d\n", status); + exit_if_device(); + return status; +} + +MODULE_DESCRIPTION("MARS if_device"); +MODULE_AUTHOR("Thomas Schoebel-Theuer "); +MODULE_LICENSE("GPL"); + +module_init(init_if_device); +module_exit(exit_if_device); diff --git a/mars_if_device.h b/mars_if_device.h new file mode 100644 index 00000000..f05a5f7d --- /dev/null +++ b/mars_if_device.h @@ -0,0 +1,18 @@ +// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG +struct if_device_brick { + MARS_BRICK(if_device); +}; + +struct if_device_input { + MARS_INPUT(if_device); + struct request_queue *q; + struct gendisk *disk; + struct block_device *bdev; + int mio_size; +}; + +struct if_device_output { + MARS_OUTPUT(if_device); +}; + +MARS_TYPES(if_device); diff --git a/mars_test.c b/mars_test.c new file mode 100644 index 00000000..fa86d035 --- /dev/null +++ b/mars_test.c @@ -0,0 +1,89 @@ +// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG + +#include +#include +#include + +#include +#include +#include + +#define _STRATEGY +#include "mars.h" + +#include "mars_if_device.h" +#include "mars_device_sync.h" + +GENERIC_MAKE_CONNECT(if_device, device_sync); + +static struct if_device_brick *if_brick = NULL; +static struct device_sync_brick *device_brick = NULL; + +void make_test_instance(void) +{ + static char *names[] = { "brick" }; + int size = 1024; + int status; + void *mem = kzalloc(size, GFP_KERNEL); + if (!mem) { + MARS_ERR("cannot grab test memory\n"); + return; + } + + MARS_DBG("starting....\n"); + + status = device_sync_brick_init_full(mem, size, &device_sync_brick_type, NULL, NULL, names); + MARS_DBG("done (status=%d)\n", status); + if (!status) + device_brick = mem; + + mem = kzalloc(size, GFP_KERNEL); + if (!mem) { + MARS_ERR("cannot grab test memory\n"); + return; + } + + status = if_device_brick_init_full(mem, size, &if_device_brick_type, NULL, NULL, names); + MARS_DBG("done (status=%d)\n", status); + if (!status) + if_brick = mem; + + status = if_device_device_sync_connect(if_brick->inputs[0], device_brick->outputs[0]); + MARS_DBG("connect (status=%d)\n", status); + +} + +void destroy_test_instance(void) +{ + if (if_brick) { + if_device_device_sync_disconnect(if_brick->inputs[0]); + if_device_brick_exit_full(if_brick); + kfree(if_brick); + if_brick = NULL; + } + if (device_brick) { + device_sync_brick_exit_full(device_brick); + kfree(device_brick); + device_brick = NULL; + } +} + +static void __exit exit_test(void) +{ + MARS_DBG("destroy_test_instance()\n"); + destroy_test_instance(); +} + +static int __init init_test(void) +{ + MARS_DBG("make_test_instance()\n"); + make_test_instance(); + return 0; +} + +MODULE_DESCRIPTION("MARS TEST"); +MODULE_AUTHOR("Thomas Schoebel-Theuer "); +MODULE_LICENSE("GPL"); + +module_init(init_test); +module_exit(exit_test);