+static inline int module_refcount(struct module *m)
+{
+ return 1;
+}
+
+/***************************************************************************
+ *
+ * Linux kernel slab shrinker emulation. Currently used only in lu_object.c
+ *
+ ***************************************************************************/
+
+struct shrinker {
+ ;
+};
+
+#define DEFAULT_SEEKS (0)
+
+typedef int (*shrinker_t)(int, unsigned int);
+
+static inline
+struct shrinker *set_shrinker(int seeks, shrinker_t shrink)
+{
+ return (struct shrinker *)0xdeadbea1; /* Cannot return NULL here */
+}
+
+static inline void remove_shrinker(struct shrinker *shrinker)
+{
+}
+
+/***************************************************************************
+ *
+ * Linux kernel radix tree emulation.
+ *
+ * XXX this stub-implementation assumes that elements stored in a radix tree
+ * are struct page's and nothing else. Proper implementation will be
+ * committed soon.
+ *
+ ***************************************************************************/
+
+struct radix_tree_root {
+ cfs_list_t list;
+ void *rnode;
+};
+
+struct radix_tree_node {
+ cfs_list_t _node;
+ unsigned long index;
+ void *item;
+};
+
+#define RADIX_TREE_INIT(mask) { \
+ NOT_IMPLEMENTED \
+}
+
+#define RADIX_TREE(name, mask) \
+ struct radix_tree_root name = RADIX_TREE_INIT(mask)
+
+
+#define INIT_RADIX_TREE(root, mask) \
+do { \
+ CFS_INIT_LIST_HEAD(&((struct radix_tree_root *)root)->list); \
+ ((struct radix_tree_root *)root)->rnode = NULL; \
+} while (0)
+
+static inline int radix_tree_insert(struct radix_tree_root *root,
+ unsigned long idx, void *item)
+{
+ struct radix_tree_node *node;
+ node = malloc(sizeof(*node));
+ if (!node)
+ return -ENOMEM;
+
+ CFS_INIT_LIST_HEAD(&node->_node);
+ node->index = idx;
+ node->item = item;
+ cfs_list_add_tail(&node->_node, &root->list);
+ root->rnode = (void *)1001;
+ return 0;
+}
+
+static inline struct radix_tree_node *radix_tree_lookup0(struct radix_tree_root *root,
+ unsigned long idx)
+{
+ struct radix_tree_node *node;
+
+ if (cfs_list_empty(&root->list))
+ return NULL;
+
+ cfs_list_for_each_entry_typed(node, &root->list,
+ struct radix_tree_node, _node)
+ if (node->index == idx)
+ return node;
+
+ return NULL;
+}
+
+static inline void *radix_tree_lookup(struct radix_tree_root *root,
+ unsigned long idx)
+{
+ struct radix_tree_node *node = radix_tree_lookup0(root, idx);
+
+ if (node)
+ return node->item;
+ return node;
+}
+
+static inline void *radix_tree_delete(struct radix_tree_root *root,
+ unsigned long idx)
+{
+ struct radix_tree_node *p = radix_tree_lookup0(root, idx);
+ void *item;
+
+ if (p == NULL)
+ return NULL;
+
+ cfs_list_del_init(&p->_node);
+ item = p->item;
+ free(p);
+ if (cfs_list_empty(&root->list))
+ root->rnode = NULL;
+
+ return item;
+}
+
+static inline unsigned int
+radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
+ unsigned long first_index, unsigned int max_items)
+{
+ int i;
+ int j = 0;
+
+ for (i = 0; i < max_items; i++, first_index++) {
+ results[j++] = radix_tree_lookup(root, first_index);
+ if (results[j - 1] == NULL)
+ --j;
+ }
+
+ return j;
+}
+
+static inline int radix_tree_preload(int gfp_mask)
+{
+ return 0;
+}
+
+void radix_tree_init(void);
+
+static inline void radix_tree_preload_end(void)
+{
+}
+
+/***************************************************************************
+ *
+ * Linux kernel red black tree emulation.
+ *
+ ***************************************************************************/
+struct rb_node {
+ unsigned long rb_parent_color;
+#define RB_RED 0
+#define RB_BLACK 1
+ struct rb_node *rb_right;
+ struct rb_node *rb_left;
+};
+
+struct rb_root {
+ struct rb_node *rb_node;
+};
+
+
+#define rb_parent(r) ((struct rb_node *)((r)->rb_parent_color & ~3))
+#define rb_color(r) ((r)->rb_parent_color & 1)
+#define rb_is_red(r) (!rb_color(r))
+#define rb_is_black(r) rb_color(r)
+#define rb_set_red(r) do { (r)->rb_parent_color &= ~1; } while (0)
+#define rb_set_black(r) do { (r)->rb_parent_color |= 1; } while (0)
+
+static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
+{
+ rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
+}
+static inline void rb_set_color(struct rb_node *rb, int color)
+{
+ rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
+}
+
+#define RB_ROOT ((struct rb_root) { NULL, })
+#define rb_entry(ptr, type, member) container_of(ptr, type, member)
+
+#define RB_EMPTY_ROOT(root) ((root)->rb_node == NULL)
+#define RB_EMPTY_NODE(node) (rb_parent(node) == node)
+#define RB_CLEAR_NODE(node) (rb_set_parent(node, node))
+
+static inline void rb_init_node(struct rb_node *rb)
+{
+ rb->rb_parent_color = 0;
+ rb->rb_right = NULL;
+ rb->rb_left = NULL;
+ RB_CLEAR_NODE(rb);
+}
+
+extern void rb_insert_color(struct rb_node *, struct rb_root *);
+extern void rb_erase(struct rb_node *, struct rb_root *);
+
+/* Find logical next and previous nodes in a tree */
+extern struct rb_node *rb_next(const struct rb_node *);
+extern struct rb_node *rb_prev(const struct rb_node *);
+extern struct rb_node *rb_first(const struct rb_root *);
+extern struct rb_node *rb_last(const struct rb_root *);
+static inline void rb_link_node(struct rb_node *node, struct rb_node *parent,
+ struct rb_node **rb_link)
+{
+ node->rb_parent_color = (unsigned long)parent;
+ node->rb_left = node->rb_right = NULL;
+
+ *rb_link = node;
+}
+
+/***************************************************************************
+ *
+ * End of Linux kernel red black tree emulation.
+ *
+ ***************************************************************************/
+
+typedef ssize_t (*read_actor_t)();
+
+# ifndef IFTODT
+# define IFSHIFT 12
+# define IFTODT(type) (((type) & S_IFMT) >> IFSHIFT)
+# define DTTOIF(dirtype) ((dirtype) << IFSHIFT)
+# endif
+