mars/mars.h

// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG
#ifndef MARS_H
#define MARS_H

#include <linux/list.h>
#include <linux/semaphore.h>

#include <asm/spinlock.h>
#include <asm/atomic.h>

#define MARS_DELAY /**/
//#define MARS_DELAY msleep(20000)

#define MARS_FATAL "MARS_FATAL  "
#define MARS_ERROR "MARS_ERROR  "
#define MARS_INFO  "MARS_INFO   "
#define MARS_DEBUG "MARS_DEBUG  "
#define _MARS_FMT(fmt) "[%s] " __BASE_FILE__ " %d %s(): " fmt, current->comm, __LINE__, __FUNCTION__
//#define _MARS_FMT(fmt) _BRICK_FMT(fmt)

#define MARS_FAT(fmt, args...) do { printk(MARS_FATAL _MARS_FMT(fmt), ##args); MARS_DELAY; } while (0)
#define MARS_ERR(fmt, args...) do { printk(MARS_ERROR _MARS_FMT(fmt), ##args); MARS_DELAY; } while (0)
#define MARS_INF(fmt, args...) do { printk(MARS_INFO  _MARS_FMT(fmt), ##args); } while (0)
#ifdef MARS_DEBUGGING
#define MARS_DBG(fmt, args...) do { printk(MARS_DEBUG _MARS_FMT(fmt), ##args); } while (0)
#else
#define MARS_DBG(args...) /**/
#endif
#ifdef IO_DEBUGGING
#define MARS_IO MARS_DBG
#else
#define MARS_IO(args...) /*empty*/
#endif
#ifdef STAT_DEBUGGING
#define MARS_STAT MARS_INF
#else
#define MARS_IO(args...) /*empty*/
#endif

#define BRICK_OBJ_MREF            0
#define BRICK_OBJ_NR                  1

#define GFP_MARS GFP_NOIO

#include "brick.h"

/////////////////////////////////////////////////////////////////////////

// MARS-specific definitions

// object stuff

/* mref */

#define MREF_UPTODATE        1
#define MREF_READING         2
#define MREF_WRITING         4

extern const struct generic_object_type mref_type;

struct mref_aspect {
	GENERIC_ASPECT(mref);
};

struct mref_aspect_layout {
	GENERIC_ASPECT_LAYOUT(mref);
};

struct mref_object_layout {
	GENERIC_OBJECT_LAYOUT(mref);
};

#define MREF_OBJECT(PREFIX)						\
	GENERIC_OBJECT(PREFIX);						\
	/* supplied by caller */					\
	loff_t ref_pos;							\
	int    ref_len;							\
	int    ref_may_write;						\
	void  *ref_data;         /* preset to NULL for buffered IO */	\
	/* maintained by the ref implementation, readable for callers */ \
	int    ref_flags;						\
	int    ref_rw;							\
	int    ref_id; /* not mandatory; may be used for identification */ \
	/* maintained by the ref implementation, incrementable for	\
	 * callers (but not decrementable! use ref_put()) */		\
	atomic_t ref_count;						\
        /* callback part */						\
	struct generic_callback *ref_cb;				\
	struct generic_callback _ref_cb;				\

struct mref_object {
	MREF_OBJECT(mref);
};

// internal helper structs

struct mars_info {
	loff_t current_size;
	int transfer_order;
	int transfer_size;
	struct file *backing_file;
};

// brick stuff

#define MARS_BRICK(PREFIX)						\
	GENERIC_BRICK(PREFIX);						\
	struct list_head global_brick_link;				\
	struct list_head dent_brick_link;				\
	const char *brick_path;						\
	struct mars_global *global;					\
	int status_level;						\

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_get_info)(struct PREFIX##_output *output, struct mars_info *info); \
	/* mref */							\
	int  (*mref_get)(struct PREFIX##_output *output, struct mref_object *mref); \
	void (*mref_io)(struct PREFIX##_output *output, struct mref_object *mref); \
	void (*mref_put)(struct PREFIX##_output *output, struct mref_object *mref); \

// all non-extendable types

#define _MARS_TYPES(BRICK)						\
									\
struct BRICK##_brick_ops {                                              \
        MARS_BRICK_OPS(BRICK);                                          \
};                                                                      \
                                                                        \
struct BRICK##_output_ops {					        \
	MARS_OUTPUT_OPS(BRICK);						\
};                                                                      \
									\
struct BRICK##_brick_type {                                             \
	GENERIC_BRICK_TYPE(BRICK);                                      \
};									\
									\
struct BRICK##_input_type {					        \
	GENERIC_INPUT_TYPE(BRICK);                                      \
};									\
									\
struct BRICK##_output_type {					        \
	GENERIC_OUTPUT_TYPE(BRICK);                                     \
};									\
									\
struct BRICK##_callback {					        \
	GENERIC_CALLBACK(BRICK);					\
};									\
									\
