X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=libcfs%2Finclude%2Flibcfs%2Fposix%2Flibcfs.h;h=403861ce6a12863260253ab45c24f2524a48354f;hp=61054e7994cc7bb777b90bc4ed84f63098683d15;hb=c4a6999ceec8ac95415de4cb6099182d3f67d1cb;hpb=6869932b552ac705f411de3362f01bd50c1f6f7d diff --git a/libcfs/include/libcfs/posix/libcfs.h b/libcfs/include/libcfs/posix/libcfs.h index 61054e7..403861c 100644 --- a/libcfs/include/libcfs/posix/libcfs.h +++ b/libcfs/include/libcfs/posix/libcfs.h @@ -1,6 +1,4 @@ -/* -*- 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. @@ -26,8 +24,10 @@ * 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/ @@ -43,21 +43,39 @@ #ifndef __LIBCFS_POSIX_LIBCFS_H__ #define __LIBCFS_POSIX_LIBCFS_H__ +#include #include #include #include +#include #include #include #include #include -#include #include #include #include +#include #include #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_NETDB_H +#include +#endif + +#ifdef HAVE_UNISTD_H +#include +#endif #ifdef HAVE_LIBPTHREAD #include @@ -80,122 +98,31 @@ #endif #include -#include #include #include #include #include #include -#include #include -# 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))) +#define do_gettimeofday(tv) gettimeofday(tv, NULL); +typedef unsigned long long cfs_cycles_t; /* this goes in posix-fs.h */ #include -#ifdef __linux__ #include -#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 */ -# include -# include -# define __swab16(x) bswap_16(x) -# define __swab32(x) bswap_32(x) -# define __swab64(x) bswap_64(x) -# define __swab16s(x) do {*(x) = bswap_16(*(x));} while (0) -# define __swab32s(x) do {*(x) = bswap_32(*(x));} while (0) -# define __swab64s(x) do {*(x) = bswap_64(*(x));} while (0) -# if __BYTE_ORDER == __LITTLE_ENDIAN -# define le16_to_cpu(x) (x) -# define cpu_to_le16(x) (x) -# define le32_to_cpu(x) (x) -# define cpu_to_le32(x) (x) -# define le64_to_cpu(x) (x) -# define cpu_to_le64(x) (x) - -# define be16_to_cpu(x) bswap_16(x) -# 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) -# 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 be16_to_cpu(x) (x) -# define cpu_to_be16(x) (x) -# define be32_to_cpu(x) (x) -# define cpu_to_be32(x) (x) -# define be64_to_cpu(x) (x) -# define cpu_to_be64(x) (x) - -# else -# error "Unknown byte order" -# endif /* __BIG_ENDIAN */ -# endif /* __LITTLE_ENDIAN */ -#elif __APPLE__ -#define __cpu_to_le64(x) OSSwapHostToLittleInt64(x) -#define __cpu_to_le32(x) OSSwapHostToLittleInt32(x) -#define __cpu_to_le16(x) OSSwapHostToLittleInt16(x) - -#define __le16_to_cpu(x) OSSwapLittleToHostInt16(x) -#define __le32_to_cpu(x) OSSwapLittleToHostInt32(x) -#define __le64_to_cpu(x) OSSwapLittleToHostInt64(x) - -#define cpu_to_le64(x) __cpu_to_le64(x) -#define cpu_to_le32(x) __cpu_to_le32(x) -#define cpu_to_le16(x) __cpu_to_le16(x) - -#define le64_to_cpu(x) __le64_to_cpu(x) -#define le32_to_cpu(x) __le32_to_cpu(x) -#define le16_to_cpu(x) __le16_to_cpu(x) - -#define __swab16(x) OSSwapInt16(x) -#define __swab32(x) OSSwapInt32(x) -#define __swab64(x) OSSwapInt64(x) -#define __swab16s(x) do { *(x) = __swab16(*(x)); } while (0) -#define __swab32s(x) do { *(x) = __swab32(*(x)); } while (0) -#define __swab64s(x) do { *(x) = __swab64(*(x)); } while (0) -#endif +#ifndef THREAD_SIZE /* x86_64 linux has THREAD_SIZE in userspace */ +# define THREAD_SIZE 8192 +#endif /* THREAD_SIZE */ - -# ifndef THREAD_SIZE /* x86_64 linux has THREAD_SIZE in userspace */ -# define THREAD_SIZE 8192 -# 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 LUSTRE_LNET_PID 12345 - -#define ENTRY_NESTING_SUPPORT (1) -#define ENTRY_NESTING do {;} while (0) -#define EXIT_NESTING do {;} while (0) -#define __current_nesting_level() (0) - /** * Platform specific declarations for cfs_curproc API (libcfs/curproc.h) * @@ -203,13 +130,14 @@ typedef struct dirent64 cfs_dirent_t; */ #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?) */ struct module { int count; + char *name; }; static inline void MODULE_AUTHOR(char *name) @@ -219,13 +147,13 @@ static inline void MODULE_AUTHOR(char *name) #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) @@ -234,7 +162,7 @@ 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) @@ -242,4 +170,247 @@ static inline void module_put(struct module *module) } +static inline int module_refcount(struct module *m) +{ + return 1; +} + +/*************************************************************************** + * + * Linux kernel slab shrinker emulation. Currently used only in lu_object.c + * + ***************************************************************************/ + +struct shrinker { +#ifndef __INTEL_COMPILER + ; +#endif +}; + +struct shrinker_var { +#ifndef __INTEL_COMPILER + ; +#endif +}; + +#define DEF_SHRINKER_VAR(name, shrink, count, scan) \ + struct shrinker_var name = {}; + +#define DEFAULT_SEEKS (0) + +static inline +struct shrinker *set_shrinker(int seeks, struct shrinker_var *var) +{ + 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 { + struct list_head list; + void *rnode; +}; + +struct radix_tree_node { + struct list_head _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 { \ + 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; + + 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 struct radix_tree_node * +radix_tree_lookup0(struct radix_tree_root *root, unsigned long idx) +{ + struct radix_tree_node *node; + + if (list_empty(&root->list)) + return NULL; + + list_for_each_entry(node, &root->list, _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; + + list_del_init(&p->_node); + item = p->item; + free(p); + if (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 + +#ifndef ERESTARTSYS +#define ERESTARTSYS ERESTART +#endif + #endif