[deliverable/linux.git] / drivers / staging / ramster / tmem.h

/*
 * tmem.h
 *
 * Transcendent memory
 *
 * Copyright (c) 2009-2012, Dan Magenheimer, Oracle Corp.
 */

#ifndef _TMEM_H_
#define _TMEM_H_

#include <linux/types.h>
#include <linux/highmem.h>
#include <linux/hash.h>
#include <linux/atomic.h>

/*
 * These are defined by the Xen<->Linux ABI so should remain consistent
 */
#define TMEM_POOL_PERSIST		1
#define TMEM_POOL_SHARED		2
#define TMEM_POOL_PRECOMPRESSED		4
#define TMEM_POOL_PAGESIZE_SHIFT	4
#define TMEM_POOL_PAGESIZE_MASK		0xf
#define TMEM_POOL_RESERVED_BITS		0x00ffff00

/*
 * sentinels have proven very useful for debugging but can be removed
 * or disabled before final merge.
 */
#undef SENTINELS
#ifdef SENTINELS
#define DECL_SENTINEL uint32_t sentinel;
#define SET_SENTINEL(_x, _y) (_x->sentinel = _y##_SENTINEL)
#define INVERT_SENTINEL(_x, _y) (_x->sentinel = ~_y##_SENTINEL)
#define ASSERT_SENTINEL(_x, _y) WARN_ON(_x->sentinel != _y##_SENTINEL)
#define ASSERT_INVERTED_SENTINEL(_x, _y) WARN_ON(_x->sentinel != ~_y##_SENTINEL)
#else
#define DECL_SENTINEL
#define SET_SENTINEL(_x, _y) do { } while (0)
#define INVERT_SENTINEL(_x, _y) do { } while (0)
#define ASSERT_SENTINEL(_x, _y) do { } while (0)
#define ASSERT_INVERTED_SENTINEL(_x, _y) do { } while (0)
#endif

#define ASSERT_SPINLOCK(_l)	lockdep_assert_held(_l)

/*
 * A pool is the highest-level data structure managed by tmem and
 * usually corresponds to a large independent set of pages such as
 * a filesystem.  Each pool has an id, and certain attributes and counters.
 * It also contains a set of hash buckets, each of which contains an rbtree
 * of objects and a lock to manage concurrency within the pool.
 */

#define TMEM_HASH_BUCKET_BITS	8
#define TMEM_HASH_BUCKETS	(1<<TMEM_HASH_BUCKET_BITS)

struct tmem_hashbucket {
	struct rb_root obj_rb_root;
	spinlock_t lock;
};

struct tmem_pool {
	void *client; /* "up" for some clients, avoids table lookup */
	struct list_head pool_list;
	uint32_t pool_id;
	bool persistent;
	bool shared;
	atomic_t obj_count;
	atomic_t refcount;
	struct tmem_hashbucket hashbucket[TMEM_HASH_BUCKETS];
	DECL_SENTINEL
};

#define is_persistent(_p)  (_p->persistent)
#define is_ephemeral(_p)   (!(_p->persistent))

/*
 * An object id ("oid") is large: 192-bits (to ensure, for example, files
 * in a modern filesystem can be uniquely identified).
 */

struct tmem_oid {
	uint64_t oid[3];
};

static inline void tmem_oid_set_invalid(struct tmem_oid *oidp)
{
	oidp->oid[0] = oidp->oid[1] = oidp->oid[2] = -1UL;
}

static inline bool tmem_oid_valid(struct tmem_oid *oidp)
{
	return oidp->oid[0] != -1UL || oidp->oid[1] != -1UL ||
		oidp->oid[2] != -1UL;
}

static inline int tmem_oid_compare(struct tmem_oid *left,
					struct tmem_oid *right)
{
	int ret;

	if (left->oid[2] == right->oid[2]) {
		if (left->oid[1] == right->oid[1]) {
			if (left->oid[0] == right->oid[0])
				ret = 0;
			else if (left->oid[0] < right->oid[0])
				ret = -1;
			else
				return 1;
		} else if (left->oid[1] < right->oid[1])
			ret = -1;
		else
			ret = 1;
	} else if (left->oid[2] < right->oid[2])
		ret = -1;
	else
		ret = 1;
	return ret;
}

