ctree.h 55 KB

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