RepoMirrors
/
mars
mirror of https://github.com/schoebel/mars
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
mars/mars.h

407 lines
11 KiB
C
Raw Blame History

// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG
#ifndef MARS_H
#define MARS_H
#include <linux/semaphore.h>
#include <linux/rwsem.h>
//#define MARS_TRACING // write runtime trace data to /mars/trace.csv
#define msleep msleep_interruptible
extern long long mars_global_memlimit;
/////////////////////////////////////////////////////////////////////////
// include the generic brick infrastructure
#ifdef BRICK_H
#error "brick.h must not be already included - please reorganize your includes"
#endif
#define BRICK_OBJ_MREF 0
#define BRICK_OBJ_MAX 1
#define BRICK_DEPTH_MAX 128
#include "brick.h"
#define GFP_MARS GFP_NOIO
//#define GFP_MARS GFP_KERNEL // can lead to deadlocks!
/////////////////////////////////////////////////////////////////////////
// MARS-specific debugging helpers
#define MARS_DELAY /**/
//#define MARS_DELAY msleep(20000)
#define MARS_FATAL "MARS_FATAL "
#define MARS_ERROR "MARS_ERROR "
#define MARS_WARNING "MARS_WARN "
#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_MSG(_stacktrace, PREFIX, _fmt, _args...) do { say(PREFIX _MARS_FMT(_fmt), ##_args); MARS_DELAY; if (_stacktrace) dump_stack(); } while (0)
#define MARS_FAT(_fmt, _args...) _MARS_MSG(true, MARS_FATAL, _fmt, ##_args)
#define MARS_ERR(_fmt, _args...) _MARS_MSG(true, MARS_ERROR, _fmt, ##_args)
#define MARS_WRN(_fmt, _args...) _MARS_MSG(false, MARS_WARNING, _fmt, ##_args)
#define MARS_INF(_fmt, _args...) _MARS_MSG(false, MARS_INFO, _fmt, ##_args)
#ifdef MARS_DEBUGGING
#define MARS_DBG(_fmt, _args...) _MARS_MSG(false, MARS_DEBUG, _fmt, ##_args)
#else
#define MARS_DBG(_args...) /**/
#endif
#ifdef IO_DEBUGGING
#define MARS_IO(_fmt, _args...) _MARS_MSG(false, MARS_DEBUG, _fmt, ##_args)
#else
#define MARS_IO(_args...) /*empty*/
#endif
#ifdef STAT_DEBUGGING
#define MARS_STAT MARS_INF
#else
#define MARS_STAT(_args...) /*empty*/
#endif
/////////////////////////////////////////////////////////////////////////
// MARS-specific definitions
#define MARS_PRIO_HIGH -1
#define MARS_PRIO_NORMAL 0 // this is automatically used by memset()
#define MARS_PRIO_LOW 1
#define MARS_PRIO_NR 3
// 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);
};
#ifdef MARS_TRACING
extern unsigned long long start_trace_clock;
#define MAX_TRACES 16
#define TRACING_INFO \
int ref_traces; \
unsigned long long ref_trace_stamp[MAX_TRACES]; \
const char *ref_trace_info[MAX_TRACES];
extern void _mars_log(char *buf, int len);
extern void mars_log(const char *fmt, ...);
extern void mars_trace(struct mref_object *mref, const char *info);
extern void mars_log_trace(struct mref_object *mref);
#else
#define TRACING_INFO /*empty*/
#define _mars_log(buf,len) /*empty*/
#define mars_log(fmt...) /*empty*/
#define mars_trace(mref,info) /*empty*/
#define mars_log_trace(mref) /*empty*/
#endif
#define MREF_OBJECT(PREFIX) \
GENERIC_OBJECT(PREFIX); \
/* supplied by caller */ \
void *ref_data; /* preset to NULL for buffered IO */ \
loff_t ref_pos; \
int ref_len; \
int ref_may_write; \
int ref_prio; \
int ref_timeout; \
/* maintained by the ref implementation, readable for callers */ \
loff_t ref_total_size; /* just for info, need not be implemented */ \
int ref_flags; \
int ref_rw; \
int ref_id; /* not mandatory; may be used for identification */ \
bool ref_skip_sync; /* skip sync for this particular mref */ \
/* 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; \
TRACING_INFO;
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); \
char *(*brick_statistics)(struct PREFIX##_brick *brick, int verbose); \
void (*reset_statistics)(struct PREFIX##_brick *brick); \
#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 memory allocation
extern void *mars_alloc(loff_t pos, int len);
extern void mars_free(void *data, int len);
extern struct page *mars_iomap(void *data, int *offset, int *len);
/////////////////////////////////////////////////////////////////////////
// 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_MAX] = { \
[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))) { \
list_del_init(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 const struct meta mars_timespec_meta[];
/////////////////////////////////////////////////////////////////////////
#ifdef _STRATEGY
#include "sy_old/strategy.h"
#endif
extern void mars_power_led_on(struct generic_brick *brick, bool val);
extern void mars_power_led_off(struct generic_brick *brick, bool val);
/* this should disappear!
*/
extern void (*_mars_trigger)(void);
#define mars_trigger() do { MARS_INF("trigger...\n"); if (_mars_trigger) _mars_trigger(); } while (0)
/////////////////////////////////////////////////////////////////////////
/* 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 const struct generic_brick_type *_client_brick_type;
extern const struct generic_brick_type *_bio_brick_type;
extern const 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
Reference in New Issue View Git Blame Copy Permalink