static inline unsigned tmem_oid_hash(struct tmem_oid *oidp)
{
	return hash_long(oidp->oid[0] ^ oidp->oid[1] ^ oidp->oid[2],
				TMEM_HASH_BUCKET_BITS);
}

#ifdef CONFIG_RAMSTER
struct tmem_xhandle {
	uint8_t client_id;
	uint8_t xh_data_cksum;
	uint16_t xh_data_size;
	uint16_t pool_id;
	struct tmem_oid oid;
	uint32_t index;
	void *extra;
};

static inline struct tmem_xhandle tmem_xhandle_fill(uint16_t client_id,
					struct tmem_pool *pool,
					struct tmem_oid *oidp,
					uint32_t index)
{
	struct tmem_xhandle xh;
	xh.client_id = client_id;
	xh.xh_data_cksum = (uint8_t)-1;
	xh.xh_data_size = (uint16_t)-1;
	xh.pool_id = pool->pool_id;
	xh.oid = *oidp;
	xh.index = index;
	return xh;
}
#endif


/*
 * A tmem_obj contains an identifier (oid), pointers to the parent
 * pool and the rb_tree to which it belongs, counters, and an ordered
 * set of pampds, structured in a radix-tree-like tree.  The intermediate
 * nodes of the tree are called tmem_objnodes.
 */

struct tmem_objnode;

struct tmem_obj {
	struct tmem_oid oid;
	struct tmem_pool *pool;
	struct rb_node rb_tree_node;
	struct tmem_objnode *objnode_tree_root;
	unsigned int objnode_tree_height;
	unsigned long objnode_count;
	long pampd_count;
#ifdef CONFIG_RAMSTER
	/*
	 * for current design of ramster, all pages belonging to
	 * an object reside on the same remotenode and extra is
	 * used to record the number of the remotenode so a
	 * flush-object operation can specify it
	 */
	void *extra; /* for private use by pampd implementation */
#endif
	DECL_SENTINEL
};

#define OBJNODE_TREE_MAP_SHIFT 6
#define OBJNODE_TREE_MAP_SIZE (1UL << OBJNODE_TREE_MAP_SHIFT)
#define OBJNODE_TREE_MAP_MASK (OBJNODE_TREE_MAP_SIZE-1)
#define OBJNODE_TREE_INDEX_BITS (8 /* CHAR_BIT */ * sizeof(unsigned long))
#define OBJNODE_TREE_MAX_PATH \
		(OBJNODE_TREE_INDEX_BITS/OBJNODE_TREE_MAP_SHIFT + 2)

struct tmem_objnode {
	struct tmem_obj *obj;
	DECL_SENTINEL
	void *slots[OBJNODE_TREE_MAP_SIZE];
	unsigned int slots_in_use;
};

struct tmem_handle {
	struct tmem_oid oid; /* 24 bytes */
	uint32_t index;
	uint16_t pool_id;
	uint16_t client_id;
};


/* pampd abstract datatype methods provided by the PAM implementation */
struct tmem_pamops {
	void (*create_finish)(void *, bool);
	int (*get_data)(char *, size_t *, bool, void *, struct tmem_pool *,
				struct tmem_oid *, uint32_t);
	int (*get_data_and_free)(char *, size_t *, bool, void *,
				struct tmem_pool *, struct tmem_oid *,
				uint32_t);
	void (*free)(void *, struct tmem_pool *,
				struct tmem_oid *, uint32_t, bool);
#ifdef CONFIG_RAMSTER
	void (*new_obj)(struct tmem_obj *);
	void (*free_obj)(struct tmem_pool *, struct tmem_obj *, bool);
	void *(*repatriate_preload)(void *, struct tmem_pool *,
					struct tmem_oid *, uint32_t, bool *);
	int (*repatriate)(void *, void *, struct tmem_pool *,
				struct tmem_oid *, uint32_t, bool, void *);
	bool (*is_remote)(void *);
	int (*replace_in_obj)(void *, struct tmem_obj *);
#endif
};
extern void tmem_register_pamops(struct tmem_pamops *m);

