PageRenderTime 73ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 1ms

/filesystems/unixfs/common/linux/linux.h

http://macfuse.googlecode.com/
C Header | 563 lines | 447 code | 105 blank | 11 comment | 23 complexity | 64e052fd4b8c4599215d355284e84431 MD5 | raw file
Possible License(s): Apache-2.0, BSD-3-Clause, GPL-2.0
  1. #ifndef _LINUX_TYPES_H_
  2. #define _LINUX_TYPES_H_
  3. #if defined(__APPLE__)
  4. #include <errno.h>
  5. #include <sys/types.h>
  6. #include <stdint.h>
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <unistd.h>
  11. #include <ctype.h>
  12. #include <time.h>
  13. #include <libkern/OSByteOrder.h>
  14. #define __force
  15. #define __bitwise
  16. #define __packed2__ __attribute__((packed, aligned(2)))
  17. #define __u64 uint64_t
  18. #define __u32 uint32_t
  19. #define __u16 uint16_t
  20. #define __u8 uint8_t
  21. #define __s64 int64_t
  22. #define __s32 int32_t
  23. #define __s16 int16_t
  24. #define __s8 int8_t
  25. typedef __u64 u64;
  26. typedef __u32 u32;
  27. typedef __u16 u16;
  28. typedef __u8 u8;
  29. typedef __s64 s64;
  30. typedef __s32 s32;
  31. typedef __s16 s16;
  32. typedef __s8 s8;
  33. typedef __u16 __bitwise __le16;
  34. typedef __u16 __bitwise __be16;
  35. typedef __u32 __bitwise __le32;
  36. typedef __u32 __bitwise __be32;
  37. typedef __u64 __bitwise __le64;
  38. typedef __u64 __bitwise __be64;
  39. #ifndef __fs16
  40. #define __fs16 __u16
  41. #endif
  42. #ifndef __fs32
  43. #define __fs32 __u32
  44. #endif
  45. typedef unsigned gfp_t;
  46. typedef off_t loff_t;
  47. typedef long pgoff_t;
  48. typedef uint64_t sector_t;
  49. typedef uint16_t umode_t;
  50. /* dummy structures */
  51. struct dentry;
  52. struct file;
  53. struct super_block;
  54. struct kstatfs {
  55. __u64 f_type;
  56. __u64 f_blocks;
  57. __u64 f_bfree;
  58. __u64 f_bavail;
  59. __u64 f_files;
  60. __u64 f_ffree;
  61. __u32 f_bsize;
  62. __u32 f_namelen;
  63. __u32 f_frsize;
  64. __u32 padding;
  65. __u32 f_spare[6];
  66. };
  67. /****** grab-bag stuff and defines ******/
  68. #define MS_RDONLY 1
  69. #define EXPORT_SYMBOL(s) /**/
  70. #define BLOCK_SIZE_BITS 10
  71. #define BLOCK_SIZE (1 << BLOCK_SIZE_BITS)
  72. /* file types */
  73. #define DT_UNKNOWN 0
  74. #define DT_FIFO 1
  75. #define DT_CHR 2
  76. #define DT_DIR 4
  77. #define DT_BLK 6
  78. #define DT_REG 8
  79. #define DT_LNK 10
  80. #define DT_SOCK 12
  81. #define DT_WHT 14
  82. #define get_seconds() time(0)
  83. #define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
  84. #define simple_strtoul strtoul
  85. #define simple_strtol strtol
  86. #define printk printf
  87. #define lock_kernel() /**/
  88. #define unlock_kernel() /**/
  89. #define KERN_ERR /**/
  90. #define KERN_INFO /**/
  91. #define __GFP_DMA ((__force gfp_t)0x01u)
  92. #define __GFP_HIGHMEM ((__force gfp_t)0x02u)
  93. #define __GFP_DMA32 ((__force gfp_t)0x04u)
  94. #define __GFP_WAIT ((__force gfp_t)0x10u)
  95. #define __GFP_HIGH ((__force gfp_t)0x20u)
  96. #define __GFP_IO ((__force gfp_t)0x40u)
  97. #define __GFP_FS ((__force gfp_t)0x80u)
  98. #define GFP_KERNEL (__GFP_WAIT | __GFP_IO | __GFP_FS)
  99. #ifdef __compiler_offsetof
  100. #define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
  101. #else
  102. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  103. #endif
  104. #define container_of(ptr, type, member) ({ \
  105. const typeof( ((type *)0)->member ) *__mptr = (ptr); \
  106. (type *)( (char *)__mptr - offsetof(type,member) );})
  107. #define likely(x) __builtin_expect(!!(x), 1)
  108. #define unlikely(x) __builtin_expect(!!(x), 0)
  109. #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
  110. #define BUILD_BUG_ON_ZERO(e) (sizeof(char[1 - 2 * !!(e)]) - 1)
  111. #define BUG_ON(condition) /**/
  112. #define MAX_ERRNO 4095
  113. #define IS_ERR_VALUE(x) unlikely((x) >= (unsigned long)-MAX_ERRNO)
  114. #define __must_be_array(a) \
  115. BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0])))
  116. #define ARRAY_SIZE(arr) \
  117. (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
  118. static inline long PTR_ERR(const void* ptr)
  119. {
  120. return (long)ptr;
  121. }
  122. static inline void* ERR_PTR(long error)
  123. {
  124. return (void *)error;
  125. }
  126. static inline long IS_ERR(const void *ptr)
  127. {
  128. return IS_ERR_VALUE((unsigned long)ptr);
  129. }
  130. #define min_t(type, x, y) ({ \
  131. type __min1 = (x); \
  132. type __min2 = (y); \
  133. __min1 < __min2 ? __min1: __min2; })
  134. #define max_t(type, x, y) ({ \
  135. type __max1 = (x); \
  136. type __max2 = (y); \
  137. __max1 > __max2 ? __max1: __max2; })
  138. /****** page and memory stuff ******/
  139. #define PAGE_SIZE 4096
  140. #define PAGE_CACHE_SIZE PAGE_SIZE
  141. #define PAGE_CACHE_SHIFT 12
  142. #define PAGE_CACHE_MASK (~(PAGE_CACHE_SIZE-1))
  143. struct address_space {
  144. struct inode* host;
  145. };
  146. struct page {
  147. union {
  148. unsigned long private;
  149. struct address_space* mapping;
  150. };
  151. };
  152. static inline struct page* find_lock_page(struct address_space* mapping,
  153. pgoff_t offset)
  154. {
  155. return (struct page*)0;
  156. }
  157. static inline void page_noop(struct page* page)
  158. {
  159. /* nothing */
  160. }
  161. #define lock_page page_noop
  162. #define unlock_page page_noop
  163. #define put_page page_noop
  164. #define page_cache_release page_noop
  165. #define PageUptodate(x) 1
  166. #define PageError(x) 0
  167. static inline struct page* read_mapping_page(struct address_space* mapping,
  168. pgoff_t index, void* data)
  169. {
  170. return (struct page*)0;
  171. }
  172. static inline void* kmalloc(size_t size, gfp_t flags)
  173. {
  174. return malloc(size);
  175. }
  176. static inline void* kzalloc(size_t size, gfp_t flags)
  177. {
  178. return calloc(1, size);
  179. }
  180. static inline void kfree(const void* p)
  181. {
  182. free((void*)p);
  183. }
  184. /****** buffer stuff *****/
  185. struct block_device {
  186. int fd;
  187. unsigned bd_block_size;
  188. };
  189. struct buffer_head {
  190. sector_t b_blocknr;
  191. size_t b_size;
  192. struct b_flags {
  193. uint32_t dynamic : 1;
  194. } b_flags;
  195. unsigned char b_data[PAGE_SIZE];
  196. };
  197. int sb_bread_intobh(struct super_block* sb, off_t block,
  198. struct buffer_head* bh);
  199. struct buffer_head* sb_bread(struct super_block* sb, off_t block);
  200. struct buffer_head* sb_getblk(struct super_block* sb, sector_t block);
  201. void brelse(struct buffer_head* bh);
  202. #define bforget brelse
  203. static inline void buffer_noop(struct buffer_head *bh)
  204. {
  205. /* nothing */
  206. }
  207. static inline void ll_rw_block(int rw, int nr, struct buffer_head* bhs[])
  208. {
  209. /* nothing */
  210. }
  211. #define mark_buffer_dirty buffer_noop
  212. #define set_buffer_uptodate buffer_noop
  213. #define clear_buffer_uptodate buffer_noop
  214. #define wait_on_buffer buffer_noop
  215. #define buffer_dirty(x) 0
  216. #define set_buffer_mapped buffer_noop
  217. /****** bit and math stuff ******/
  218. #define BITOP_WORD(nr) ((nr) / BITS_PER_LONG)
  219. #define BITOP_LE_SWIZZLE ((BITS_PER_LONG-1) & ~0x7)
  220. #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 1)
  221. #define BITOP_ADDR(x) "=m" (*(volatile long *) (x))
  222. #else
  223. #define BITOP_ADDR(x) "+m" (*(volatile long *) (x))
  224. #endif
  225. #define ADDR BITOP_ADDR(addr)
  226. #if defined(__i386__) || defined(__x86_64__)
  227. static inline void __set_bit(int nr, volatile unsigned long *addr)
  228. {
  229. asm volatile("bts %1,%0" : ADDR : "Ir" (nr) : "memory");
  230. }
  231. #elif defined(__ppc__) || defined(__ppc64__)
  232. static inline void __set_bit(int nr, volatile unsigned long *addr)
  233. {
  234. *addr |= (1L << nr);
  235. }
  236. #endif
  237. #if defined(__LITTLE_ENDIAN__)
  238. #define generic_test_le_bit(nr, addr) test_bit(nr, addr)
  239. #define generic___set_le_bit(nr, addr) __set_bit(nr, addr)
  240. #define generic___clear_le_bit(nr, addr) __clear_bit(nr, addr)
  241. #define generic_test_and_set_le_bit(nr, addr) test_and_set_bit(nr, addr)
  242. #define generic_test_and_clear_le_bit(nr, addr) test_and_clear_bit(nr, addr)
  243. #define generic___test_and_set_le_bit(nr, addr) __test_and_set_bit(nr, addr)
  244. #define generic___test_and_clear_le_bit(nr, addr) __test_and_clear_bit(nr, addr)
  245. #define generic_find_next_zero_le_bit(addr, size, offset) \
  246. find_next_zero_bit(addr, size, offset)
  247. #define generic_find_next_le_bit(addr, size, offset) \
  248. find_next_bit(addr, size, offset)
  249. #elif defined(__BIG_ENDIAN__)
  250. #define generic_test_le_bit(nr, addr) \
  251. test_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  252. #define generic___set_le_bit(nr, addr) \
  253. __set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  254. #define generic___clear_le_bit(nr, addr) \
  255. __clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  256. #define generic_test_and_set_le_bit(nr, addr) \
  257. test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  258. #define generic_test_and_clear_le_bit(nr, addr) \
  259. test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  260. #define generic___test_and_set_le_bit(nr, addr) \
  261. __test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  262. #define generic___test_and_clear_le_bit(nr, addr) \
  263. __test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  264. extern unsigned long generic_find_next_zero_le_bit(
  265. const unsigned long *addr, unsigned long size,
  266. unsigned long offset);
  267. extern unsigned long generic_find_next_le_bit(const unsigned long *addr,
  268. unsigned long size, unsigned long offset);
  269. #endif
  270. #define ext2_set_bit(nr,addr) \
  271. generic___test_and_set_le_bit((nr),(unsigned long *)(addr))
  272. #define ext2_clear_bit(nr,addr) \
  273. generic___test_and_clear_le_bit((nr),(unsigned long *)(addr))
  274. #define ext2_test_bit(nr,addr) \
  275. generic_test_le_bit((nr),(unsigned long *)(addr))
  276. #define ext2_find_first_zero_bit(addr, size) \
  277. generic_find_first_zero_le_bit((unsigned long *)(addr), (size))
  278. #define ext2_find_next_zero_bit(addr, size, off) \
  279. generic_find_next_zero_le_bit((unsigned long *)(addr), (size), (off))
  280. #define ext2_find_next_bit(addr, size, off) \
  281. generic_find_next_le_bit((unsigned long *)(addr), (size), (off))
  282. #if defined(__i386__) || defined(__ppc__)
  283. #define BITS_PER_LONG 32
  284. #elif defined(__x86_64__) || defined(__ppc64__)
  285. #define BITS_PER_LONG 64
  286. #endif
  287. static inline unsigned int blksize_bits(unsigned int size)
  288. {
  289. unsigned int bits = 8;
  290. do {
  291. bits++;
  292. size >>= 1;
  293. } while (size > 256);
  294. return bits;
  295. }
  296. static inline __attribute__((const)) int is_power_of_2(unsigned long n)
  297. {
  298. return (n != 0 && ((n & (n - 1)) == 0));
  299. }
  300. static inline unsigned long ffz(unsigned long word) /* find first zero bit */
  301. {
  302. asm("bsf %1,%0"
  303. : "=r" (word)
  304. : "r" (~word));
  305. return word;
  306. }
  307. static inline unsigned long find_next_zero_bit(const unsigned long *addr,
  308. unsigned long size, unsigned long offset)
  309. {
  310. const unsigned long* p = addr + BITOP_WORD(offset);
  311. unsigned long result = offset & ~(BITS_PER_LONG-1);
  312. unsigned long tmp;
  313. if (offset >= size)
  314. return size;
  315. size -= result;
  316. offset %= BITS_PER_LONG;
  317. if (offset) {
  318. tmp = *(p++);
  319. tmp |= ~0UL >> (BITS_PER_LONG - offset);
  320. if (size < BITS_PER_LONG)
  321. goto found_first;
  322. if (~tmp)
  323. goto found_middle;
  324. size -= BITS_PER_LONG;
  325. result += BITS_PER_LONG;
  326. }
  327. while (size & ~(BITS_PER_LONG-1)) {
  328. if (~(tmp = *(p++)))
  329. goto found_middle;
  330. result += BITS_PER_LONG;
  331. size -= BITS_PER_LONG;
  332. }
  333. if (!size)
  334. return result;
  335. tmp = *p;
  336. found_first:
  337. tmp |= ~0UL << size;
  338. if (tmp == ~0UL) /* Are any bits zero? */
  339. return result + size; /* Nope. */
  340. found_middle:
  341. return result + ffz(tmp);
  342. }
  343. #define do_div(n, base) \
  344. ({ \
  345. unsigned long __upper, __low, __high, __mod, __base; \
  346. __base = (base); \
  347. asm("":"=a" (__low), "=d" (__high) : "A" (n)); \
  348. __upper = __high; \
  349. if (__high) { \
  350. __upper = __high % (__base); \
  351. __high = __high / (__base); \
  352. } \
  353. asm("divl %2":"=a" (__low), "=d" (__mod) \
  354. : "rm" (__base), "0" (__low), "1" (__upper)); \
  355. asm("":"=A" (n) : "a" (__low), "d" (__high)); \
  356. __mod; \
  357. })
  358. /****** endian stuff ******/
  359. #define le64_to_cpu(x) OSSwapLittleToHostInt64(x)
  360. #define be64_to_cpu(x) OSSwapBigToHostInt64(x)
  361. #define cpu_to_le64(x) OSSwapHostToLittleInt64(x)
  362. #define cpu_to_be64(x) OSSwapHostToBigInt64(x)
  363. #define le32_to_cpu(x) OSSwapLittleToHostInt32(x)
  364. #define be32_to_cpu(x) OSSwapBigToHostInt32(x)
  365. #define cpu_to_le32(x) OSSwapHostToLittleInt32(x)
  366. #define cpu_to_be32(x) OSSwapHostToBigInt32(x)
  367. #define le16_to_cpu(x) OSSwapLittleToHostInt16(x)
  368. #define be16_to_cpu(x) OSSwapBigToHostInt16(x)
  369. #define cpu_to_le16(x) OSSwapHostToLittleInt16(x)
  370. #define cpu_to_be16(x) OSSwapHostToBigInt16(x)
  371. static inline void le16_add_cpu(__le16* var, u16 val)
  372. {
  373. *var = cpu_to_le16(le16_to_cpu(*var) + val);
  374. }
  375. static inline void le32_add_cpu(__le32* var, u32 val)
  376. {
  377. *var = cpu_to_le32(le32_to_cpu(*var) + val);
  378. }
  379. static inline void le64_add_cpu(__le64* var, u64 val)
  380. {
  381. *var = cpu_to_le64(le64_to_cpu(*var) + val);
  382. }
  383. static inline void be16_add_cpu(__be16* var, u16 val)
  384. {
  385. *var = cpu_to_be16(be16_to_cpu(*var) + val);
  386. }
  387. static inline void be32_add_cpu(__be32* var, u32 val)
  388. {
  389. *var = cpu_to_be32(be32_to_cpu(*var) + val);
  390. }
  391. static inline void be64_add_cpu(__be64* var, u64 val)
  392. {
  393. *var = cpu_to_be64(be64_to_cpu(*var) + val);
  394. }
  395. /****** device stuff ******/
  396. #define MINORBITS 20
  397. #define MINORMASK ((1U << MINORBITS) - 1)
  398. #define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
  399. #define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
  400. #define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))
  401. static inline int old_valid_dev(dev_t dev)
  402. {
  403. return MAJOR(dev) < 256 && MINOR(dev) < 256;
  404. }
  405. static inline u16 old_encode_dev(dev_t dev)
  406. {
  407. return (MAJOR(dev) << 8) | MINOR(dev);
  408. }
  409. static inline dev_t old_decode_dev(u16 val)
  410. {
  411. return MKDEV((val >> 8) & 255, val & 255);
  412. }
  413. static inline int new_valid_dev(dev_t dev)
  414. {
  415. return 1;
  416. }
  417. static inline u32 new_encode_dev(dev_t dev)
  418. {
  419. unsigned major = MAJOR(dev);
  420. unsigned minor = MINOR(dev);
  421. return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
  422. }
  423. static inline dev_t new_decode_dev(u32 dev)
  424. {
  425. unsigned major = (dev & 0xfff00) >> 8;
  426. unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
  427. return MKDEV(major, minor);
  428. }
  429. static inline int huge_valid_dev(dev_t dev)
  430. {
  431. return 1;
  432. }
  433. static inline u64 huge_encode_dev(dev_t dev)
  434. {
  435. return new_encode_dev(dev);
  436. }
  437. static inline dev_t huge_decode_dev(u64 dev)
  438. {
  439. return new_decode_dev(dev);
  440. }
  441. static inline int sysv_valid_dev(dev_t dev)
  442. {
  443. return MAJOR(dev) < (1<<14) && MINOR(dev) < (1<<18);
  444. }
  445. static inline u32 sysv_encode_dev(dev_t dev)
  446. {
  447. return MINOR(dev) | (MAJOR(dev) << 18);
  448. }
  449. static inline unsigned sysv_major(u32 dev)
  450. {
  451. return (dev >> 18) & 0x3fff;
  452. }
  453. static inline unsigned sysv_minor(u32 dev)
  454. {
  455. return dev & 0x3ffff;
  456. }
  457. #endif /* __APPLE__ */
  458. #endif /* _LINUX_TYPES_H_ */