[RFC 13/32] mars: add new module xio

[Thomas Schoebel-Theuer]

Signed-off-by: Thomas Schoebel-Theuer <tst@xxxxxxxxxxxxxxxxxx>
---
 drivers/staging/mars/xio_bricks/xio.c | 227 ++++++++++++++++++++++++
 include/linux/xio/xio.h               | 319 ++++++++++++++++++++++++++++++++++
 2 files changed, 546 insertions(+)
 create mode 100644 drivers/staging/mars/xio_bricks/xio.c
 create mode 100644 include/linux/xio/xio.h

diff --git a/drivers/staging/mars/xio_bricks/xio.c b/drivers/staging/mars/xio_bricks/xio.c
new file mode 100644
index 000000000000..e58f11f497f9
--- /dev/null
+++ b/drivers/staging/mars/xio_bricks/xio.c
@@ -0,0 +1,227 @@
+/*
+ * MARS Long Distance Replication Software
+ *
+ * Copyright (C) 2010-2014 Thomas Schoebel-Theuer
+ * Copyright (C) 2011-2014 1&1 Internet AG
+ *
+ * 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/module.h>
+#include <linux/string.h>
+#include <linux/uaccess.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+
+#include <linux/xio/xio.h>
+
+/************************************************************/
+
+/*  infrastructure */
+
+struct banning xio_global_ban = {};
+atomic_t xio_global_io_flying = ATOMIC_INIT(0);
+
+/************************************************************/
+
+/*  object stuff */
+
+const struct generic_object_type aio_type = {
+	.object_type_name = "aio",
+	.default_size = sizeof(struct aio_object),
+	.object_type_nr = OBJ_TYPE_AIO,
+};
+
+/************************************************************/
+
+/*  brick stuff */
+
+/*******************************************************************/
+
+/*  meta descriptions */
+
+const struct meta xio_info_meta[] = {
+	META_INI(current_size,	  struct xio_info, FIELD_INT),
+	META_INI(tf_align,	  struct xio_info, FIELD_INT),
+	META_INI(tf_min_size,	  struct xio_info, FIELD_INT),
+	{}
+};
+
+const struct meta xio_aio_user_meta[] = {
+	META_INI(_object_cb.cb_error, struct aio_object, FIELD_INT),
+	META_INI(io_pos,	   struct aio_object, FIELD_INT),
+	META_INI(io_len,	   struct aio_object, FIELD_INT),
+	META_INI(io_may_write,	  struct aio_object, FIELD_INT),
+	META_INI(io_prio,	   struct aio_object, FIELD_INT),
+	META_INI(io_cs_mode,	   struct aio_object, FIELD_INT),
+	META_INI(io_timeout,	   struct aio_object, FIELD_INT),
+	META_INI(io_total_size,   struct aio_object, FIELD_INT),
+	META_INI(io_checksum,	   struct aio_object, FIELD_RAW),
+	META_INI(io_flags,	   struct aio_object, FIELD_INT),
+	META_INI(io_rw,    struct aio_object, FIELD_INT),
+	META_INI(io_id,    struct aio_object, FIELD_INT),
+	META_INI(io_skip_sync,	  struct aio_object, FIELD_INT),
+	{}
+};
+
+const struct meta xio_timespec_meta[] = {
+	META_INI_TRANSFER(tv_sec,  struct timespec, FIELD_UINT, 8),
+	META_INI_TRANSFER(tv_nsec, struct timespec, FIELD_UINT, 4),
+	{}
+};
+
+/************************************************************/
+
+/*  crypto stuff */
+
+#include <linux/scatterlist.h>
+#include <linux/crypto.h>
+
+/* 896545098777564212b9e91af4c973f094649aa7 */
+#ifndef crt_hash
+#define HAS_NEW_CRYPTO
+#endif
+
+#ifdef HAS_NEW_CRYPTO
+
+/* Nor now, use shash.
+ * Later, asynchronous support should be added for full exploitation
+ * of crypto hardware.
+ */
+#include <crypto/hash.h>
+
+static struct crypto_shash *xio_tfm;
+int xio_digest_size;
+
+struct mars_sdesc {
+	struct shash_desc shash;
+	char ctx[];
+};
+
+void xio_digest(unsigned char *digest, void *data, int len)
+{
+	int size = sizeof(struct mars_sdesc) + crypto_shash_descsize(xio_tfm);
+	struct mars_sdesc *sdesc = brick_mem_alloc(size);
+	int status;
+
+	sdesc->shash.tfm = xio_tfm;
+	sdesc->shash.flags = 0;
+
+	memset(digest, 0, xio_digest_size);
+	status = crypto_shash_digest(&sdesc->shash, data, len, digest);
+	if (unlikely(status < 0))
+		XIO_ERR(
+		"cannot calculate cksum on %p len=%d, status=%d\n",
+			 data, len,
+			 status);
+
+	brick_mem_free(sdesc);
+}
+
+#else  /* HAS_NEW_CRYPTO */
+
+/* Old implementation, to disappear.
+ * Was a quick'n dirty lab prototype with unnecessary
+ * global variables and locking.
+ */
+
+static struct crypto_hash *xio_tfm;
+static struct semaphore tfm_sem;
+int xio_digest_size;
+
+void xio_digest(unsigned char *digest, void *data, int len)
+{
+	struct hash_desc desc = {
+		.tfm = xio_tfm,
+		.flags = 0,
+	};
+	struct scatterlist sg;
+
+	memset(digest, 0, xio_digest_size);
+
+	/*  TODO: use per-thread instance, omit locking */
+	down(&tfm_sem);
+
+	crypto_hash_init(&desc);
+	sg_init_table(&sg, 1);
+	sg_set_buf(&sg, data, len);
+	crypto_hash_update(&desc, &sg, sg.length);
+	crypto_hash_final(&desc, digest);
+	up(&tfm_sem);
+}
+
+#endif /* HAS_NEW_CRYPTO */
+
+void aio_checksum(struct aio_object *aio)
+{
+	unsigned char checksum[xio_digest_size];
+	int len;
+
+	if (aio->io_cs_mode <= 0 || !aio->io_data)
+		goto out_return;
+	xio_digest(checksum, aio->io_data, aio->io_len);
+
+	len = sizeof(aio->io_checksum);
+	if (len > xio_digest_size)
+		len = xio_digest_size;
+	memcpy(&aio->io_checksum, checksum, len);
+out_return:;
+}
+
+/*******************************************************************/
+
+/*  init stuff */
+
+int __init init_xio(void)
+{
+	XIO_INF("init_xio()\n");
+
+	sema_init(&tfm_sem, 1);
+
+#ifdef HAS_NEW_CRYPTO
+	xio_tfm = crypto_alloc_shash("md5", 0, 0);
+	if (unlikely(!xio_tfm) || IS_ERR(xio_tfm)) {
+		XIO_ERR(
+		"cannot alloc crypto hash, status=%ld\n",
+			 PTR_ERR(xio_tfm));
+		return -ELIBACC;
+	}
+	xio_digest_size = crypto_shash_digestsize(xio_tfm);
+#else  /* HAS_NEW_CRYPTO */
+	xio_tfm = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
+	if (!xio_tfm) {
+		XIO_ERR("cannot alloc crypto hash\n");
+		return -ENOMEM;
+	}
+	if (IS_ERR(xio_tfm)) {
+		XIO_ERR("alloc crypto hash failed, status = %d\n", (int)PTR_ERR(xio_tfm));
+		return PTR_ERR(xio_tfm);
+	}
+	xio_digest_size = crypto_hash_digestsize(xio_tfm);
+#endif /* HAS_NEW_CRYPTO */
+	XIO_INF("digest_size = %d\n", xio_digest_size);
+
+	return 0;
+}
+
+void exit_xio(void)
+{
+	XIO_INF("exit_xio()\n");
+
+	if (xio_tfm) {
+#ifdef HAS_NEW_CRYPTO
+		crypto_free_shash(xio_tfm);
+#else  /* HAS_NEW_CRYPTO */
+		crypto_free_hash(xio_tfm);
+#endif /* HAS_NEW_CRYPTO */
+	}
+}
diff --git a/include/linux/xio/xio.h b/include/linux/xio/xio.h
new file mode 100644
index 000000000000..d26a1c761ee3
--- /dev/null
+++ b/include/linux/xio/xio.h
@@ -0,0 +1,319 @@
+/*
+ * MARS Long Distance Replication Software
+ *
+ * Copyright (C) 2010-2014 Thomas Schoebel-Theuer
+ * Copyright (C) 2011-2014 1&1 Internet AG
+ *
+ * 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 XIO_H
+#define XIO_H
+
+#include <linux/semaphore.h>
+#include <linux/rwsem.h>
+#include <linux/major.h>
+
+#if defined(CONFIG_CRYPTO_LZO) || defined(CONFIG_CRYPTO_LZO_MODULE)
+#define __HAVE_LZO
+#endif
+
+#ifdef __enabled_CONFIG_CRYPTO_LZO
+#if __enabled_CONFIG_CRYPTO_LZO
+#define __HAVE_LZO
+#endif
+#endif
+
+#ifdef __enabled_CONFIG_CRYPTO_LZO_MODULE
+#if __enabled_CONFIG_CRYPTO_LZO_MODULE
+#define __HAVE_LZO
+#endif
+#endif
+
+/* TRANSITIONAL compatibility to BOTH the old prepatch
+ * and the new wrapper around vfs_*(). Both will be replaced
+ * for kernel upstream.
+ */
+#include <linux/brick/vfs_compat.h>
+#ifndef MARS_MAJOR
+#define __USE_COMPAT
+#endif
+
+/***********************************************************************/
+
+/*  include the generic brick infrastructure */
+
+#define OBJ_TYPE_AIO			0
+#define OBJ_TYPE_MAX			1
+
+#include <linux/brick/brick.h>
+#include <linux/brick/brick_mem.h>
+#include <linux/brick/lamport.h>
+#include <linux/brick/lib_timing.h>
+
+/***********************************************************************/
+
+/*  XIO-specific debugging helpers */
+
+#define _XIO_MSG(_class, _dump, _fmt, _args...)				\
+	brick_say(_class, _dump, "XIO", __BASE_FILE__, __LINE__, __func__, _fmt, ##_args)
+
+#define XIO_FAT(_fmt, _args...) _XIO_MSG(SAY_FATAL, true,  _fmt, ##_args)
+#define XIO_ERR(_fmt, _args...) _XIO_MSG(SAY_ERROR, false, _fmt, ##_args)
+#define XIO_WRN(_fmt, _args...) _XIO_MSG(SAY_WARN,  false, _fmt, ##_args)
+#define XIO_INF(_fmt, _args...) _XIO_MSG(SAY_INFO,  false, _fmt, ##_args)
+
+#ifdef XIO_DEBUGGING
+#define XIO_DBG(_fmt, _args...) _XIO_MSG(SAY_DEBUG, false, _fmt, ##_args)
+#else
+#define XIO_DBG(_args...) /**/
+#endif
+
+/***********************************************************************/
+
+/*  XIO-specific definitions */
+
+#define XIO_PRIO_HIGH			-1
+#define XIO_PRIO_NORMAL			0 /*  this is automatically used by memset() */
+#define XIO_PRIO_LOW			1
+#define XIO_PRIO_NR			3
+
+/*  object stuff */
+
+/* aio */
+
+#define AIO_UPTODATE			1
+#define AIO_READING			2
+#define AIO_WRITING			4
+
+extern const struct generic_object_type aio_type;
+
+#define XIO_CHECKSUM_SIZE		16
+
+#define AIO_OBJECT(OBJTYPE)						\
+	CALLBACK_OBJECT(OBJTYPE);					\
+	/* supplied by caller */					\
+	void  *io_data;  /* preset to NULL for buffered IO */		\
+	loff_t io_pos;							\
+	int    io_len;							\
+	int    io_may_write;						\
+	int    io_prio;							\
+	int    io_timeout;						\
+	int    io_cs_mode; /* 0 = off, 1 = checksum + data, 2 = checksum only */\
+	/* maintained by the aio implementation, readable for callers */\
+	loff_t io_total_size; /* just for info, need not be implemented */\
+	unsigned char io_checksum[XIO_CHECKSUM_SIZE];			\
+	int    io_flags;						\
+	int    io_rw;							\
+	int    io_id; /* not mandatory; may be used for identification */\
+	bool   io_skip_sync /* skip sync for this particular aio */
+
+struct aio_object {
+	AIO_OBJECT(aio);
+};
+
+/*  internal helper structs */
+
+struct xio_info {
+	loff_t current_size;
+
+	int tf_align;	 /*  transfer alignment constraint */
+	int tf_min_size; /*  transfer is only possible in multiples of this */
+};
+
+/*  brick stuff */
+
+#define XIO_BRICK(BRITYPE)						\
+	GENERIC_BRICK(BRITYPE);						\
+	struct generic_object_layout aio_object_layout;			\
+	struct list_head global_brick_link;				\
+	struct list_head dent_brick_link;				\
+	const char *brick_name;						\
+	const char *brick_path;						\
+	void *private_ptr;						\
+	void **kill_ptr;						\
+	int *mode_ptr;							\
+	int kill_round;							\
+	bool killme;							\
+	void (*show_status)(struct xio_brick *brick, bool shutdown)
+
+struct xio_brick {
+	XIO_BRICK(xio);
+};
+
+#define XIO_INPUT(BRITYPE)						\
+	GENERIC_INPUT(BRITYPE)
+
+struct xio_input {
+	XIO_INPUT(xio);
+};
+
+#define XIO_OUTPUT(BRITYPE)						\
+	GENERIC_OUTPUT(BRITYPE)
+
+struct xio_output {
+	XIO_OUTPUT(xio);
+};
+
+#define XIO_BRICK_OPS(BRITYPE)						\
+	GENERIC_BRICK_OPS(BRITYPE);					\
+	char *(*brick_statistics)(struct BRITYPE##_brick *brick, int verbose);\
+	void (*reset_statistics)(struct BRITYPE##_brick *brick)
+
+#define XIO_OUTPUT_OPS(BRITYPE)						\
+	GENERIC_OUTPUT_OPS(BRITYPE);					\
+	int  (*xio_get_info)(struct BRITYPE##_output *output, struct xio_info *info);\
+	/* aio */							\
+	int  (*aio_get)(struct BRITYPE##_output *output, struct aio_object *aio);\
+	void (*aio_io)(struct BRITYPE##_output *output, struct aio_object *aio);\
+	void (*aio_put)(struct BRITYPE##_output *output, struct aio_object *aio)
+
+/*  all non-extendable types */
+
+#define _XIO_TYPES(BRITYPE)						\
+									\
+struct BRITYPE##_brick_ops {						\
+	XIO_BRICK_OPS(BRITYPE);						\
+};									\
+									\
+struct BRITYPE##_output_ops {						\
+	XIO_OUTPUT_OPS(BRITYPE);					\
+};									\
+									\
+struct BRITYPE##_brick_type {						\
+	GENERIC_BRICK_TYPE(BRITYPE);					\
+};									\
+									\
+struct BRITYPE##_input_type {						\
+	GENERIC_INPUT_TYPE(BRITYPE);					\
+};									\
+									\
+struct BRITYPE##_output_type {						\
+	GENERIC_OUTPUT_TYPE(BRITYPE);					\
+};									\
+									\
+struct BRITYPE##_callback {						\
+	GENERIC_CALLBACK(BRITYPE);					\
+};									\
+									\
+DECLARE_BRICK_FUNCTIONS(BRITYPE)
+
+#define XIO_TYPES(BRITYPE)						\
+									\
+_XIO_TYPES(BRITYPE);							\
+									\
+DECLARE_ASPECT_FUNCTIONS(BRITYPE, aio)					\
+extern int init_xio_##BRITYPE(void);					\
+extern void exit_xio_##BRITYPE(void)
+
+/*  instantiate pseudo base-classes */
+
+DECLARE_OBJECT_FUNCTIONS(aio)
+_XIO_TYPES(xio);
+DECLARE_ASPECT_FUNCTIONS(xio, aio)
+
+/***********************************************************************/
+
+/*  XIO-specific helpers */
+
+#define XIO_MAKE_STATICS(BRITYPE)					\
+									\
+int BRITYPE##_brick_nr = -EEXIST;					\
+									\
+static const struct generic_aspect_type BRITYPE##_aio_aspect_type = {	\
+	.aspect_type_name = #BRITYPE "_aio_aspect_type",		\
+	.object_type = &aio_type,					\
+	.aspect_size = sizeof(struct BRITYPE##_aio_aspect),		\
+	.init_fn = BRITYPE##_aio_aspect_init_fn,			\
+	.exit_fn = BRITYPE##_aio_aspect_exit_fn,			\
+};									\
+									\
+static const struct generic_aspect_type *BRITYPE##_aspect_types[OBJ_TYPE_MAX] = {\
+	[OBJ_TYPE_AIO] = &BRITYPE##_aio_aspect_type,			\
+}
+
+extern const struct meta xio_info_meta[];
+extern const struct meta xio_aio_user_meta[];
+extern const struct meta xio_timespec_meta[];
+
+/***********************************************************************/
+
+/* Some minimal upcalls from generic IO layer to the strategy layer.
+ * TODO: abstract away.
+ */
+
+extern void xio_set_power_on_led(struct xio_brick *brick, bool val);
+extern void xio_set_power_off_led(struct xio_brick *brick, bool val);
+
+/* this should disappear!
+ */
+extern void (*_local_trigger)(void);
+extern void (*_remote_trigger)(void);
+#define local_trigger() do { if (_local_trigger) { XIO_DBG("trigger...\n"); _local_trigger(); } } while (0)
+#define remote_trigger()						\
+do { if (_remote_trigger) { XIO_DBG("remote_trigger...\n"); _remote_trigger(); } } while (0)
+
+/***********************************************************************/
+
+/* Some global stuff.
+ */
+
+extern struct banning xio_global_ban;
+
+extern atomic_t xio_global_io_flying;
+
+extern int xio_throttle_start;
+extern int xio_throttle_end;
+
+/***********************************************************************/
+
+/* Some special brick types for avoidance of cyclic references.
+ *
+ * The client/server network bricks use this for independent instantiation
+ * from the main instantiation logic (separate modprobe for xio_server
+ * is possible).
+ */
+extern const struct generic_brick_type *_client_brick_type;
+extern const struct generic_brick_type *_bio_brick_type;
+extern const struct generic_brick_type *_sio_brick_type;
+
+/***********************************************************************/
+
+/* Crypto stuff
+ */
+
+extern int xio_digest_size;
+extern void xio_digest(unsigned char *digest, void *data, int len);
+extern void aio_checksum(struct aio_object *aio);
+
+/***********************************************************************/
+
+/* Crash-testing instrumentation.
+ * Only for debugging. Never use this for production.
+ * Simulate a crash at the "wrong moment".
+ */
+
+#ifdef CONFIG_MARS_DEBUG
+extern int mars_crash_mode;
+extern int mars_hang_mode;
+extern void _crashme(int mode, bool do_sync);
+#else
+extern inline void _crashme(int mode, bool do_sync) {}
+#endif
+
+/***********************************************************************/
+
+/*  init */
+
+extern int init_xio(void);
+extern void exit_xio(void);
+
+#endif
-- 
2.11.0