/* memory allocation methods provided by the host implementation */
struct tmem_hostops {
	struct tmem_obj *(*obj_alloc)(struct tmem_pool *);
	void (*obj_free)(struct tmem_obj *, struct tmem_pool *);
	struct tmem_objnode *(*objnode_alloc)(struct tmem_pool *);
	void (*objnode_free)(struct tmem_objnode *, struct tmem_pool *);
};
extern void tmem_register_hostops(struct tmem_hostops *m);

/* core tmem accessor functions */
extern int tmem_put(struct tmem_pool *, struct tmem_oid *, uint32_t index,
			bool, void *);
extern int tmem_get(struct tmem_pool *, struct tmem_oid *, uint32_t index,
			char *, size_t *, bool, int);
extern int tmem_flush_page(struct tmem_pool *, struct tmem_oid *,
			uint32_t index);
extern int tmem_flush_object(struct tmem_pool *, struct tmem_oid *);
extern int tmem_destroy_pool(struct tmem_pool *);
extern void tmem_new_pool(struct tmem_pool *, uint32_t);
#ifdef CONFIG_RAMSTER
extern int tmem_replace(struct tmem_pool *, struct tmem_oid *, uint32_t index,
			void *);
extern void *tmem_localify_get_pampd(struct tmem_pool *, struct tmem_oid *,
				   uint32_t index, struct tmem_obj **,
				   void **);
extern void tmem_localify_finish(struct tmem_obj *, uint32_t index,
				 void *, void *, bool);
