X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Fliblustre.h;h=79ffd505c18ecf45fa9dc130b5e6f44947701510;hb=14765d2816bafa2a08879ece0e33bf8c97f84948;hp=e801dc6972b9d1b6fb6dc9f334b2c66b139d0613;hpb=b3d03f05e7c59e1933bfe6e177a1a5683b928096;p=fs%2Flustre-release.git diff --git a/lustre/include/liblustre.h b/lustre/include/liblustre.h index e801dc6..79ffd50 100644 --- a/lustre/include/liblustre.h +++ b/lustre/include/liblustre.h @@ -34,6 +34,10 @@ #define __LINUX_SPINLOCK_H #endif +#include +#include +#include + #include #ifdef HAVE_STDINT_H # include @@ -47,9 +51,6 @@ #ifdef HAVE_SYS_IOCTL_H # include #endif -#ifndef _IOWR -# include "ioctl.h" -#endif #include #include @@ -62,26 +63,30 @@ #endif #include #include +#include +#include #include #include -#include +#include + +#ifndef _IOWR +# include "ioctl.h" +#endif /* definitions for liblustre */ #ifdef __CYGWIN__ -#define CFS_PAGE_SHIFT 12 -#define CFS_PAGE_SIZE (1UL << CFS_PAGE_SHIFT) -#define CFS_PAGE_MASK (~((__u64)CFS_PAGE_SIZE-1)) #define loff_t long long #define ERESTART 2001 typedef unsigned short umode_t; #endif -#ifndef CURRENT_SECONDS -# define CURRENT_SECONDS time(0) + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(a) ((sizeof (a))/(sizeof ((a)[0]))) #endif /* This is because lprocfs_status.h gets included here indirectly. It would @@ -91,13 +96,16 @@ typedef unsigned short umode_t; #ifndef smp_processor_id #define smp_processor_id() 0 #endif -#ifndef smp_num_cpus -#define smp_num_cpus 1 +#ifndef num_online_cpus +#define num_online_cpus() 1 +#endif +#ifndef num_possible_cpus +#define num_possible_cpus() 1 #endif /* always adopt 2.5 definitions */ #define KERNEL_VERSION(a,b,c) ((a)*100+(b)*10+c) -#define LINUX_VERSION_CODE KERNEL_VERSION(2,5,0) +#define LINUX_VERSION_CODE KERNEL_VERSION(2,6,5) #ifndef page_private #define page_private(page) ((page)->private) @@ -145,14 +153,10 @@ static inline void *kmalloc(int size, int prot) #define GFP_HIGHUSER 1 #define GFP_ATOMIC 1 #define GFP_NOFS 1 -#define IS_ERR(a) ((unsigned long)(a) < 1000) +#define IS_ERR(a) ((unsigned long)(a) > (unsigned long)-1000L) #define PTR_ERR(a) ((long)(a)) #define ERR_PTR(a) ((void*)((long)(a))) -typedef struct { - void *cwd; -}mm_segment_t; - typedef int (read_proc_t)(char *page, char **start, off_t off, int count, int *eof, void *data); @@ -160,72 +164,25 @@ struct file; /* forward ref */ typedef int (write_proc_t)(struct file *file, const char *buffer, unsigned long count, void *data); -#define NIPQUAD(addr) \ - ((unsigned char *)&addr)[0], \ - ((unsigned char *)&addr)[1], \ - ((unsigned char *)&addr)[2], \ - ((unsigned char *)&addr)[3] - -#if defined(__LITTLE_ENDIAN) -#define HIPQUAD(addr) \ - ((unsigned char *)&addr)[3], \ - ((unsigned char *)&addr)[2], \ - ((unsigned char *)&addr)[1], \ - ((unsigned char *)&addr)[0] -#elif defined(__BIG_ENDIAN) -#define HIPQUAD NIPQUAD -#else -#error "Undefined byteorder??" -#endif /* __LITTLE_ENDIAN */ - /* bits ops */ /* a long can be more than 32 bits, so use BITS_PER_LONG * to allow the compiler to adjust the bit shifting accordingly */ -/* test if bit nr is set in bitmap addr; returns previous value of bit nr */ -static __inline__ int set_bit(int nr, long * addr) -{ - long mask; - - addr += nr / BITS_PER_LONG; - mask = 1UL << (nr & (BITS_PER_LONG - 1)); - nr = (mask & *addr) != 0; - *addr |= mask; - return nr; -} - -/* clear bit nr in bitmap addr; returns previous value of bit nr*/ -static __inline__ int clear_bit(int nr, long * addr) -{ - long mask; - - addr += nr / BITS_PER_LONG; - mask = 1UL << (nr & (BITS_PER_LONG - 1)); - nr = (mask & *addr) != 0; - *addr &= ~mask; - return nr; -} - -static __inline__ int test_bit(int nr, long * addr) -{ - return ((1UL << (nr & (BITS_PER_LONG - 1))) & ((addr)[nr / BITS_PER_LONG])) != 0; -} - static __inline__ int ext2_set_bit(int nr, void *addr) { - return set_bit(nr, (long*)addr); + return set_bit(nr, addr); } static __inline__ int ext2_clear_bit(int nr, void *addr) { - return clear_bit(nr, (long*)addr); + return clear_bit(nr, addr); } static __inline__ int ext2_test_bit(int nr, void *addr) { - return test_bit(nr, (long*)addr); + return test_bit(nr, addr); } /* modules */ @@ -286,6 +243,7 @@ extern int ldlm_init(void); extern int osc_init(void); extern int lov_init(void); extern int mdc_init(void); +extern int lmv_init(void); extern int mgc_init(void); extern int echo_client_init(void); @@ -295,6 +253,8 @@ extern int echo_client_init(void); #define EXPORT_SYMBOL(S) +struct rcu_head { }; + typedef struct { } spinlock_t; typedef __u64 kdev_t; @@ -314,6 +274,14 @@ static inline void spin_unlock_bh(spinlock_t *l) {} static inline void spin_lock_irqsave(spinlock_t *a, unsigned long b) {} static inline void spin_unlock_irqrestore(spinlock_t *a, unsigned long b) {} +typedef spinlock_t rwlock_t; +#define RW_LOCK_UNLOCKED SPIN_LOCK_UNLOCKED +#define read_lock(l) spin_lock(l) +#define read_unlock(l) spin_unlock(l) +#define write_lock(l) spin_lock(l) +#define write_unlock(l) spin_unlock(l) +#define rwlock_init(l) spin_lock_init(l) + #define min(x,y) ((x)<(y) ? (x) : (y)) #define max(x,y) ((x)>(y) ? (x) : (y)) @@ -411,8 +379,10 @@ static inline cfs_page_t *alloc_pages(int mask, unsigned long order) } return pg; } +#define cfs_alloc_pages(mask, order) alloc_pages((mask), (order)) -#define alloc_page(mask) alloc_pages((mask), 0) +#define alloc_page(mask) alloc_pages((mask), 0) +#define cfs_alloc_page(mask) alloc_page(mask) static inline void __free_pages(cfs_page_t *pg, int what) { @@ -423,9 +393,11 @@ static inline void __free_pages(cfs_page_t *pg, int what) #endif free(pg); } +#define __cfs_free_pages(pg, order) __free_pages((pg), (order)) #define __free_page(page) __free_pages((page), 0) #define free_page(page) __free_page(page) +#define __cfs_free_page(page) __cfs_free_pages((page), 0) static inline cfs_page_t* __grab_cache_page(unsigned long index) { @@ -463,6 +435,9 @@ static inline cfs_page_t* __grab_cache_page(unsigned long index) #define ATTR_RAW 0x0800 /* file system, not vfs will massage attrs */ #define ATTR_FROM_OPEN 0x1000 /* called from open path, ie O_TRUNC */ #define ATTR_CTIME_SET 0x2000 +#define ATTR_BLOCKS 0x4000 +#define ATTR_KILL_SUID 0 +#define ATTR_KILL_SGID 0 struct iattr { unsigned int ia_valid; @@ -475,7 +450,8 @@ struct iattr { time_t ia_ctime; unsigned int ia_attr_flags; }; -#define ll_iattr_struct iattr + +#define ll_iattr iattr #define IT_OPEN 0x0001 #define IT_CREAT 0x0002 @@ -519,7 +495,6 @@ static inline void intent_init(struct lookup_intent *it, int op, int flags) it->it_flags = flags; } - struct dentry { int d_count; }; @@ -579,6 +554,8 @@ struct task_struct { int state; struct signal pending; char comm[32]; + int uid; + int gid; int pid; int fsuid; int fsgid; @@ -612,9 +589,9 @@ static inline int capable(int cap) #define DECLARE_WAIT_QUEUE_HEAD(HEAD) \ wait_queue_head_t HEAD = { \ - .sleepers = LIST_HEAD_INIT(HEAD.sleepers) \ + .sleepers = CFS_LIST_HEAD_INIT(HEAD.sleepers) \ } -#define init_waitqueue_head(l) INIT_LIST_HEAD(&(l)->sleepers) +#define init_waitqueue_head(l) CFS_INIT_LIST_HEAD(&(l)->sleepers) #define wake_up(l) do { int a; a++; } while (0) #define TASK_INTERRUPTIBLE 0 #define TASK_UNINTERRUPTIBLE 1 @@ -685,7 +662,7 @@ static inline int timer_pending(struct timer_list *l) static inline int init_timer(struct timer_list *l) { - INIT_LIST_HEAD(&l->tl_list); + CFS_INIT_LIST_HEAD(&l->tl_list); return 0; } @@ -701,6 +678,8 @@ static inline void del_timer(struct timer_list *l) typedef struct { volatile int counter; } atomic_t; +#define ATOMIC_INIT(i) { (i) } + #define atomic_read(a) ((a)->counter) #define atomic_set(a,b) do {(a)->counter = b; } while (0) #define atomic_dec_and_test(a) ((--((a)->counter)) == 0) @@ -708,7 +687,11 @@ typedef struct { volatile int counter; } atomic_t; #define atomic_inc(a) (((a)->counter)++) #define atomic_dec(a) do { (a)->counter--; } while (0) #define atomic_add(b,a) do {(a)->counter += b;} while (0) +#define atomic_add_return(n,a) ((a)->counter += n) +#define atomic_inc_return(a) atomic_add_return(1,a) #define atomic_sub(b,a) do {(a)->counter -= b;} while (0) +#define atomic_sub_return(n,a) ((a)->counter -= n) +#define atomic_dec_return(a) atomic_sub_return(1,a) #ifndef likely #define likely(exp) (exp) @@ -717,9 +700,43 @@ typedef struct { volatile int counter; } atomic_t; #define unlikely(exp) (exp) #endif +#define might_sleep() +#define might_sleep_if(c) +#define smp_mb() + +static inline +int test_and_set_bit(int nr, unsigned long *addr) +{ + int oldbit; + + while (nr >= sizeof(long)) { + nr -= sizeof(long); + addr++; + } + + oldbit = (*addr) & (1 << nr); + *addr |= (1 << nr); + return oldbit; +} + +static inline +int test_and_clear_bit(int nr, unsigned long *addr) +{ + int oldbit; + + while (nr >= sizeof(long)) { + nr -= sizeof(long); + addr++; + } + + oldbit = (*addr) & (1 << nr); + *addr &= ~(1 << nr); + return oldbit; +} + /* FIXME sys/capability will finally included linux/fs.h thus * cause numerous trouble on x86-64. as temporary solution for - * build broken at cary, we copy definition we need from capability.h + * build broken at Cray, we copy definition we need from capability.h * FIXME */ struct _cap_struct; @@ -744,9 +761,6 @@ typedef enum { cap_t cap_get_proc(void); int cap_get_flag(cap_t, cap_value_t, cap_flag_t, cap_flag_value_t *); -/* log related */ -static inline int llog_init_commit_master(void) { return 0; } -static inline int llog_cleanup_commit_master(int force) { return 0; } static inline void libcfs_run_lbug_upcall(char *file, const char *fn, const int l){} @@ -815,7 +829,7 @@ typedef struct file_lock { unsigned long fl_break_time; /* for nonblocking lease breaks */ union { - struct nfs_lock_info nfs_fl; + struct nfs_lock_info nfs_fl; } fl_u; } cfs_flock_t; @@ -887,10 +901,39 @@ void posix_acl_release(struct posix_acl *acl) { } +#ifdef LIBLUSTRE_POSIX_ACL +# ifndef posix_acl_xattr_entry +# define posix_acl_xattr_entry xattr_acl_entry +# endif +# ifndef posix_acl_xattr_header +# define posix_acl_xattr_header xattr_acl_header +# endif +# ifndef posix_acl_xattr_size +# define posix_acl_xattr_size(entry) xattr_acl_size(entry) +# endif +# ifndef CONFIG_FS_POSIX_ACL +# define CONFIG_FS_POSIX_ACL 1 +# endif +#endif + #ifndef ENOTSUPP #define ENOTSUPP ENOTSUP #endif +typedef int mm_segment_t; +enum { + KERNEL_DS, + USER_DS +}; +static inline mm_segment_t get_fs(void) +{ + return USER_DS; +} + +static inline void set_fs(mm_segment_t seg) +{ +} + #include #include #include @@ -898,4 +941,60 @@ void posix_acl_release(struct posix_acl *acl) #include #include +/* Fast hashing routine for a long. + (C) 2002 William Lee Irwin III, IBM */ + +/* + * Knuth recommends primes in approximately golden ratio to the maximum + * integer representable by a machine word for multiplicative hashing. + * Chuck Lever verified the effectiveness of this technique: + * http://www.citi.umich.edu/techreports/reports/citi-tr-00-1.pdf + * + * These primes are chosen to be bit-sparse, that is operations on + * them can use shifts and additions instead of multiplications for + * machines where multiplications are slow. + */ +#if BITS_PER_LONG == 32 +/* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */ +#define GOLDEN_RATIO_PRIME 0x9e370001UL +#elif BITS_PER_LONG == 64 +/* 2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1 */ +#define GOLDEN_RATIO_PRIME 0x9e37fffffffc0001UL +#else +#error Define GOLDEN_RATIO_PRIME for your wordsize. +#endif + +static inline unsigned long hash_long(unsigned long val, unsigned int bits) +{ + unsigned long hash = val; + +#if BITS_PER_LONG == 64 + /* Sigh, gcc can't optimise this alone like it does for 32 bits. */ + unsigned long n = hash; + n <<= 18; + hash -= n; + n <<= 33; + hash -= n; + n <<= 3; + hash += n; + n <<= 3; + hash -= n; + n <<= 4; + hash += n; + n <<= 2; + hash += n; +#else + /* On some cpus multiply is faster, on others gcc will do shifts */ + hash *= GOLDEN_RATIO_PRIME; +#endif + + /* High bits are more random, so use them. */ + return hash >> (BITS_PER_LONG - bits); +} + +static inline unsigned long hash_ptr(void *ptr, unsigned int bits) +{ + return hash_long((unsigned long)ptr, bits); +} + #endif