-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
+ *
+ * Copyright (c) 2012, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#ifndef __LIBCFS_POSIX_LIBCFS_H__
#define __LIBCFS_POSIX_LIBCFS_H__
+#include <errno.h>
#include <sys/errno.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
-#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <assert.h>
+#include <sys/ioctl.h>
#include <sys/signal.h>
#include <signal.h>
#include <sys/time.h>
#include <time.h>
+#include <getopt.h>
+#include <signal.h>
+#include <pwd.h>
+#include <sys/socket.h>
+#include <sys/utsname.h>
+#include <ctype.h>
+#include <stdbool.h>
+
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
#ifdef HAVE_LIBPTHREAD
#include <pthread.h>
#include <libcfs/user-bitops.h>
# define do_gettimeofday(tv) gettimeofday(tv, NULL);
-typedef unsigned long long cycles_t;
-
-#define IS_ERR(a) ((unsigned long)(a) > (unsigned long)-1000L)
-#define PTR_ERR(a) ((long)(a))
-#define ERR_PTR(a) ((void*)((long)(a)))
+typedef unsigned long long cfs_cycles_t;
/* this goes in posix-fs.h */
#include <sys/mount.h>
#include <mntent.h>
#endif
-typedef struct file cfs_file_t;
-typedef struct dentry cfs_dentry_t;
-#ifdef __linux__
-typedef struct dirent64 cfs_dirent_t;
-#endif
+#define fget(x) NULL
+#define fput(f) do {} while (0)
#ifdef __linux__
/* Userpace byte flipping */
# define cpu_to_be16(x) bswap_16(x)
# define be32_to_cpu(x) bswap_32(x)
# define cpu_to_be32(x) bswap_32(x)
-# define be64_to_cpu(x) bswap_64(x)
-# define cpu_to_be64(x) bswap_64(x)
+# define be64_to_cpu(x) (__u64)bswap_64(x)
+# define cpu_to_be64(x) (__u64)bswap_64(x)
# else
# if __BYTE_ORDER == __BIG_ENDIAN
# define le16_to_cpu(x) bswap_16(x)
# define cpu_to_le16(x) bswap_16(x)
# define le32_to_cpu(x) bswap_32(x)
# define cpu_to_le32(x) bswap_32(x)
-# define le64_to_cpu(x) bswap_64(x)
-# define cpu_to_le64(x) bswap_64(x)
+# define le64_to_cpu(x) (__u64)bswap_64(x)
+# define cpu_to_le64(x) (__u64)bswap_64(x)
# define be16_to_cpu(x) (x)
# define cpu_to_be16(x) (x)
#define __swab64s(x) do { *(x) = __swab64(*(x)); } while (0)
#endif
+#if !defined(ALIGN)
+#define __ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
+#define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a) - 1)
+#endif
# ifndef THREAD_SIZE /* x86_64 linux has THREAD_SIZE in userspace */
# define THREAD_SIZE 8192
+# else
# endif
-#define LUSTRE_TRACE_SIZE (THREAD_SIZE >> 5)
-
-#define CHECK_STACK() do { } while(0)
+#define CFS_CHECK_STACK(msgdata, mask, cdls) do {} while(0)
#define CDEBUG_STACK() (0L)
/* initial pid */
*/
#define CFS_CURPROC_COMM_MAX (sizeof ((struct task_struct *)0)->comm)
-typedef __u32 cfs_kernel_cap_t;
+typedef __u32 kernel_cap_t;
/**
* Module support (probably shouldn't be used in generic code?)
#define MODULE_DESCRIPTION(name) MODULE_AUTHOR(name)
#define MODULE_LICENSE(name) MODULE_AUTHOR(name)
-#define THIS_MODULE NULL
+#define THIS_MODULE (void *)0x11111
#define __init
#define __exit
-static inline int request_module(char *name)
+static inline int request_module(const char *name, ...)
{
- return (-EINVAL);
+ return (-EINVAL);
}
static inline void __module_get(struct module *module)
static inline int try_module_get(struct module *module)
{
- return 1;
+ return 1;
}
static inline void module_put(struct module *module)
static inline int module_refcount(struct module *m)
{
- return 1;
+ return 1;
}
/***************************************************************************
***************************************************************************/
struct shrinker {
- ;
+#ifndef __INTEL_COMPILER
+ ;
+#endif
};
#define DEFAULT_SEEKS (0)
typedef int (*shrinker_t)(int, unsigned int);
-static inline struct shrinker *set_shrinker(int seeks, shrinker_t shrinkert)
+static inline
+struct shrinker *set_shrinker(int seeks, shrinker_t shrink)
{
- return NULL;
+ return (struct shrinker *)0xdeadbea1; /* Cannot return NULL here */
}
static inline void remove_shrinker(struct shrinker *shrinker)
***************************************************************************/
struct radix_tree_root {
- struct list_head *rnode;
+ struct list_head list;
+ void *rnode;
+};
+
+struct radix_tree_node {
+ struct list_head _node;
+ unsigned long index;
+ void *item;
};
-#define RADIX_TREE_INIT(mask) { \
- .rnode = NULL, \
+#define RADIX_TREE_INIT(mask) { \
+ NOT_IMPLEMENTED \
}
#define RADIX_TREE(name, mask) \
- struct radix_tree_root name = RADIX_TREE_INIT(mask)
+ struct radix_tree_root name = RADIX_TREE_INIT(mask)
+
-#define INIT_RADIX_TREE(root, mask) \
-do { \
- (root)->rnode = NULL; \
+#define INIT_RADIX_TREE(root, mask) \
+do { \
+ 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, struct page *page)
+ unsigned long idx, void *item)
{
- if (root->rnode == NULL)
- root->rnode = &page->_node;
- else
- list_add_tail(&page->_node, root->rnode);
- return 0;
+ struct radix_tree_node *node;
+ node = malloc(sizeof(*node));
+ if (!node)
+ return -ENOMEM;
+
+ INIT_LIST_HEAD(&node->_node);
+ node->index = idx;
+ node->item = item;
+ list_add_tail(&node->_node, &root->list);
+ root->rnode = (void *)1001;
+ return 0;
}
-static inline void *radix_tree_lookup(struct radix_tree_root *root,
- unsigned long idx)
+static inline struct radix_tree_node *
+radix_tree_lookup0(struct radix_tree_root *root, unsigned long idx)
{
- struct page *p;
+ struct radix_tree_node *node;
- if (root->rnode == NULL)
- return NULL;
+ if (list_empty(&root->list))
+ return NULL;
- p = list_entry(root->rnode, struct page, _node);
- if (p->index == idx)
- return p;
+ list_for_each_entry(node, &root->list, _node)
+ if (node->index == idx)
+ return node;
- list_for_each_entry(p, root->rnode, _node)
- if (p->index == idx)
- return p;
+ return NULL;
+}
- 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)
+ unsigned long idx)
{
- struct page *p = radix_tree_lookup(root, idx);
-
- if (p == NULL)
- return NULL;
- if (list_empty(root->rnode))
- root->rnode = NULL;
- else if (root->rnode == &p->_node)
- root->rnode = p->_node.next;
- list_del_init(&p->_node);
- return p;
+ struct radix_tree_node *p = radix_tree_lookup0(root, idx);
+ void *item;
+
+ if (p == NULL)
+ return NULL;
+
+ list_del_init(&p->_node);
+ item = p->item;
+ free(p);
+ if (list_empty(&root->list))
+ root->rnode = NULL;
+
+ return item;
}
static inline unsigned int
{
}
+/***************************************************************************
+ *
+ * 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
+
#endif