X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Fliblustre.h;h=dc339a419835b6494e467438f1b8759bb622d305;hb=a8209f8c79f3b037c6dc47ccb9eb5f0fcf4ffe78;hp=6c6ac1db559ff7edc78b1e355f743148e0cc91d0;hpb=efc75006b820c9b8e186c7650fc24edd5d0509af;p=fs%2Flustre-release.git diff --git a/lustre/include/liblustre.h b/lustre/include/liblustre.h index 6c6ac1d..dc339a4 100644 --- a/lustre/include/liblustre.h +++ b/lustre/include/liblustre.h @@ -25,13 +25,18 @@ #define LIBLUSTRE_H__ #include -#ifndef __CYGWIN__ -#include -#include -#else -#include -#include "ioctl.h" +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_ASM_PAGE_H +# include #endif +#ifdef HAVE_SYS_USER_H +# include +#endif + +#include "ioctl.h" + #include #include #include @@ -40,9 +45,9 @@ #include #include -#include +#include #include -#include +#include /* definitions for liblustre */ @@ -51,7 +56,7 @@ #define PAGE_SHIFT 12 #define PAGE_SIZE (1UL << PAGE_SHIFT) #define PAGE_MASK (~(PAGE_SIZE-1)) -#define loff_t __u64 +#define loff_t long long #define ERESTART 2001 typedef unsigned short umode_t; @@ -65,6 +70,62 @@ typedef unsigned short umode_t; #define smp_processor_id() 0 #endif +#ifndef smp_mb +#define smp_mb() do {} while (0) +#endif + +#ifndef might_sleep_if +#define might_sleep_if(cond) do {} while (0) +#endif + +#ifndef might_sleep +#define might_sleep() do {} while (0) +#endif + +#ifndef signal_pending +#define signal_pending(proc) 0 +#endif + +#ifndef MAY_EXEC +#define MAY_EXEC 1 +#endif + +#ifndef MAY_WRITE +#define MAY_WRITE 2 +#endif + +#ifndef MAY_READ +#define MAY_READ 4 +#endif + +#ifndef MAY_APPEND +#define MAY_APPEND 8 +#endif + +#ifndef FMODE_READ +#define FMODE_READ 1 +#endif + +#ifndef FMODE_WRITE +#define FMODE_WRITE 2 +#endif + +#ifndef FMODE_EXEC +#define FMODE_EXEC 4 +#endif + +#define S_IRWXUGO (S_IRWXU|S_IRWXG|S_IRWXO) +#define S_IALLUGO (S_ISUID|S_ISGID|S_ISVTX|S_IRWXUGO) +#define S_IRUGO (S_IRUSR|S_IRGRP|S_IROTH) +#define S_IWUGO (S_IWUSR|S_IWGRP|S_IWOTH) +#define S_IXUGO (S_IXUSR|S_IXGRP|S_IXOTH) + +#define LBUG() \ + do { \ + printf("!!!LBUG at %s:%d\n", __FILE__, __LINE__); \ + sleep(1000000); \ + } while (0) + /* always adopt 2.5 definitions */ #define KERNEL_VERSION(a,b,c) ((a)*100+(b)*10+c) #define LINUX_VERSION_CODE (2*200+5*10+0) @@ -111,17 +172,13 @@ static inline void *kmalloc(int size, int prot) #define GFP_HIGHUSER 1 #define GFP_ATOMIC 1 #define GFP_NOFS 1 -#define IS_ERR(a) (((a) && abs((int)(a)) < 500) ? 1 : 0) -#define PTR_ERR(a) ((int)(a)) -#define ERR_PTR(a) ((void*)(a)) - -#define capable(foo) 1 -#define CAP_SYS_ADMIN 1 +#define IS_ERR(a) (((a) && abs((long)(a)) < 500) ? 1 : 0) +#define PTR_ERR(a) ((long)(a)) +#define ERR_PTR(a) ((void*)((long)(a))) typedef struct { void *cwd; - -}mm_segment_t; +} mm_segment_t; typedef int (read_proc_t)(char *page, char **start, off_t off, int count, int *eof, void *data); @@ -130,78 +187,23 @@ struct file; /* forward ref */ typedef int (write_proc_t)(struct file *file, const char *buffer, unsigned long count, void *data); -/* byteorder */ -#define __swab16(x) \ -({ \ - __u16 __x = (x); \ - ((__u16)( \ - (((__u16)(__x) & (__u16)0x00ffU) << 8) | \ - (((__u16)(__x) & (__u16)0xff00U) >> 8) )); \ -}) - -#define __swab32(x) \ -({ \ - __u32 __x = (x); \ - ((__u32)( \ - (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | \ - (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | \ - (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | \ - (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); \ -}) - -#define __swab64(x) \ -({ \ - __u64 __x = (x); \ - ((__u64)( \ - (__u64)(((__u64)(__x) & (__u64)0x00000000000000ffULL) << 56) | \ - (__u64)(((__u64)(__x) & (__u64)0x000000000000ff00ULL) << 40) | \ - (__u64)(((__u64)(__x) & (__u64)0x0000000000ff0000ULL) << 24) | \ - (__u64)(((__u64)(__x) & (__u64)0x00000000ff000000ULL) << 8) | \ - (__u64)(((__u64)(__x) & (__u64)0x000000ff00000000ULL) >> 8) | \ - (__u64)(((__u64)(__x) & (__u64)0x0000ff0000000000ULL) >> 24) | \ - (__u64)(((__u64)(__x) & (__u64)0x00ff000000000000ULL) >> 40) | \ - (__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); \ -}) - -#define __swab16s(x) __swab16(*(x)) -#define __swab32s(x) __swab32(*(x)) -#define __swab64s(x) __swab64(*(x)) - -#define __LITTLE_ENDIAN__ -#ifdef __LITTLE_ENDIAN__ -# define le16_to_cpu(x) ((__u16)(x)) -# define cpu_to_le16(x) ((__u16)(x)) -# define le32_to_cpu(x) ((__u32)(x)) -# define cpu_to_le32(x) ((__u32)(x)) -# define le64_to_cpu(x) ((__u64)(x)) -# define cpu_to_le64(x) ((__u64)(x)) -#else -# define le16_to_cpu(x) __swab16(x) -# define cpu_to_le16(x) __swab16(x) -# define le32_to_cpu(x) __swab32(x) -# define cpu_to_le32(x) __swab32(x) -# define le64_to_cpu(x) __swab64(x) -# define cpu_to_le64(x) __swab64(x) -# error "do more check here!!!" -#endif - #define NIPQUAD(addr) \ ((unsigned char *)&addr)[0], \ ((unsigned char *)&addr)[1], \ ((unsigned char *)&addr)[2], \ ((unsigned char *)&addr)[3] - -#if defined(__LITTLE_ENDIAN__) + +#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__) +#elif defined(__BIG_ENDIAN) #define HIPQUAD NIPQUAD #else -#error "Please fix asm/byteorder.h" -#endif /* __LITTLE_ENDIAN__ */ +#error "Undefined byteorder??" +#endif /* __LITTLE_ENDIAN */ /* bits ops */ static __inline__ int set_bit(int nr,long * addr) @@ -235,6 +237,16 @@ static __inline__ int test_bit(int nr, long * addr) return ((mask & *addr) != 0); } +static __inline__ int test_and_set_bit(int nr, long * addr) +{ + int res; + + res = test_bit(nr, addr); + set_bit(nr, addr); + + return res; +} + static __inline__ int ext2_set_bit(int nr, void *addr) { return set_bit(nr, (long*)addr); @@ -256,16 +268,17 @@ struct module { int count; }; -static inline void MODULE_AUTHOR(char *name) -{ - printf("%s\n", name); -} -#define MODULE_DESCRIPTION(name) MODULE_AUTHOR(name) -#define MODULE_LICENSE(name) MODULE_AUTHOR(name) +#define MODULE_AUTHOR(name) +#define MODULE_DESCRIPTION(name) +#define MODULE_LICENSE(name) + +#define module_init(init) +#define module_exit(exit) #define THIS_MODULE NULL #define __init #define __exit +#define __user /* devices */ @@ -284,12 +297,22 @@ static inline int request_module(char *name) return (-EINVAL); } -#define __MOD_INC_USE_COUNT(m) do {int a = 1; a++; } while (0) -#define __MOD_DEC_USE_COUNT(m) do {int a = 1; a++; } while (0) -#define MOD_INC_USE_COUNT do {int a = 1; a++; } while (0) -#define MOD_DEC_USE_COUNT do {int a = 1; a++; } while (0) -#define try_module_get __MOD_INC_USE_COUNT -#define module_put __MOD_DEC_USE_COUNT +#define __MOD_INC_USE_COUNT(m) do {} while (0) +#define __MOD_DEC_USE_COUNT(m) do {} while (0) +#define MOD_INC_USE_COUNT do {} while (0) +#define MOD_DEC_USE_COUNT do {} while (0) +static inline void __module_get(struct module *module) +{ +} + +static inline int try_module_get(struct module *module) +{ + return 1; +} + +static inline void module_put(struct module *module) +{ +} /* module initialization */ extern int init_obdclass(void); @@ -303,14 +326,15 @@ extern int echo_client_init(void); /* general stuff */ -#define jiffies 0 #define EXPORT_SYMBOL(S) -typedef int spinlock_t; +typedef struct { } spinlock_t; typedef __u64 kdev_t; -#define SPIN_LOCK_UNLOCKED 0 +#define SPIN_LOCK_UNLOCKED (spinlock_t) { } +#define LASSERT_SPIN_LOCKED(lock) do {} while(0) + static inline void spin_lock(spinlock_t *l) {return;} static inline void spin_unlock(spinlock_t *l) {return;} static inline void spin_lock_init(spinlock_t *l) {return;} @@ -318,22 +342,18 @@ static inline void local_irq_save(unsigned long flag) {return;} static inline void local_irq_restore(unsigned long flag) {return;} static inline int spin_is_locked(spinlock_t *l) {return 1;} -static inline void spin_lock_bh(spinlock_t *l) -{ - return; -} -static inline void spin_unlock_bh(spinlock_t *l) -{ - return; -} -static inline void spin_unlock_irqrestore(spinlock_t *a, unsigned long b) -{ - return; -} -static inline void spin_lock_irqsave(spinlock_t *a, unsigned long b) -{ - return; -} +static inline void spin_lock_bh(spinlock_t *l) {} +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 struct { } rwlock_t; +#define rwlock_init(x) do {} while(0) +#define RW_LOCK_UNLOCKED (rwlock_t) {} +#define read_lock(l) +#define read_unlock(l) +#define write_lock(l) +#define write_unlock(l) #define min(x,y) ((x)<(y) ? (x) : (y)) #define max(x,y) ((x)>(y) ? (x) : (y)) @@ -347,6 +367,10 @@ static inline void spin_lock_irqsave(spinlock_t *a, unsigned long b) ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; }) #endif +#define container_of(ptr, type, member) ({ \ + const typeof( ((type *)0)->member ) *__mptr = (ptr); \ + (type *)( (char *)__mptr - offsetof(type,member) );}) + /* registering symbols */ #define ERESTARTSYS ERESTART @@ -354,14 +378,7 @@ static inline void spin_lock_irqsave(spinlock_t *a, unsigned long b) /* random */ -static inline void get_random_bytes(void *ptr, int size) -{ - int *p = (int *)ptr; - int i, count = size/sizeof(int); - - for (i = 0; i< count; i++) - *p++ = rand(); -} +void get_random_bytes(void *ptr, int size); /* memory */ @@ -380,6 +397,12 @@ static inline int copy_to_user(void *a,void *b, int c) return 0; } +static inline long strncpy_from_user(char *dest, const char *src, long n) +{ + char *s; + s = strncpy(dest, src, n); + return strnlen(s, n); +} /* slabs */ typedef struct { @@ -411,23 +434,19 @@ static inline int kmem_cache_destroy(kmem_cache_t *a) #define kmem_cache_alloc(cache, prio) malloc(cache->size) #define kmem_cache_free(cache, obj) free(obj) -#define PAGE_CACHE_SIZE PAGE_SIZE -#define PAGE_CACHE_SHIFT 12 -#define PAGE_CACHE_MASK PAGE_MASK +#define PAGE_CACHE_SIZE PAGE_SIZE +#define PAGE_CACHE_SHIFT PAGE_SHIFT +#define PAGE_CACHE_MASK PAGE_MASK -struct page { - void *addr; - unsigned long index; - struct list_head list; - unsigned long private; +/* struct page decl moved out from here into portals/include/libcfs/user-prim.h */ - /* internally used by liblustre file i/o */ - int _offset; - int _count; -}; +/* 2.4 defines */ +#define PAGE_LIST_ENTRY list +#define PAGE_LIST(page) ((page)->list) +#define page_address(page) ((page)->addr) #define kmap(page) (page)->addr -#define kunmap(a) do { int foo = 1; foo++; } while (0) +#define kunmap(a) do {} while (0) static inline struct page *alloc_pages(int mask, unsigned long order) { @@ -461,6 +480,7 @@ static inline void __free_pages(struct page *pg, int what) } #define __free_page(page) __free_pages((page), 0) +#define free_page(page) __free_page(page) static inline struct page* __grab_cache_page(unsigned long index) { @@ -497,7 +517,7 @@ static inline struct page* __grab_cache_page(unsigned long index) #define ATTR_ATTR_FLAG 0x0400 #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 +/* ATTR_CTIME_SET has been defined in lustre_idl.h */ struct iattr { unsigned int ia_valid; @@ -520,31 +540,37 @@ struct iattr { #define IT_GETXATTR 0x0040 #define IT_EXEC 0x0080 #define IT_PIN 0x0100 +#define IT_CHDIR 0x0200 #define IT_FL_LOCKED 0x0001 #define IT_FL_FOLLOWED 0x0002 /* set by vfs_follow_link */ #define INTENT_MAGIC 0x19620323 -struct lustre_intent_data { - int it_disposition; - int it_status; - __u64 it_lock_handle; - void *it_data; - int it_lock_mode; - int it_int_flags; -}; struct lookup_intent { int it_magic; void (*it_op_release)(struct lookup_intent *); int it_op; int it_flags; int it_create_mode; - union { - struct lustre_intent_data lustre; - } d; + union { + void *fs_data; /* FS-specific intent data */ + } d; }; +struct lustre_intent_data { + int it_disposition; + int it_status; + __u64 it_lock_handle; + void *it_data; + int it_lock_mode; + int it_int_flags; + void *it_key; + int it_key_size; +}; + +#define LUSTRE_IT(it) ((struct lustre_intent_data *)((it)->d.fs_data)) + static inline void intent_init(struct lookup_intent *it, int op, int flags) { memset(it, 0, sizeof(*it)); @@ -562,8 +588,6 @@ struct vfsmount { void *pwd; }; -#define cpu_to_le32(x) ((__u32)(x)) - /* semaphores */ struct rw_semaphore { int count; @@ -574,24 +598,106 @@ struct semaphore { int count; }; -#define down(a) do {(a)->count++;} while (0) -#define up(a) do {(a)->count--;} while (0) -#define down_read(a) do {(a)->count++;} while (0) -#define up_read(a) do {(a)->count--;} while (0) -#define down_write(a) do {(a)->count++;} while (0) -#define up_write(a) do {(a)->count--;} while (0) -#define sema_init(a,b) do { (a)->count = b; } while (0) -#define init_rwsem(a) do {} while (0) +struct crypto_tfm; + +struct scatterlist { + struct page *page; + unsigned int offset; + __u32 dma_address; + unsigned int length; +}; + +struct cipher_tfm { + void *cit_iv; + unsigned int cit_ivsize; + __u32 cit_mode; + int (*cit_setkey)(struct crypto_tfm *tfm, + const __u8 *key, unsigned int keylen); + int (*cit_encrypt)(struct crypto_tfm *tfm, + struct scatterlist *dst, + struct scatterlist *src, + unsigned int nbytes); + int (*cit_encrypt_iv)(struct crypto_tfm *tfm, + struct scatterlist *dst, + struct scatterlist *src, + unsigned int nbytes, __u8 *iv); + int (*cit_decrypt)(struct crypto_tfm *tfm, + struct scatterlist *dst, + struct scatterlist *src, + unsigned int nbytes); + int (*cit_decrypt_iv)(struct crypto_tfm *tfm, + struct scatterlist *dst, + struct scatterlist *src, + unsigned int nbytes, __u8 *iv); + void (*cit_xor_block)(__u8 *dst, const __u8 *src); +}; + +struct digest_tfm { + void (*dit_init)(struct crypto_tfm *tfm); + void (*dit_update)(struct crypto_tfm *tfm, + struct scatterlist *sg, unsigned int nsg); + void (*dit_update_kernel)(struct crypto_tfm *tfm, + const void *data, size_t count); + void (*dit_final)(struct crypto_tfm *tfm, __u8 *out); + void (*dit_digest)(struct crypto_tfm *tfm, struct scatterlist *sg, + unsigned int nsg, __u8 *out); + int (*dit_setkey)(struct crypto_tfm *tfm, + const __u8 *key, unsigned int keylen); +#ifdef CONFIG_CRYPTO_HMAC + void *dit_hmac_block; +#endif +}; + +struct compress_tfm { + int (*cot_compress)(struct crypto_tfm *tfm, + const __u8 *src, unsigned int slen, + __u8 *dst, unsigned int *dlen); + int (*cot_decompress)(struct crypto_tfm *tfm, + const __u8 *src, unsigned int slen, + __u8 *dst, unsigned int *dlen); +}; + +struct crypto_tfm { + + __u32 crt_flags; + + union { + struct cipher_tfm cipher; + struct digest_tfm digest; + struct compress_tfm compress; + } crt_u; + + struct crypto_alg *__crt_alg; +}; + +/* use the macro's argument to avoid unused warnings */ +#define down(a) do { (void)a; } while (0) +#define up(a) do { (void)a; } while (0) +#define down_read(a) do { (void)a; } while (0) +#define up_read(a) do { (void)a; } while (0) +#define down_write(a) do { (void)a; } while (0) +#define up_write(a) do { (void)a; } while (0) +#define sema_init(a,b) do { (void)a; } while (0) +#define init_rwsem(a) do { (void)a; } while (0) + #define DECLARE_MUTEX(name) \ struct semaphore name = { 1 } + static inline void init_MUTEX (struct semaphore *sem) { sema_init(sem, 1); } +struct rpc_pipe_msg { + struct list_head list; + void *data; + size_t len; + size_t copied; + int error; +}; typedef struct { - struct list_head sleepers; + struct list_head task_list; } wait_queue_head_t; typedef struct { @@ -613,23 +719,41 @@ struct task_struct { struct signal pending; char comm[32]; int pid; + uid_t uid; + gid_t gid; int fsuid; int fsgid; + int max_groups; + int ngroups; + gid_t *groups; __u32 cap_effective; + __u32 pag; + + struct fs_struct __fs; }; extern struct task_struct *current; - -#define in_group_p(a) 0 /* FIXME */ +int in_group_p(gid_t gid); +static inline int capable(int cap) +{ + if (current->cap_effective & (1 << cap)) + return 1; + else + return 0; +} #define set_current_state(foo) do { current->state = foo; } while (0) #define init_waitqueue_entry(q,p) do { (q)->process = p; } while (0) -#define add_wait_queue(q,p) do { list_add(&(q)->sleepers, &(p)->sleeping); } while (0) +#define add_wait_queue(q,p) do { list_add(&(q)->task_list, &(p)->sleeping); } while (0) #define del_wait_queue(p) do { list_del(&(p)->sleeping); } while (0) #define remove_wait_queue(q,p) do { list_del(&(p)->sleeping); } while (0) -#define init_waitqueue_head(l) INIT_LIST_HEAD(&(l)->sleepers) +#define DECLARE_WAIT_QUEUE_HEAD(HEAD) \ + wait_queue_head_t HEAD = { \ + .task_list = LIST_HEAD_INIT(HEAD.task_list) \ + } +#define init_waitqueue_head(l) INIT_LIST_HEAD(&(l)->task_list) #define wake_up(l) do { int a; a++; } while (0) #define TASK_INTERRUPTIBLE 0 #define TASK_UNINTERRUPTIBLE 1 @@ -649,31 +773,45 @@ extern struct task_struct *current; #define in_interrupt() (0) -#define schedule() do { int a; a++; } while (0) +#define schedule() do {} while (0) static inline int schedule_timeout(signed long t) { return 0; } -#define lock_kernel() do { int a; a++; } while (0) -#define daemonize(l) do { int a; a++; } while (0) -#define sigfillset(l) do { int a; a++; } while (0) -#define recalc_sigpending(l) do { int a; a++; } while (0) +#define lock_kernel() do {} while (0) +#define unlock_kernel() do {} while (0) +#define daemonize(l) do {} while (0) +#define sigfillset(l) do {} while (0) +#define recalc_sigpending(l) do {} while (0) #define kernel_thread(l,m,n) LBUG() #define USERMODEHELPER(path, argv, envp) (0) - -static inline int call_usermodehelper(char *prog, char **argv, char **evnp, int unknown) -{ - return 0; -} - - #define SIGNAL_MASK_ASSERT() - #define KERN_INFO +#include +#if HZ != 1 +#error "liblustre's jiffies currently expects HZ to be 1" +#endif +#define jiffies \ +({ \ + unsigned long _ret = 0; \ + struct timeval tv; \ + if (gettimeofday(&tv, NULL) == 0) \ + _ret = tv.tv_sec; \ + _ret; \ +}) +#define time_after(a, b) ((long)(b) - (long)(a) < 0) +#define time_before(a, b) time_after(b,a) + +static inline unsigned long get_seconds(void) +{ + struct timeval tv; + gettimeofday(&tv, NULL); + return (tv.tv_sec + tv.tv_usec / 1000000); +} struct timer_list { struct list_head tl_list; @@ -708,9 +846,11 @@ 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) +#define atomic_dec_and_lock(a, l) atomic_dec_and_test(a) #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) @@ -723,20 +863,41 @@ typedef struct { volatile int counter; } atomic_t; #define unlikely(exp) (exp) #endif +/* 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 + * FIXME + */ +struct _cap_struct; +typedef struct _cap_struct *cap_t; +typedef int cap_value_t; +typedef enum { + CAP_EFFECTIVE=0, + CAP_PERMITTED=1, + CAP_INHERITABLE=2 +} cap_flag_t; +typedef enum { + CAP_CLEAR=0, + CAP_SET=1 +} cap_flag_value_t; + +#define CAP_DAC_OVERRIDE 1 +#define CAP_DAC_READ_SEARCH 2 +#define CAP_FOWNER 3 +#define CAP_FSETID 4 +#define CAP_SYS_ADMIN 21 + +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 portals_run_lbug_upcall(char *file, const char *fn, const int l){} -#define LBUG() \ - do { \ - printf("!!!LBUG at %s:%d\n", __FILE__, __LINE__); \ - sleep(1000000); \ - } while (0) - - - /* completion */ struct completion { unsigned int done; @@ -774,6 +935,4 @@ int liblustre_wait_event(int timeout); #include #include - #endif -