ctree.h 48 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530
  1. /*
  2. * Copyright (C) 2007 Oracle. All rights reserved.
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU General Public
  6. * License v2 as published by the Free Software Foundation.
  7. *
  8. * This program is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11. * General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public
  14. * License along with this program; if not, write to the
  15. * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16. * Boston, MA 021110-1307, USA.
  17. */
  18. #ifndef __BTRFS_CTREE__
  19. #define __BTRFS_CTREE__
  20. #include <linux/version.h>
  21. #include <linux/mm.h>
  22. #include <linux/highmem.h>
  23. #include <linux/fs.h>
  24. #include <linux/workqueue.h>
  25. #include <linux/completion.h>
  26. #include <linux/backing-dev.h>
  27. #include <asm/kmap_types.h>
  28. #include "bit-radix.h"
  29. #include "extent_io.h"
  30. #include "extent_map.h"
  31. struct btrfs_trans_handle;
  32. struct btrfs_transaction;
  33. extern struct kmem_cache *btrfs_trans_handle_cachep;
  34. extern struct kmem_cache *btrfs_transaction_cachep;
  35. extern struct kmem_cache *btrfs_bit_radix_cachep;
  36. extern struct kmem_cache *btrfs_path_cachep;
  37. #define BTRFS_MAGIC "_B5RfS_M"
  38. #define BTRFS_MAX_LEVEL 8
  39. /* holds pointers to all of the tree roots */
  40. #define BTRFS_ROOT_TREE_OBJECTID 1ULL
  41. /* stores information about which extents are in use, and reference counts */
  42. #define BTRFS_EXTENT_TREE_OBJECTID 2ULL
  43. /*
  44. * chunk tree stores translations from logical -> physical block numbering
  45. * the super block points to the chunk tree
  46. */
  47. #define BTRFS_CHUNK_TREE_OBJECTID 3ULL
  48. /*
  49. * stores information about which areas of a given device are in use.
  50. * one per device. The tree of tree roots points to the device tree
  51. */
  52. #define BTRFS_DEV_TREE_OBJECTID 4ULL
  53. /* one per subvolume, storing files and directories */
  54. #define BTRFS_FS_TREE_OBJECTID 5ULL
  55. /* directory objectid inside the root tree */
  56. #define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
  57. /*
  58. * All files have objectids higher than this.
  59. */
  60. #define BTRFS_FIRST_FREE_OBJECTID 256ULL
  61. /*
  62. * the device items go into the chunk tree. The key is in the form
  63. * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
  64. */
  65. #define BTRFS_DEV_ITEMS_OBJECTID 1ULL
  66. /*
  67. * we can actually store much bigger names, but lets not confuse the rest
  68. * of linux
  69. */
  70. #define BTRFS_NAME_LEN 255
  71. /* 32 bytes in various csum fields */
  72. #define BTRFS_CSUM_SIZE 32
  73. /* four bytes for CRC32 */
  74. #define BTRFS_CRC32_SIZE 4
  75. #define BTRFS_EMPTY_DIR_SIZE 0
  76. #define BTRFS_FT_UNKNOWN 0
  77. #define BTRFS_FT_REG_FILE 1
  78. #define BTRFS_FT_DIR 2
  79. #define BTRFS_FT_CHRDEV 3
  80. #define BTRFS_FT_BLKDEV 4
  81. #define BTRFS_FT_FIFO 5
  82. #define BTRFS_FT_SOCK 6
  83. #define BTRFS_FT_SYMLINK 7
  84. #define BTRFS_FT_XATTR 8
  85. #define BTRFS_FT_MAX 9
  86. /*
  87. * the key defines the order in the tree, and so it also defines (optimal)
  88. * block layout. objectid corresonds to the inode number. The flags
  89. * tells us things about the object, and is a kind of stream selector.
  90. * so for a given inode, keys with flags of 1 might refer to the inode
  91. * data, flags of 2 may point to file data in the btree and flags == 3
  92. * may point to extents.
  93. *
  94. * offset is the starting byte offset for this key in the stream.
  95. *
  96. * btrfs_disk_key is in disk byte order. struct btrfs_key is always
  97. * in cpu native order. Otherwise they are identical and their sizes
  98. * should be the same (ie both packed)
  99. */
  100. struct btrfs_disk_key {
  101. __le64 objectid;
  102. u8 type;
  103. __le64 offset;
  104. } __attribute__ ((__packed__));
  105. struct btrfs_key {
  106. u64 objectid;
  107. u8 type;
  108. u64 offset;
  109. } __attribute__ ((__packed__));
  110. struct btrfs_mapping_tree {
  111. struct extent_map_tree map_tree;
  112. };
  113. #define BTRFS_DEV_UUID_SIZE 16
  114. struct btrfs_dev_item {
  115. /* the internal btrfs device id */
  116. __le64 devid;
  117. /* size of the device */
  118. __le64 total_bytes;
  119. /* bytes used */
  120. __le64 bytes_used;
  121. /* optimal io alignment for this device */
  122. __le32 io_align;
  123. /* optimal io width for this device */
  124. __le32 io_width;
  125. /* minimal io size for this device */
  126. __le32 sector_size;
  127. /* type and info about this device */
  128. __le64 type;
  129. /* btrfs generated uuid for this device */
  130. u8 uuid[BTRFS_DEV_UUID_SIZE];
  131. } __attribute__ ((__packed__));
  132. struct btrfs_stripe {
  133. __le64 devid;
  134. __le64 offset;
  135. } __attribute__ ((__packed__));
  136. struct btrfs_chunk {
  137. __le64 owner;
  138. __le64 stripe_len;
  139. __le64 type;
  140. /* optimal io alignment for this chunk */
  141. __le32 io_align;
  142. /* optimal io width for this chunk */
  143. __le32 io_width;
  144. /* minimal io size for this chunk */
  145. __le32 sector_size;
  146. /* 2^16 stripes is quite a lot, a second limit is the size of a single
  147. * item in the btree
  148. */
  149. __le16 num_stripes;
  150. struct btrfs_stripe stripe;
  151. /* additional stripes go here */
  152. } __attribute__ ((__packed__));
  153. static inline unsigned long btrfs_chunk_item_size(int num_stripes)
  154. {
  155. BUG_ON(num_stripes == 0);
  156. return sizeof(struct btrfs_chunk) +
  157. sizeof(struct btrfs_stripe) * (num_stripes - 1);
  158. }
  159. #define BTRFS_FSID_SIZE 16
  160. #define BTRFS_HEADER_FLAG_WRITTEN (1 << 0)
  161. /*
  162. * every tree block (leaf or node) starts with this header.
  163. */
  164. struct btrfs_header {
  165. u8 csum[BTRFS_CSUM_SIZE];
  166. u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
  167. __le64 bytenr; /* which block this node is supposed to live in */
  168. __le64 flags;
  169. __le64 generation;
  170. __le64 owner;
  171. __le32 nritems;
  172. u8 level;
  173. } __attribute__ ((__packed__));
  174. #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
  175. sizeof(struct btrfs_header)) / \
  176. sizeof(struct btrfs_key_ptr))
  177. #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
  178. #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
  179. #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
  180. sizeof(struct btrfs_item) - \
  181. sizeof(struct btrfs_file_extent_item))
  182. /*
  183. * this is a very generous portion of the super block, giving us
  184. * room to translate 14 chunks with 3 stripes each.
  185. */
  186. #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
  187. /*
  188. * the super block basically lists the main trees of the FS
  189. * it currently lacks any block count etc etc
  190. */
  191. struct btrfs_super_block {
  192. u8 csum[BTRFS_CSUM_SIZE];
  193. /* the first 4 fields must match struct btrfs_header */
  194. u8 fsid[16]; /* FS specific uuid */
  195. __le64 bytenr; /* this block number */
  196. __le64 flags;
  197. __le64 magic;
  198. __le64 generation;
  199. __le64 root;
  200. __le64 chunk_root;
  201. __le64 total_bytes;
  202. __le64 bytes_used;
  203. __le64 root_dir_objectid;
  204. __le64 num_devices;
  205. __le32 sectorsize;
  206. __le32 nodesize;
  207. __le32 leafsize;
  208. __le32 stripesize;
  209. __le32 sys_chunk_array_size;
  210. u8 root_level;
  211. u8 chunk_root_level;
  212. struct btrfs_dev_item dev_item;
  213. u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
  214. } __attribute__ ((__packed__));
  215. /*
  216. * A leaf is full of items. offset and size tell us where to find
  217. * the item in the leaf (relative to the start of the data area)
  218. */
  219. struct btrfs_item {
  220. struct btrfs_disk_key key;
  221. __le32 offset;
  222. __le32 size;
  223. } __attribute__ ((__packed__));
  224. /*
  225. * leaves have an item area and a data area:
  226. * [item0, item1....itemN] [free space] [dataN...data1, data0]
  227. *
  228. * The data is separate from the items to get the keys closer together
  229. * during searches.
  230. */
  231. struct btrfs_leaf {
  232. struct btrfs_header header;
  233. struct btrfs_item items[];
  234. } __attribute__ ((__packed__));
  235. /*
  236. * all non-leaf blocks are nodes, they hold only keys and pointers to
  237. * other blocks
  238. */
  239. struct btrfs_key_ptr {
  240. struct btrfs_disk_key key;
  241. __le64 blockptr;
  242. __le64 generation;
  243. } __attribute__ ((__packed__));
  244. struct btrfs_node {
  245. struct btrfs_header header;
  246. struct btrfs_key_ptr ptrs[];
  247. } __attribute__ ((__packed__));
  248. /*
  249. * btrfs_paths remember the path taken from the root down to the leaf.
  250. * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
  251. * to any other levels that are present.
  252. *
  253. * The slots array records the index of the item or block pointer
  254. * used while walking the tree.
  255. */
  256. struct btrfs_path {
  257. struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
  258. int slots[BTRFS_MAX_LEVEL];
  259. int reada;
  260. int lowest_level;
  261. };
  262. /*
  263. * items in the extent btree are used to record the objectid of the
  264. * owner of the block and the number of references
  265. */
  266. struct btrfs_extent_item {
  267. __le32 refs;
  268. } __attribute__ ((__packed__));
  269. struct btrfs_extent_ref {
  270. __le64 root;
  271. __le64 generation;
  272. __le64 objectid;
  273. __le64 offset;
  274. } __attribute__ ((__packed__));
  275. /* dev extents record free space on individual devices. The owner
  276. * field points back to the chunk allocation mapping tree that allocated
  277. * the extent
  278. */
  279. struct btrfs_dev_extent {
  280. __le64 owner;
  281. __le64 length;
  282. } __attribute__ ((__packed__));
  283. struct btrfs_inode_ref {
  284. __le16 name_len;
  285. /* name goes here */
  286. } __attribute__ ((__packed__));
  287. struct btrfs_timespec {
  288. __le64 sec;
  289. __le32 nsec;
  290. } __attribute__ ((__packed__));
  291. /*
  292. * there is no padding here on purpose. If you want to extent the inode,
  293. * make a new item type
  294. */
  295. struct btrfs_inode_item {
  296. __le64 generation;
  297. __le64 size;
  298. __le64 nblocks;
  299. __le64 block_group;
  300. __le32 nlink;
  301. __le32 uid;
  302. __le32 gid;
  303. __le32 mode;
  304. __le64 rdev;
  305. __le16 flags;
  306. __le16 compat_flags;
  307. struct btrfs_timespec atime;
  308. struct btrfs_timespec ctime;
  309. struct btrfs_timespec mtime;
  310. struct btrfs_timespec otime;
  311. } __attribute__ ((__packed__));
  312. struct btrfs_dir_item {
  313. struct btrfs_disk_key location;
  314. __le16 data_len;
  315. __le16 name_len;
  316. u8 type;
  317. } __attribute__ ((__packed__));
  318. struct btrfs_root_item {
  319. struct btrfs_inode_item inode;
  320. __le64 root_dirid;
  321. __le64 bytenr;
  322. __le64 byte_limit;
  323. __le64 bytes_used;
  324. __le32 flags;
  325. __le32 refs;
  326. struct btrfs_disk_key drop_progress;
  327. u8 drop_level;
  328. u8 level;
  329. } __attribute__ ((__packed__));
  330. #define BTRFS_FILE_EXTENT_REG 0
  331. #define BTRFS_FILE_EXTENT_INLINE 1
  332. struct btrfs_file_extent_item {
  333. __le64 generation;
  334. u8 type;
  335. /*
  336. * disk space consumed by the extent, checksum blocks are included
  337. * in these numbers
  338. */
  339. __le64 disk_bytenr;
  340. __le64 disk_num_bytes;
  341. /*
  342. * the logical offset in file blocks (no csums)
  343. * this extent record is for. This allows a file extent to point
  344. * into the middle of an existing extent on disk, sharing it
  345. * between two snapshots (useful if some bytes in the middle of the
  346. * extent have changed
  347. */
  348. __le64 offset;
  349. /*
  350. * the logical number of file blocks (no csums included)
  351. */
  352. __le64 num_bytes;
  353. } __attribute__ ((__packed__));
  354. struct btrfs_csum_item {
  355. u8 csum;
  356. } __attribute__ ((__packed__));
  357. /* different types of block groups (and chunks) */
  358. #define BTRFS_BLOCK_GROUP_DATA (1 << 0)
  359. #define BTRFS_BLOCK_GROUP_SYSTEM (1 << 1)
  360. #define BTRFS_BLOCK_GROUP_METADATA (1 << 2)
  361. #define BTRFS_BLOCK_GROUP_RAID0 (1 << 3)
  362. #define BTRFS_BLOCK_GROUP_RAID1 (1 << 4)
  363. #define BTRFS_BLOCK_GROUP_DUP (1 << 5)
  364. struct btrfs_block_group_item {
  365. __le64 used;
  366. __le64 chunk_tree;
  367. __le64 chunk_objectid;
  368. __le64 flags;
  369. } __attribute__ ((__packed__));
  370. struct btrfs_space_info {
  371. u64 flags;
  372. u64 total_bytes;
  373. u64 bytes_used;
  374. u64 bytes_pinned;
  375. int full;
  376. struct list_head list;
  377. };
  378. struct btrfs_block_group_cache {
  379. struct btrfs_key key;
  380. struct btrfs_block_group_item item;
  381. struct btrfs_space_info *space_info;
  382. u64 pinned;
  383. u64 flags;
  384. int cached;
  385. };
  386. struct btrfs_device;
  387. struct btrfs_fs_devices;
  388. struct btrfs_fs_info {
  389. u8 fsid[BTRFS_FSID_SIZE];
  390. struct btrfs_root *extent_root;
  391. struct btrfs_root *tree_root;
  392. struct btrfs_root *chunk_root;
  393. struct btrfs_root *dev_root;
  394. struct radix_tree_root fs_roots_radix;
  395. struct extent_io_tree free_space_cache;
  396. struct extent_io_tree block_group_cache;
  397. struct extent_io_tree pinned_extents;
  398. struct extent_io_tree pending_del;
  399. struct extent_io_tree extent_ins;
  400. /* logical->physical extent mapping */
  401. struct btrfs_mapping_tree mapping_tree;
  402. u64 generation;
  403. u64 last_trans_committed;
  404. unsigned long mount_opt;
  405. u64 max_extent;
  406. u64 max_inline;
  407. u64 alloc_start;
  408. struct btrfs_transaction *running_transaction;
  409. struct btrfs_super_block super_copy;
  410. struct extent_buffer *sb_buffer;
  411. struct block_device *__bdev;
  412. struct super_block *sb;
  413. struct inode *btree_inode;
  414. struct backing_dev_info bdi;
  415. spinlock_t hash_lock;
  416. struct mutex trans_mutex;
  417. struct mutex fs_mutex;
  418. struct list_head trans_list;
  419. struct list_head hashers;
  420. struct list_head dead_roots;
  421. struct list_head end_io_work_list;
  422. struct work_struct end_io_work;
  423. spinlock_t end_io_work_lock;
  424. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
  425. struct work_struct trans_work;
  426. #else
  427. struct delayed_work trans_work;
  428. #endif
  429. struct kobject super_kobj;
  430. struct completion kobj_unregister;
  431. int do_barriers;
  432. int closing;
  433. unsigned long throttles;
  434. u64 total_pinned;
  435. struct list_head dirty_cowonly_roots;
  436. struct btrfs_fs_devices *fs_devices;
  437. struct list_head space_info;
  438. spinlock_t delalloc_lock;
  439. spinlock_t new_trans_lock;
  440. u64 delalloc_bytes;
  441. u64 last_alloc;
  442. u64 last_data_alloc;
  443. u64 avail_data_alloc_bits;
  444. u64 avail_metadata_alloc_bits;
  445. u64 avail_system_alloc_bits;
  446. u64 data_alloc_profile;
  447. u64 metadata_alloc_profile;
  448. u64 system_alloc_profile;
  449. };
  450. /*
  451. * in ram representation of the tree. extent_root is used for all allocations
  452. * and for the extent tree extent_root root.
  453. */
  454. struct btrfs_root {
  455. struct extent_buffer *node;
  456. struct extent_buffer *commit_root;
  457. struct btrfs_root_item root_item;
  458. struct btrfs_key root_key;
  459. struct btrfs_fs_info *fs_info;
  460. struct inode *inode;
  461. struct kobject root_kobj;
  462. struct completion kobj_unregister;
  463. u64 objectid;
  464. u64 last_trans;
  465. /* data allocations are done in sectorsize units */
  466. u32 sectorsize;
  467. /* node allocations are done in nodesize units */
  468. u32 nodesize;
  469. /* leaf allocations are done in leafsize units */
  470. u32 leafsize;
  471. u32 stripesize;
  472. u32 type;
  473. u64 highest_inode;
  474. u64 last_inode_alloc;
  475. int ref_cows;
  476. int track_dirty;
  477. struct btrfs_key defrag_progress;
  478. int defrag_running;
  479. int defrag_level;
  480. char *name;
  481. int in_sysfs;
  482. /* the dirty list is only used by non-reference counted roots */
  483. struct list_head dirty_list;
  484. };
  485. /*
  486. * inode items have the data typically returned from stat and store other
  487. * info about object characteristics. There is one for every file and dir in
  488. * the FS
  489. */
  490. #define BTRFS_INODE_ITEM_KEY 1
  491. #define BTRFS_INODE_REF_KEY 2
  492. #define BTRFS_XATTR_ITEM_KEY 8
  493. /* reserve 2-15 close to the inode for later flexibility */
  494. /*
  495. * dir items are the name -> inode pointers in a directory. There is one
  496. * for every name in a directory.
  497. */
  498. #define BTRFS_DIR_ITEM_KEY 16
  499. #define BTRFS_DIR_INDEX_KEY 17
  500. /*
  501. * extent data is for file data
  502. */
  503. #define BTRFS_EXTENT_DATA_KEY 18
  504. /*
  505. * csum items have the checksums for data in the extents
  506. */
  507. #define BTRFS_CSUM_ITEM_KEY 19
  508. /* reserve 20-31 for other file stuff */
  509. /*
  510. * root items point to tree roots. There are typically in the root
  511. * tree used by the super block to find all the other trees
  512. */
  513. #define BTRFS_ROOT_ITEM_KEY 32
  514. /*
  515. * extent items are in the extent map tree. These record which blocks
  516. * are used, and how many references there are to each block
  517. */
  518. #define BTRFS_EXTENT_ITEM_KEY 33
  519. #define BTRFS_EXTENT_REF_KEY 34
  520. /*
  521. * block groups give us hints into the extent allocation trees. Which
  522. * blocks are free etc etc
  523. */
  524. #define BTRFS_BLOCK_GROUP_ITEM_KEY 50
  525. #define BTRFS_DEV_EXTENT_KEY 75
  526. #define BTRFS_DEV_ITEM_KEY 76
  527. #define BTRFS_CHUNK_ITEM_KEY 77
  528. /*
  529. * string items are for debugging. They just store a short string of
  530. * data in the FS
  531. */
  532. #define BTRFS_STRING_ITEM_KEY 253
  533. #define BTRFS_MOUNT_NODATASUM (1 << 0)
  534. #define BTRFS_MOUNT_NODATACOW (1 << 1)
  535. #define BTRFS_MOUNT_NOBARRIER (1 << 2)
  536. #define BTRFS_MOUNT_SSD (1 << 3)
  537. #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
  538. #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
  539. #define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \
  540. BTRFS_MOUNT_##opt)
  541. /*
  542. * Inode flags
  543. */
  544. #define BTRFS_INODE_NODATASUM (1 << 0)
  545. #define BTRFS_INODE_NODATACOW (1 << 1)
  546. #define BTRFS_INODE_READONLY (1 << 2)
  547. #define btrfs_clear_flag(inode, flag) (BTRFS_I(inode)->flags &= \
  548. ~BTRFS_INODE_##flag)
  549. #define btrfs_set_flag(inode, flag) (BTRFS_I(inode)->flags |= \
  550. BTRFS_INODE_##flag)
  551. #define btrfs_test_flag(inode, flag) (BTRFS_I(inode)->flags & \
  552. BTRFS_INODE_##flag)
  553. /* some macros to generate set/get funcs for the struct fields. This
  554. * assumes there is a lefoo_to_cpu for every type, so lets make a simple
  555. * one for u8:
  556. */
  557. #define le8_to_cpu(v) (v)
  558. #define cpu_to_le8(v) (v)
  559. #define __le8 u8
  560. #define read_eb_member(eb, ptr, type, member, result) ( \
  561. read_extent_buffer(eb, (char *)(result), \
  562. ((unsigned long)(ptr)) + \
  563. offsetof(type, member), \
  564. sizeof(((type *)0)->member)))
  565. #define write_eb_member(eb, ptr, type, member, result) ( \
  566. write_extent_buffer(eb, (char *)(result), \
  567. ((unsigned long)(ptr)) + \
  568. offsetof(type, member), \
  569. sizeof(((type *)0)->member)))
  570. #ifndef BTRFS_SETGET_FUNCS
  571. #define BTRFS_SETGET_FUNCS(name, type, member, bits) \
  572. u##bits btrfs_##name(struct extent_buffer *eb, type *s); \
  573. void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val);
  574. #endif
  575. #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
  576. static inline u##bits btrfs_##name(struct extent_buffer *eb) \
  577. { \
  578. type *p = kmap_atomic(eb->first_page, KM_USER0); \
  579. u##bits res = le##bits##_to_cpu(p->member); \
  580. kunmap_atomic(p, KM_USER0); \
  581. return res; \
  582. } \
  583. static inline void btrfs_set_##name(struct extent_buffer *eb, \
  584. u##bits val) \
  585. { \
  586. type *p = kmap_atomic(eb->first_page, KM_USER0); \
  587. p->member = cpu_to_le##bits(val); \
  588. kunmap_atomic(p, KM_USER0); \
  589. }
  590. #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
  591. static inline u##bits btrfs_##name(type *s) \
  592. { \
  593. return le##bits##_to_cpu(s->member); \
  594. } \
  595. static inline void btrfs_set_##name(type *s, u##bits val) \
  596. { \
  597. s->member = cpu_to_le##bits(val); \
  598. }
  599. BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
  600. BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
  601. BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
  602. BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
  603. BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
  604. BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
  605. BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
  606. BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
  607. BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
  608. total_bytes, 64);
  609. BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
  610. bytes_used, 64);
  611. BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
  612. io_align, 32);
  613. BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
  614. io_width, 32);
  615. BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
  616. sector_size, 32);
  617. BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
  618. static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
  619. {
  620. return (char *)d + offsetof(struct btrfs_dev_item, uuid);
  621. }
  622. BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
  623. BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
  624. BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
  625. BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
  626. BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
  627. BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
  628. BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
  629. BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
  630. BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
  631. BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
  632. BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
  633. stripe_len, 64);
  634. BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
  635. io_align, 32);
  636. BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
  637. io_width, 32);
  638. BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
  639. sector_size, 32);
  640. BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
  641. BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
  642. num_stripes, 16);
  643. BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
  644. BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
  645. static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
  646. int nr)
  647. {
  648. unsigned long offset = (unsigned long)c;
  649. offset += offsetof(struct btrfs_chunk, stripe);
  650. offset += nr * sizeof(struct btrfs_stripe);
  651. return (struct btrfs_stripe *)offset;
  652. }
  653. static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
  654. struct btrfs_chunk *c, int nr)
  655. {
  656. return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
  657. }
  658. static inline void btrfs_set_stripe_offset_nr(struct extent_buffer *eb,
  659. struct btrfs_chunk *c, int nr,
  660. u64 val)
  661. {
  662. btrfs_set_stripe_offset(eb, btrfs_stripe_nr(c, nr), val);
  663. }
  664. static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
  665. struct btrfs_chunk *c, int nr)
  666. {
  667. return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
  668. }
  669. static inline void btrfs_set_stripe_devid_nr(struct extent_buffer *eb,
  670. struct btrfs_chunk *c, int nr,
  671. u64 val)
  672. {
  673. btrfs_set_stripe_devid(eb, btrfs_stripe_nr(c, nr), val);
  674. }
  675. /* struct btrfs_block_group_item */
  676. BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
  677. used, 64);
  678. BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
  679. used, 64);
  680. BTRFS_SETGET_STACK_FUNCS(block_group_chunk_tree, struct btrfs_block_group_item,
  681. chunk_tree, 64);
  682. BTRFS_SETGET_FUNCS(disk_block_group_chunk_tree, struct btrfs_block_group_item,
  683. chunk_tree, 64);
  684. BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
  685. struct btrfs_block_group_item, chunk_objectid, 64);
  686. BTRFS_SETGET_FUNCS(disk_block_group_chunk_objecitd,
  687. struct btrfs_block_group_item, chunk_objectid, 64);
  688. BTRFS_SETGET_FUNCS(disk_block_group_flags,
  689. struct btrfs_block_group_item, flags, 64);
  690. BTRFS_SETGET_STACK_FUNCS(block_group_flags,
  691. struct btrfs_block_group_item, flags, 64);
  692. /* struct btrfs_inode_ref */
  693. BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
  694. /* struct btrfs_inode_item */
  695. BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
  696. BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
  697. BTRFS_SETGET_FUNCS(inode_nblocks, struct btrfs_inode_item, nblocks, 64);
  698. BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
  699. BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
  700. BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
  701. BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
  702. BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
  703. BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
  704. BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 16);
  705. BTRFS_SETGET_FUNCS(inode_compat_flags, struct btrfs_inode_item,
  706. compat_flags, 16);
  707. static inline struct btrfs_timespec *
  708. btrfs_inode_atime(struct btrfs_inode_item *inode_item)
  709. {
  710. unsigned long ptr = (unsigned long)inode_item;
  711. ptr += offsetof(struct btrfs_inode_item, atime);
  712. return (struct btrfs_timespec *)ptr;
  713. }
  714. static inline struct btrfs_timespec *
  715. btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
  716. {
  717. unsigned long ptr = (unsigned long)inode_item;
  718. ptr += offsetof(struct btrfs_inode_item, mtime);
  719. return (struct btrfs_timespec *)ptr;
  720. }
  721. static inline struct btrfs_timespec *
  722. btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
  723. {
  724. unsigned long ptr = (unsigned long)inode_item;
  725. ptr += offsetof(struct btrfs_inode_item, ctime);
  726. return (struct btrfs_timespec *)ptr;
  727. }
  728. static inline struct btrfs_timespec *
  729. btrfs_inode_otime(struct btrfs_inode_item *inode_item)
  730. {
  731. unsigned long ptr = (unsigned long)inode_item;
  732. ptr += offsetof(struct btrfs_inode_item, otime);
  733. return (struct btrfs_timespec *)ptr;
  734. }
  735. BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
  736. BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
  737. /* struct btrfs_extent_item */
  738. BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 32);
  739. /* struct btrfs_dev_extent */
  740. BTRFS_SETGET_FUNCS(dev_extent_owner, struct btrfs_dev_extent, owner, 64);
  741. BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
  742. /* struct btrfs_extent_ref */
  743. BTRFS_SETGET_FUNCS(ref_root, struct btrfs_extent_ref, root, 64);
  744. BTRFS_SETGET_FUNCS(ref_generation, struct btrfs_extent_ref, generation, 64);
  745. BTRFS_SETGET_FUNCS(ref_objectid, struct btrfs_extent_ref, objectid, 64);
  746. BTRFS_SETGET_FUNCS(ref_offset, struct btrfs_extent_ref, offset, 64);
  747. BTRFS_SETGET_STACK_FUNCS(stack_ref_root, struct btrfs_extent_ref, root, 64);
  748. BTRFS_SETGET_STACK_FUNCS(stack_ref_generation, struct btrfs_extent_ref,
  749. generation, 64);
  750. BTRFS_SETGET_STACK_FUNCS(stack_ref_objectid, struct btrfs_extent_ref,
  751. objectid, 64);
  752. BTRFS_SETGET_STACK_FUNCS(stack_ref_offset, struct btrfs_extent_ref, offset, 64);
  753. BTRFS_SETGET_STACK_FUNCS(stack_extent_refs, struct btrfs_extent_item,
  754. refs, 32);
  755. /* struct btrfs_node */
  756. BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
  757. BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
  758. static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
  759. {
  760. unsigned long ptr;
  761. ptr = offsetof(struct btrfs_node, ptrs) +
  762. sizeof(struct btrfs_key_ptr) * nr;
  763. return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
  764. }
  765. static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
  766. int nr, u64 val)
  767. {
  768. unsigned long ptr;
  769. ptr = offsetof(struct btrfs_node, ptrs) +
  770. sizeof(struct btrfs_key_ptr) * nr;
  771. btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
  772. }
  773. static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
  774. {
  775. unsigned long ptr;
  776. ptr = offsetof(struct btrfs_node, ptrs) +
  777. sizeof(struct btrfs_key_ptr) * nr;
  778. return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
  779. }
  780. static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
  781. int nr, u64 val)
  782. {
  783. unsigned long ptr;
  784. ptr = offsetof(struct btrfs_node, ptrs) +
  785. sizeof(struct btrfs_key_ptr) * nr;
  786. btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
  787. }
  788. static inline unsigned long btrfs_node_key_ptr_offset(int nr)
  789. {
  790. return offsetof(struct btrfs_node, ptrs) +
  791. sizeof(struct btrfs_key_ptr) * nr;
  792. }
  793. void btrfs_node_key(struct extent_buffer *eb,
  794. struct btrfs_disk_key *disk_key, int nr);
  795. static inline void btrfs_set_node_key(struct extent_buffer *eb,
  796. struct btrfs_disk_key *disk_key, int nr)
  797. {
  798. unsigned long ptr;
  799. ptr = btrfs_node_key_ptr_offset(nr);
  800. write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
  801. struct btrfs_key_ptr, key, disk_key);
  802. }
  803. /* struct btrfs_item */
  804. BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
  805. BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
  806. static inline unsigned long btrfs_item_nr_offset(int nr)
  807. {
  808. return offsetof(struct btrfs_leaf, items) +
  809. sizeof(struct btrfs_item) * nr;
  810. }
  811. static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
  812. int nr)
  813. {
  814. return (struct btrfs_item *)btrfs_item_nr_offset(nr);
  815. }
  816. static inline u32 btrfs_item_end(struct extent_buffer *eb,
  817. struct btrfs_item *item)
  818. {
  819. return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
  820. }
  821. static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
  822. {
  823. return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
  824. }
  825. static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
  826. {
  827. return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
  828. }
  829. static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
  830. {
  831. return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
  832. }
  833. static inline void btrfs_item_key(struct extent_buffer *eb,
  834. struct btrfs_disk_key *disk_key, int nr)
  835. {
  836. struct btrfs_item *item = btrfs_item_nr(eb, nr);
  837. read_eb_member(eb, item, struct btrfs_item, key, disk_key);
  838. }
  839. static inline void btrfs_set_item_key(struct extent_buffer *eb,
  840. struct btrfs_disk_key *disk_key, int nr)
  841. {
  842. struct btrfs_item *item = btrfs_item_nr(eb, nr);
  843. write_eb_member(eb, item, struct btrfs_item, key, disk_key);
  844. }
  845. /* struct btrfs_dir_item */
  846. BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
  847. BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
  848. BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
  849. static inline void btrfs_dir_item_key(struct extent_buffer *eb,
  850. struct btrfs_dir_item *item,
  851. struct btrfs_disk_key *key)
  852. {
  853. read_eb_member(eb, item, struct btrfs_dir_item, location, key);
  854. }
  855. static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
  856. struct btrfs_dir_item *item,
  857. struct btrfs_disk_key *key)
  858. {
  859. write_eb_member(eb, item, struct btrfs_dir_item, location, key);
  860. }
  861. /* struct btrfs_disk_key */
  862. BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
  863. objectid, 64);
  864. BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
  865. BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
  866. static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
  867. struct btrfs_disk_key *disk)
  868. {
  869. cpu->offset = le64_to_cpu(disk->offset);
  870. cpu->type = disk->type;
  871. cpu->objectid = le64_to_cpu(disk->objectid);
  872. }
  873. static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
  874. struct btrfs_key *cpu)
  875. {
  876. disk->offset = cpu_to_le64(cpu->offset);
  877. disk->type = cpu->type;
  878. disk->objectid = cpu_to_le64(cpu->objectid);
  879. }
  880. static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
  881. struct btrfs_key *key, int nr)
  882. {
  883. struct btrfs_disk_key disk_key;
  884. btrfs_node_key(eb, &disk_key, nr);
  885. btrfs_disk_key_to_cpu(key, &disk_key);
  886. }
  887. static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
  888. struct btrfs_key *key, int nr)
  889. {
  890. struct btrfs_disk_key disk_key;
  891. btrfs_item_key(eb, &disk_key, nr);
  892. btrfs_disk_key_to_cpu(key, &disk_key);
  893. }
  894. static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
  895. struct btrfs_dir_item *item,
  896. struct btrfs_key *key)
  897. {
  898. struct btrfs_disk_key disk_key;
  899. btrfs_dir_item_key(eb, item, &disk_key);
  900. btrfs_disk_key_to_cpu(key, &disk_key);
  901. }
  902. static inline u8 btrfs_key_type(struct btrfs_key *key)
  903. {
  904. return key->type;
  905. }
  906. static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
  907. {
  908. key->type = val;
  909. }
  910. /* struct btrfs_header */
  911. BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
  912. BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
  913. generation, 64);
  914. BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
  915. BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
  916. BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
  917. BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
  918. static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
  919. {
  920. return (btrfs_header_flags(eb) & flag) == flag;
  921. }
  922. static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
  923. {
  924. u64 flags = btrfs_header_flags(eb);
  925. btrfs_set_header_flags(eb, flags | flag);
  926. return (flags & flag) == flag;
  927. }
  928. static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
  929. {
  930. u64 flags = btrfs_header_flags(eb);
  931. btrfs_set_header_flags(eb, flags & ~flag);
  932. return (flags & flag) == flag;
  933. }
  934. static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
  935. {
  936. unsigned long ptr = offsetof(struct btrfs_header, fsid);
  937. return (u8 *)ptr;
  938. }
  939. static inline u8 *btrfs_super_fsid(struct extent_buffer *eb)
  940. {
  941. unsigned long ptr = offsetof(struct btrfs_super_block, fsid);
  942. return (u8 *)ptr;
  943. }
  944. static inline u8 *btrfs_header_csum(struct extent_buffer *eb)
  945. {
  946. unsigned long ptr = offsetof(struct btrfs_header, csum);
  947. return (u8 *)ptr;
  948. }
  949. static inline struct btrfs_node *btrfs_buffer_node(struct extent_buffer *eb)
  950. {
  951. return NULL;
  952. }
  953. static inline struct btrfs_leaf *btrfs_buffer_leaf(struct extent_buffer *eb)
  954. {
  955. return NULL;
  956. }
  957. static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb)
  958. {
  959. return NULL;
  960. }
  961. static inline int btrfs_is_leaf(struct extent_buffer *eb)
  962. {
  963. return (btrfs_header_level(eb) == 0);
  964. }
  965. /* struct btrfs_root_item */
  966. BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
  967. BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
  968. BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
  969. BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
  970. BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
  971. BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
  972. BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
  973. BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 32);
  974. BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
  975. BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
  976. /* struct btrfs_super_block */
  977. BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
  978. BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
  979. generation, 64);
  980. BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
  981. BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
  982. struct btrfs_super_block, sys_chunk_array_size, 32);
  983. BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
  984. root_level, 8);
  985. BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
  986. chunk_root, 64);
  987. BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
  988. chunk_root_level, 64);
  989. BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
  990. total_bytes, 64);
  991. BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
  992. bytes_used, 64);
  993. BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
  994. sectorsize, 32);
  995. BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
  996. nodesize, 32);
  997. BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
  998. leafsize, 32);
  999. BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
  1000. stripesize, 32);
  1001. BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
  1002. root_dir_objectid, 64);
  1003. BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
  1004. num_devices, 64);
  1005. static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
  1006. {
  1007. return offsetof(struct btrfs_leaf, items);
  1008. }
  1009. /* struct btrfs_file_extent_item */
  1010. BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
  1011. static inline unsigned long btrfs_file_extent_inline_start(struct
  1012. btrfs_file_extent_item *e)
  1013. {
  1014. unsigned long offset = (unsigned long)e;
  1015. offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
  1016. return offset;
  1017. }
  1018. static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
  1019. {
  1020. return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
  1021. }
  1022. static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
  1023. struct btrfs_item *e)
  1024. {
  1025. unsigned long offset;
  1026. offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
  1027. return btrfs_item_size(eb, e) - offset;
  1028. }
  1029. BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
  1030. disk_bytenr, 64);
  1031. BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
  1032. generation, 64);
  1033. BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
  1034. disk_num_bytes, 64);
  1035. BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
  1036. offset, 64);
  1037. BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
  1038. num_bytes, 64);
  1039. static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
  1040. {
  1041. return sb->s_fs_info;
  1042. }
  1043. static inline int btrfs_set_root_name(struct btrfs_root *root,
  1044. const char *name, int len)
  1045. {
  1046. /* if we already have a name just free it */
  1047. if (root->name)
  1048. kfree(root->name);
  1049. root->name = kmalloc(len+1, GFP_KERNEL);
  1050. if (!root->name)
  1051. return -ENOMEM;
  1052. memcpy(root->name, name, len);
  1053. root->name[len] ='\0';
  1054. return 0;
  1055. }
  1056. static inline u32 btrfs_level_size(struct btrfs_root *root, int level) {
  1057. if (level == 0)
  1058. return root->leafsize;
  1059. return root->nodesize;
  1060. }
  1061. /* helper function to cast into the data area of the leaf. */
  1062. #define btrfs_item_ptr(leaf, slot, type) \
  1063. ((type *)(btrfs_leaf_data(leaf) + \
  1064. btrfs_item_offset_nr(leaf, slot)))
  1065. #define btrfs_item_ptr_offset(leaf, slot) \
  1066. ((unsigned long)(btrfs_leaf_data(leaf) + \
  1067. btrfs_item_offset_nr(leaf, slot)))
  1068. static inline struct dentry *fdentry(struct file *file) {
  1069. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
  1070. return file->f_dentry;
  1071. #else
  1072. return file->f_path.dentry;
  1073. #endif
  1074. }
  1075. /* extent-tree.c */
  1076. u32 btrfs_count_snapshots_in_path(struct btrfs_root *root,
  1077. struct btrfs_path *count_path,
  1078. u64 first_extent);
  1079. int btrfs_extent_post_op(struct btrfs_trans_handle *trans,
  1080. struct btrfs_root *root);
  1081. int btrfs_copy_pinned(struct btrfs_root *root, struct extent_io_tree *copy);
  1082. struct btrfs_block_group_cache *btrfs_lookup_block_group(struct
  1083. btrfs_fs_info *info,
  1084. u64 bytenr);
  1085. struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root,
  1086. struct btrfs_block_group_cache
  1087. *hint, u64 search_start,
  1088. int data, int owner);
  1089. int btrfs_inc_root_ref(struct btrfs_trans_handle *trans,
  1090. struct btrfs_root *root, u64 owner_objectid);
  1091. struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
  1092. struct btrfs_root *root, u32 size,
  1093. u64 root_objectid,
  1094. u64 hint, u64 empty_size);
  1095. struct extent_buffer *__btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
  1096. struct btrfs_root *root,
  1097. u32 blocksize,
  1098. u64 root_objectid,
  1099. u64 ref_generation,
  1100. u64 first_objectid,
  1101. int level,
  1102. u64 hint,
  1103. u64 empty_size);
  1104. int btrfs_grow_extent_tree(struct btrfs_trans_handle *trans,
  1105. struct btrfs_root *root, u64 new_size);
  1106. int btrfs_shrink_extent_tree(struct btrfs_root *root, u64 new_size);
  1107. int btrfs_insert_extent_backref(struct btrfs_trans_handle *trans,
  1108. struct btrfs_root *root,
  1109. struct btrfs_path *path, u64 bytenr,
  1110. u64 root_objectid, u64 ref_generation,
  1111. u64 owner, u64 owner_offset);
  1112. int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
  1113. struct btrfs_root *root,
  1114. u64 num_bytes, u64 min_bytes,
  1115. u64 root_objectid, u64 ref_generation,
  1116. u64 owner, u64 owner_offset,
  1117. u64 empty_size, u64 hint_byte,
  1118. u64 search_end, struct btrfs_key *ins, int data);
  1119. int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  1120. struct extent_buffer *buf);
  1121. int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
  1122. *root, u64 bytenr, u64 num_bytes,
  1123. u64 root_objectid, u64 ref_generation,
  1124. u64 owner_objectid, u64 owner_offset, int pin);
  1125. int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
  1126. struct btrfs_root *root,
  1127. struct extent_io_tree *unpin);
  1128. int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
  1129. struct btrfs_root *root,
  1130. u64 bytenr, u64 num_bytes,
  1131. u64 root_objectid, u64 ref_generation,
  1132. u64 owner, u64 owner_offset);
  1133. int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
  1134. struct btrfs_root *root);
  1135. int btrfs_free_block_groups(struct btrfs_fs_info *info);
  1136. int btrfs_read_block_groups(struct btrfs_root *root);
  1137. int btrfs_make_block_group(struct btrfs_trans_handle *trans,
  1138. struct btrfs_root *root, u64 bytes_used,
  1139. u64 type, u64 chunk_tree, u64 chunk_objectid,
  1140. u64 size);
  1141. /* ctree.c */
  1142. int btrfs_previous_item(struct btrfs_root *root,
  1143. struct btrfs_path *path, u64 min_objectid,
  1144. int type);
  1145. int btrfs_cow_block(struct btrfs_trans_handle *trans,
  1146. struct btrfs_root *root, struct extent_buffer *buf,
  1147. struct extent_buffer *parent, int parent_slot,
  1148. struct extent_buffer **cow_ret);
  1149. int btrfs_copy_root(struct btrfs_trans_handle *trans,
  1150. struct btrfs_root *root,
  1151. struct extent_buffer *buf,
  1152. struct extent_buffer **cow_ret, u64 new_root_objectid);
  1153. int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
  1154. *root, struct btrfs_path *path, u32 data_size);
  1155. int btrfs_truncate_item(struct btrfs_trans_handle *trans,
  1156. struct btrfs_root *root,
  1157. struct btrfs_path *path,
  1158. u32 new_size, int from_end);
  1159. int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
  1160. *root, struct btrfs_key *key, struct btrfs_path *p, int
  1161. ins_len, int cow);
  1162. int btrfs_realloc_node(struct btrfs_trans_handle *trans,
  1163. struct btrfs_root *root, struct extent_buffer *parent,
  1164. int start_slot, int cache_only, u64 *last_ret,
  1165. struct btrfs_key *progress);
  1166. void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
  1167. struct btrfs_path *btrfs_alloc_path(void);
  1168. void btrfs_free_path(struct btrfs_path *p);
  1169. void btrfs_init_path(struct btrfs_path *p);
  1170. int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  1171. struct btrfs_path *path, int slot, int nr);
  1172. static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
  1173. struct btrfs_root *root,
  1174. struct btrfs_path *path)
  1175. {
  1176. return btrfs_del_items(trans, root, path, path->slots[0], 1);
  1177. }
  1178. int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
  1179. *root, struct btrfs_key *key, void *data, u32 data_size);
  1180. int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
  1181. struct btrfs_root *root,
  1182. struct btrfs_path *path,
  1183. struct btrfs_key *cpu_key, u32 *data_size, int nr);
  1184. static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
  1185. struct btrfs_root *root,
  1186. struct btrfs_path *path,
  1187. struct btrfs_key *key,
  1188. u32 data_size)
  1189. {
  1190. return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
  1191. }
  1192. int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
  1193. int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
  1194. int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
  1195. int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
  1196. *root);
  1197. /* root-item.c */
  1198. int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  1199. struct btrfs_key *key);
  1200. int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
  1201. *root, struct btrfs_key *key, struct btrfs_root_item
  1202. *item);
  1203. int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
  1204. *root, struct btrfs_key *key, struct btrfs_root_item
  1205. *item);
  1206. int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
  1207. btrfs_root_item *item, struct btrfs_key *key);
  1208. int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid,
  1209. struct btrfs_root *latest_root);
  1210. /* dir-item.c */
  1211. int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
  1212. *root, const char *name, int name_len, u64 dir,
  1213. struct btrfs_key *location, u8 type);
  1214. struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
  1215. struct btrfs_root *root,
  1216. struct btrfs_path *path, u64 dir,
  1217. const char *name, int name_len,
  1218. int mod);
  1219. struct btrfs_dir_item *
  1220. btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
  1221. struct btrfs_root *root,
  1222. struct btrfs_path *path, u64 dir,
  1223. u64 objectid, const char *name, int name_len,
  1224. int mod);
  1225. struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
  1226. struct btrfs_path *path,
  1227. const char *name, int name_len);
  1228. int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
  1229. struct btrfs_root *root,
  1230. struct btrfs_path *path,
  1231. struct btrfs_dir_item *di);
  1232. int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
  1233. struct btrfs_root *root, const char *name,
  1234. u16 name_len, const void *data, u16 data_len,
  1235. u64 dir);
  1236. struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
  1237. struct btrfs_root *root,
  1238. struct btrfs_path *path, u64 dir,
  1239. const char *name, u16 name_len,
  1240. int mod);
  1241. /* inode-map.c */
  1242. int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
  1243. struct btrfs_root *fs_root,
  1244. u64 dirid, u64 *objectid);
  1245. int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid);
  1246. /* inode-item.c */
  1247. int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
  1248. struct btrfs_root *root,
  1249. const char *name, int name_len,
  1250. u64 inode_objectid, u64 ref_objectid);
  1251. int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
  1252. struct btrfs_root *root,
  1253. const char *name, int name_len,
  1254. u64 inode_objectid, u64 ref_objectid);
  1255. int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
  1256. struct btrfs_root *root,
  1257. struct btrfs_path *path, u64 objectid);
  1258. int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
  1259. *root, struct btrfs_path *path,
  1260. struct btrfs_key *location, int mod);
  1261. /* file-item.c */
  1262. int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
  1263. struct btrfs_root *root,
  1264. u64 objectid, u64 pos, u64 offset,
  1265. u64 disk_num_bytes,
  1266. u64 num_bytes);
  1267. int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
  1268. struct btrfs_root *root,
  1269. struct btrfs_path *path, u64 objectid,
  1270. u64 bytenr, int mod);
  1271. int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
  1272. struct btrfs_root *root, struct inode *inode,
  1273. struct bio *bio);
  1274. struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
  1275. struct btrfs_root *root,
  1276. struct btrfs_path *path,
  1277. u64 objectid, u64 offset,
  1278. int cow);
  1279. int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
  1280. struct btrfs_root *root, struct btrfs_path *path,
  1281. u64 isize);
  1282. /* inode.c */
  1283. int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
  1284. size_t size, struct bio *bio);
  1285. static inline void dec_i_blocks(struct inode *inode, u64 dec)
  1286. {
  1287. dec = dec >> 9;
  1288. if (dec <= inode->i_blocks)
  1289. inode->i_blocks -= dec;
  1290. else
  1291. inode->i_blocks = 0;
  1292. }
  1293. unsigned long btrfs_force_ra(struct address_space *mapping,
  1294. struct file_ra_state *ra, struct file *file,
  1295. pgoff_t offset, pgoff_t last_index);
  1296. int btrfs_check_free_space(struct btrfs_root *root, u64 num_required,
  1297. int for_del);
  1298. int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page);
  1299. int btrfs_readpage(struct file *file, struct page *page);
  1300. void btrfs_delete_inode(struct inode *inode);
  1301. void btrfs_put_inode(struct inode *inode);
  1302. void btrfs_read_locked_inode(struct inode *inode);
  1303. int btrfs_write_inode(struct inode *inode, int wait);
  1304. void btrfs_dirty_inode(struct inode *inode);
  1305. struct inode *btrfs_alloc_inode(struct super_block *sb);
  1306. void btrfs_destroy_inode(struct inode *inode);
  1307. int btrfs_init_cachep(void);
  1308. void btrfs_destroy_cachep(void);
  1309. long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
  1310. struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
  1311. struct btrfs_root *root);
  1312. struct inode *btrfs_ilookup(struct super_block *s, u64 objectid,
  1313. u64 root_objectid);
  1314. int btrfs_commit_write(struct file *file, struct page *page,
  1315. unsigned from, unsigned to);
  1316. struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
  1317. size_t page_offset, u64 start, u64 end,
  1318. int create);
  1319. int btrfs_update_inode(struct btrfs_trans_handle *trans,
  1320. struct btrfs_root *root,
  1321. struct inode *inode);
  1322. /* file.c */
  1323. int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end);
  1324. int btrfs_check_file(struct btrfs_root *root, struct inode *inode);
  1325. extern struct file_operations btrfs_file_operations;
  1326. int btrfs_drop_extents(struct btrfs_trans_handle *trans,
  1327. struct btrfs_root *root, struct inode *inode,
  1328. u64 start, u64 end, u64 inline_limit, u64 *hint_block);
  1329. /* tree-defrag.c */
  1330. int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
  1331. struct btrfs_root *root, int cache_only);
  1332. /* sysfs.c */
  1333. int btrfs_init_sysfs(void);
  1334. void btrfs_exit_sysfs(void);
  1335. int btrfs_sysfs_add_super(struct btrfs_fs_info *fs);
  1336. int btrfs_sysfs_add_root(struct btrfs_root *root);
  1337. void btrfs_sysfs_del_root(struct btrfs_root *root);
  1338. void btrfs_sysfs_del_super(struct btrfs_fs_info *root);
  1339. /* xattr.c */
  1340. ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
  1341. int btrfs_delete_xattrs(struct btrfs_trans_handle *trans,
  1342. struct btrfs_root *root, struct inode *inode);
  1343. /* super.c */
  1344. u64 btrfs_parse_size(char *str);
  1345. #endif