GENERIC_MAKE_FUNCTIONS(BRICK);					        \
GENERIC_MAKE_CONNECT(BRICK,BRICK);				        \


#define MARS_TYPES(BRICK)						\
									\
_MARS_TYPES(BRICK)						        \
									\
struct BRICK##_object_layout;						\
									\
GENERIC_MAKE_CONNECT(generic,BRICK);				        \
GENERIC_OBJECT_LAYOUT_FUNCTIONS(BRICK);				        \
GENERIC_ASPECT_LAYOUT_FUNCTIONS(BRICK,mref);				\
GENERIC_ASPECT_FUNCTIONS(BRICK,mref);					\


// instantiate all mars-specific functions

GENERIC_OBJECT_FUNCTIONS(mref);

// instantiate a pseudo base-class "mars"

_MARS_TYPES(mars);
GENERIC_OBJECT_LAYOUT_FUNCTIONS(mars);
GENERIC_ASPECT_FUNCTIONS(mars,mref);

/////////////////////////////////////////////////////////////////////////

// MARS-specific helpers

#define MARS_MAKE_STATICS(BRICK)					\
									\
int BRICK##_brick_nr = -EEXIST;				                \
EXPORT_SYMBOL_GPL(BRICK##_brick_nr);			                \
									\
static const struct generic_aspect_type BRICK##_mref_aspect_type = {    \
	.aspect_type_name = #BRICK "_mref_aspect_type",			\
	.object_type = &mref_type,					\
	.aspect_size = sizeof(struct BRICK##_mref_aspect),		\
	.init_fn = BRICK##_mref_aspect_init_fn,				\
	.exit_fn = BRICK##_mref_aspect_exit_fn,				\
};									\
									\
static const struct generic_aspect_type *BRICK##_aspect_types[BRICK_OBJ_NR] = {	\
	[BRICK_OBJ_MREF] = &BRICK##_mref_aspect_type,			\
};									\