#endif
#endif /* _TMEM_H */
Commit	Line	Data
faca2ef7 DM	1	/*
	2	* tmem.h
	3	*
	4	* Transcendent memory
	5	*
	6	* Copyright (c) 2009-2012, Dan Magenheimer, Oracle Corp.
	7	*/
	8
	9	#ifndef _TMEM_H_
	10	#define _TMEM_H_
	11
	12	#include <linux/types.h>
	13	#include <linux/highmem.h>
	14	#include <linux/hash.h>
	15	#include <linux/atomic.h>
	16
	17	/*
	18	* These are defined by the Xen<->Linux ABI so should remain consistent
	19	*/
	20	#define TMEM_POOL_PERSIST 1
	21	#define TMEM_POOL_SHARED 2
	22	#define TMEM_POOL_PRECOMPRESSED 4
	23	#define TMEM_POOL_PAGESIZE_SHIFT 4
	24	#define TMEM_POOL_PAGESIZE_MASK 0xf
	25	#define TMEM_POOL_RESERVED_BITS 0x00ffff00
	26
	27	/*
	28	* sentinels have proven very useful for debugging but can be removed
	29	* or disabled before final merge.
	30	*/
	31	#undef SENTINELS
	32	#ifdef SENTINELS
	33	#define DECL_SENTINEL uint32_t sentinel;
	34	#define SET_SENTINEL(_x, _y) (_x->sentinel = _y##_SENTINEL)
	35	#define INVERT_SENTINEL(_x, _y) (_x->sentinel = ~_y##_SENTINEL)
	36	#define ASSERT_SENTINEL(_x, _y) WARN_ON(_x->sentinel != _y##_SENTINEL)
	37	#define ASSERT_INVERTED_SENTINEL(_x, _y) WARN_ON(_x->sentinel != ~_y##_SENTINEL)
	38	#else
	39	#define DECL_SENTINEL
	40	#define SET_SENTINEL(_x, _y) do { } while (0)
	41	#define INVERT_SENTINEL(_x, _y) do { } while (0)
	42	#define ASSERT_SENTINEL(_x, _y) do { } while (0)
	43	#define ASSERT_INVERTED_SENTINEL(_x, _y) do { } while (0)
	44	#endif
	45
	46	#define ASSERT_SPINLOCK(_l) lockdep_assert_held(_l)
	47
	48	/*
	49	* A pool is the highest-level data structure managed by tmem and
	50	* usually corresponds to a large independent set of pages such as
	51	* a filesystem. Each pool has an id, and certain attributes and counters.
	52	* It also contains a set of hash buckets, each of which contains an rbtree
	53	* of objects and a lock to manage concurrency within the pool.
	54	*/
	55
	56	#define TMEM_HASH_BUCKET_BITS 8
	57	#define TMEM_HASH_BUCKETS (1<<TMEM_HASH_BUCKET_BITS)
	58
	59	struct tmem_hashbucket {
	60	struct rb_root obj_rb_root;
	61	spinlock_t lock;
	62	};
	63
	64	struct tmem_pool {
65	void client; / "up" for some clients, avoids table lookup */
66	struct list_head pool_list;
67	uint32_t pool_id;
68	bool persistent;
69	bool shared;
70	atomic_t obj_count;
71	atomic_t refcount;
72	struct tmem_hashbucket hashbucket[TMEM_HASH_BUCKETS];
73	DECL_SENTINEL
74	};
75
76	#define is_persistent(_p) (_p->persistent)
77	#define is_ephemeral(_p) (!(_p->persistent))
78
79	/*
80	* An object id ("oid") is large: 192-bits (to ensure, for example, files
81	* in a modern filesystem can be uniquely identified).
82	*/
83
84	struct tmem_oid {
85	uint64_t oid[3];
86	};
87
88	static inline void tmem_oid_set_invalid(struct tmem_oid *oidp)
89	{
90	oidp->oid[0] = oidp->oid[1] = oidp->oid[2] = -1UL;
91	}
92
93	static inline bool tmem_oid_valid(struct tmem_oid *oidp)
94	{
95	return oidp->oid[0] != -1UL \|\| oidp->oid[1] != -1UL \|\|
96	oidp->oid[2] != -1UL;
97	}
98
99	static inline int tmem_oid_compare(struct tmem_oid *left,
100	struct tmem_oid *right)
101	{
102	int ret;
103
104	if (left->oid[2] == right->oid[2]) {
105	if (left->oid[1] == right->oid[1]) {
106	if (left->oid[0] == right->oid[0])
107	ret = 0;
108	else if (left->oid[0] < right->oid[0])
109	ret = -1;
110	else
111	return 1;
112	} else if (left->oid[1] < right->oid[1])
113	ret = -1;
114	else
115	ret = 1;
116	} else if (left->oid[2] < right->oid[2])
117	ret = -1;
118	else
119	ret = 1;
120	return ret;
121	}
122
123	static inline unsigned tmem_oid_hash(struct tmem_oid *oidp)
124	{
125	return hash_long(oidp->oid[0] ^ oidp->oid[1] ^ oidp->oid[2],
126	TMEM_HASH_BUCKET_BITS);
127	}
128
129	#ifdef CONFIG_RAMSTER
130	struct tmem_xhandle {
131	uint8_t client_id;
132	uint8_t xh_data_cksum;
133	uint16_t xh_data_size;
134	uint16_t pool_id;
135	struct tmem_oid oid;
136	uint32_t index;
137	void *extra;
138	};
139
140	static inline struct tmem_xhandle tmem_xhandle_fill(uint16_t client_id,
141	struct tmem_pool *pool,
142	struct tmem_oid *oidp,
143	uint32_t index)
144	{
145	struct tmem_xhandle xh;
146	xh.client_id = client_id;
147	xh.xh_data_cksum = (uint8_t)-1;
148	xh.xh_data_size = (uint16_t)-1;
149	xh.pool_id = pool->pool_id;
150	xh.oid = *oidp;
151	xh.index = index;
152	return xh;
153	}
154	#endif
155
156
157	/*
158	* A tmem_obj contains an identifier (oid), pointers to the parent
159	* pool and the rb_tree to which it belongs, counters, and an ordered
160	* set of pampds, structured in a radix-tree-like tree. The intermediate
161	* nodes of the tree are called tmem_objnodes.
162	*/
163
164	struct tmem_objnode;
165
166	struct tmem_obj {
167	struct tmem_oid oid;
168	struct tmem_pool *pool;
169	struct rb_node rb_tree_node;
170	struct tmem_objnode *objnode_tree_root;
171	unsigned int objnode_tree_height;
172	unsigned long objnode_count;
173	long pampd_count;
174	#ifdef CONFIG_RAMSTER
175	/*
176	* for current design of ramster, all pages belonging to
177	* an object reside on the same remotenode and extra is
178	* used to record the number of the remotenode so a
179	* flush-object operation can specify it
180	*/
181	void extra; / for private use by pampd implementation */
182	#endif
183	DECL_SENTINEL
184	};
185
186	#define OBJNODE_TREE_MAP_SHIFT 6
187	#define OBJNODE_TREE_MAP_SIZE (1UL << OBJNODE_TREE_MAP_SHIFT)
188	#define OBJNODE_TREE_MAP_MASK (OBJNODE_TREE_MAP_SIZE-1)
189	#define OBJNODE_TREE_INDEX_BITS (8 /* CHAR_BIT / sizeof(unsigned long))
190	#define OBJNODE_TREE_MAX_PATH \
191	(OBJNODE_TREE_INDEX_BITS/OBJNODE_TREE_MAP_SHIFT + 2)
192
193	struct tmem_objnode {
194	struct tmem_obj *obj;
195	DECL_SENTINEL
196	void *slots[OBJNODE_TREE_MAP_SIZE];
197	unsigned int slots_in_use;
198	};
199
200	struct tmem_handle {
201	struct tmem_oid oid; /* 24 bytes */
202	uint32_t index;
203	uint16_t pool_id;
204	uint16_t client_id;
205	};
206
207
208	/* pampd abstract datatype methods provided by the PAM implementation */
209	struct tmem_pamops {
210	void (create_finish)(void , bool);
211	int (get_data)(char , size_t , bool, void , struct tmem_pool *,
212	struct tmem_oid *, uint32_t);
213	int (get_data_and_free)(char , size_t , bool, void ,
214	struct tmem_pool , struct tmem_oid ,
215	uint32_t);
216	void (free)(void , struct tmem_pool *,
217	struct tmem_oid *, uint32_t, bool);
218	#ifdef CONFIG_RAMSTER
219	void (new_obj)(struct tmem_obj );
220	void (free_obj)(struct tmem_pool , struct tmem_obj *, bool);
221	void (repatriate_preload)(void , struct tmem_pool ,
222	struct tmem_oid , uint32_t, bool );
223	int (repatriate)(void , void , struct tmem_pool ,
224	struct tmem_oid , uint32_t, bool, void );
225	bool (is_remote)(void );
226	int (replace_in_obj)(void , struct tmem_obj *);
227	#endif
228	};
229	extern void tmem_register_pamops(struct tmem_pamops *m);
230
231	/* memory allocation methods provided by the host implementation */
232	struct tmem_hostops {
233	struct tmem_obj (obj_alloc)(struct tmem_pool *);
234	void (obj_free)(struct tmem_obj , struct tmem_pool *);
235	struct tmem_objnode (objnode_alloc)(struct tmem_pool *);
236	void (objnode_free)(struct tmem_objnode , struct tmem_pool *);
237	};
238	extern void tmem_register_hostops(struct tmem_hostops *m);
239
240	/* core tmem accessor functions */
241	extern int tmem_put(struct tmem_pool , struct tmem_oid , uint32_t index,
242	bool, void *);
243	extern int tmem_get(struct tmem_pool , struct tmem_oid , uint32_t index,
244	char , size_t , bool, int);
245	extern int tmem_flush_page(struct tmem_pool , struct tmem_oid ,
246	uint32_t index);
247	extern int tmem_flush_object(struct tmem_pool , struct tmem_oid );
248	extern int tmem_destroy_pool(struct tmem_pool *);
249	extern void tmem_new_pool(struct tmem_pool *, uint32_t);
250	#ifdef CONFIG_RAMSTER
251	extern int tmem_replace(struct tmem_pool , struct tmem_oid , uint32_t index,
252	void *);
253	extern void tmem_localify_get_pampd(struct tmem_pool , struct tmem_oid *,
254	uint32_t index, struct tmem_obj **,
255	void **);
256	extern void tmem_localify_finish(struct tmem_obj *, uint32_t index,
257	void , void , bool);
258	#endif
259	#endif /* _TMEM_H */