#define _CHECK_ATOMIC(atom,OP,minval)					\
	do {								\
		int test = atomic_read(atom);				\
		if (test OP (minval)) {					\
			atomic_set(atom, minval);			\
			MARS_ERR("%d: atomic " #atom " " #OP " " #minval " (%d)\n", __LINE__, test); \
		}							\
	} while (0)

#define CHECK_ATOMIC(atom,minval)			\
	_CHECK_ATOMIC(atom, <, minval)

#define CHECK_HEAD_EMPTY(head)						\
	if (unlikely(!list_empty(head))) {				\
		INIT_LIST_HEAD(head);					\
		MARS_ERR("%d: list_head " #head " (%p) not empty\n", __LINE__, head); \
	}								\

#define CHECK_PTR(ptr,label)						\
	if (unlikely(!(ptr))) {						\
		MARS_FAT("%d: ptr " #ptr " is NULL\n", __LINE__);	\
		goto label;						\
	}

#define _CHECK(ptr,label)						\
	if (unlikely(!(ptr))) {						\
		MARS_FAT("%d: condition " #ptr " is VIOLATED\n", __LINE__); \
		goto label;						\
	}

extern const struct meta mars_info_meta[];
extern const struct meta mars_mref_meta[];

/////////////////////////////////////////////////////////////////////////

extern struct mars_global *mars_global;

extern void mars_trigger(void);
extern int  mars_power_button(struct mars_brick *brick, bool val);
extern void mars_power_led_on(struct mars_brick *brick, bool val);
extern void mars_power_led_off(struct mars_brick *brick, bool val);

extern int  mars_power_button_recursive(struct mars_brick *brick, bool val, int timeout);

/////////////////////////////////////////////////////////////////////////

#ifdef _STRATEGY // call this only in strategy bricks, never in ordinary bricks

#define MARS_ARGV_MAX 4
#define MARS_PATH_MAX 64

extern char *my_id(void);

#define MARS_DENT(TYPE)							\
	struct list_head dent_link;					\
	struct list_head brick_list;					\
	struct TYPE *d_parent;						\
	char *d_argv[MARS_ARGV_MAX];  /* for internal use, will be automatically deallocated*/ \
	char *d_args; /* ditto uninterpreted */				\
	char *d_name; /* current path component */			\
	char *d_rest; /* some "meaningful" rest of d_name*/		\
	char *d_path; /* full absolute path */				\
	int   d_namelen;						\
	int   d_pathlen;						\
	int   d_depth;							\
	unsigned int d_type; /* from readdir() => often DT_UNKNOWN => don't rely on it, use new_stat.mode instead */ \
	int   d_class;    /* for pre-grouping order */			\
	int   d_serial;   /* for pre-grouping order */			\
	int   d_version;  /* dynamic programming per call of mars_ent_work() */ \
	bool d_activate;  /* tells whether activation should start */	\
	bool d_kill_inactive; /* whether !d_activate should kill operation  */	\
	char d_once_error;						\
	struct kstat new_stat;						\
	struct kstat old_stat;						\
	char *new_link;							\
	char *old_link;							\
	struct mars_global *d_global;					\
	void *d_private;

struct mars_dent {
	MARS_DENT(mars_dent);
};

extern const struct meta mars_timespec_meta[];
extern const struct meta mars_kstat_meta[];
extern const struct meta mars_dent_meta[];

struct mars_global {
	struct semaphore mutex;
	struct generic_switch global_power;
	struct list_head dent_anchor;
	struct list_head brick_anchor;
	volatile bool main_trigger;
	wait_queue_head_t main_event;
	//void *private;
};

typedef int (*mars_dent_checker)(const char *path, const char *name, int namlen, unsigned int d_type, int *prefix, int *serial);
typedef int (*mars_dent_worker)(struct mars_global *global, struct mars_dent *dent, bool direction);

extern int mars_dent_work(struct mars_global *global, char *dirname, int allocsize, mars_dent_checker checker, mars_dent_worker worker, void *buf, int maxdepth);
extern struct mars_dent *_mars_find_dent(struct mars_global *global, const char *path);
extern struct mars_dent *mars_find_dent(struct mars_global *global, const char *path);
extern void mars_kill_dent(struct mars_dent *dent);
extern void mars_free_dent(struct mars_dent *dent);
extern void mars_free_dent_all(struct list_head *anchor);

// low-level brick instantiation

extern struct mars_brick *mars_find_brick(struct mars_global *global, const void *brick_type, const char *path);
extern struct mars_brick *mars_make_brick(struct mars_global *global, struct mars_dent *belongs, const void *_brick_type, const char *path, const char *name);
extern int mars_free_brick(struct mars_brick *brick);
extern int mars_kill_brick(struct mars_brick *brick);

// mid-level brick instantiation (identity is based on path strings)

extern char *vpath_make(struct mars_dent *parent, const char *fmt, va_list *args);
extern char *path_make(struct mars_dent *parent, const char *fmt, ...);

extern struct mars_brick *path_find_brick(struct mars_global *global, const void *brick_type, struct mars_dent *parent, const char *fmt, ...);

/* Create a new brick and connect its inputs to a set of predecessors.
 * When @timeout > 0, switch on the brick as well as its predecessors.
 */
extern struct mars_brick *make_brick_all(
	struct mars_global *global,
	struct mars_dent *parent,
	struct mars_dent *belongs,
	int timeout,
	const char *new_name,
	const struct generic_brick_type *new_brick_type,
	const struct generic_brick_type *prev_brick_type[],
	const char *new_fmt,
	const char *prev_fmt[],
	int prev_count,
	...
	);

// general MARS infrastructure

#define MARS_ERR_ONCE(dent, args...) if (!dent->d_once_error++) MARS_ERR(args)

/* General fs wrappers (for abstraction)
 */
extern int mars_lstat(const char *path, struct kstat *stat);
extern int mars_mkdir(const char *path);
extern int mars_symlink(const char *oldpath, const char *newpath, const struct timespec *stamp, uid_t uid);
extern int mars_rename(const char *oldpath, const char *newpath);
extern int mars_chmod(const char *path, mode_t mode);
extern int mars_lchown(const char *path, uid_t uid);

#endif // _STRATEGY

/* 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 mars_server
 * is possible).
 */
extern struct generic_brick_type *_client_brick_type;
extern struct generic_brick_type *_aio_brick_type;

/* Kludge: our kernel threads will have no mm context, but need one
 * for stuff like ioctx_alloc() / aio_setup_ring() etc
 * which expect userspace resources.
 * We fake one.
 * TODO: factor out the userspace stuff from AIO such that
 * this fake is no longer necessary.
 * Even better: replace do_mmap() in AIO stuff by something
 * more friendly to kernelspace apps.
 */
#include <linux/mmu_context.h>

extern struct mm_struct *mm_fake;

inline void set_fake(void)
{
	mm_fake = current->mm;
	if (mm_fake) {
		atomic_inc(&mm_fake->mm_count);
		atomic_inc(&mm_fake->mm_users);
	}
}

inline void put_fake(void)
{
	if (mm_fake) {
		atomic_dec(&mm_fake->mm_users);
		mmput(mm_fake);
		mm_fake = NULL;
	}
}

inline struct mm_struct *fake_mm(void)
{
#if 0
	if (!current->mm) {
		// will be never released.... ;)
		atomic_inc(&(current->mm = &init_mm)->mm_count);
	}
	return NULL;
#else
	struct mm_struct *old = current->mm;
	use_mm(mm_fake);
	return old;
#endif
}
/* Cleanup faked mm, otherwise do_exit() will crash
 */
inline void cleanup_mm(struct mm_struct *old)
{
#if 0
	if (current->mm == &init_mm) {
		current->mm = NULL;
	}
#else
	unuse_mm(old);
#endif
#if 1
	for (;;) msleep(1000);
#endif
}

#endif