ctree.h 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121
  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__
  19. #define __BTRFS__
  20. #include <linux/fs.h>
  21. #include <linux/workqueue.h>
  22. #include <linux/completion.h>
  23. #include <asm/kmap_types.h>
  24. #include "bit-radix.h"
  25. #include "extent_map.h"
  26. struct btrfs_trans_handle;
  27. struct btrfs_transaction;
  28. extern struct kmem_cache *btrfs_trans_handle_cachep;
  29. extern struct kmem_cache *btrfs_transaction_cachep;
  30. extern struct kmem_cache *btrfs_bit_radix_cachep;
  31. extern struct kmem_cache *btrfs_path_cachep;
  32. #define BTRFS_MAGIC "_B2RfS_M"
  33. #define BTRFS_ROOT_TREE_OBJECTID 1ULL
  34. #define BTRFS_EXTENT_TREE_OBJECTID 2ULL
  35. #define BTRFS_FS_TREE_OBJECTID 3ULL
  36. #define BTRFS_ROOT_TREE_DIR_OBJECTID 4ULL
  37. #define BTRFS_FIRST_FREE_OBJECTID 5ULL
  38. /*
  39. * we can actually store much bigger names, but lets not confuse the rest
  40. * of linux
  41. */
  42. #define BTRFS_NAME_LEN 255
  43. /* 32 bytes in various csum fields */
  44. #define BTRFS_CSUM_SIZE 32
  45. /* four bytes for CRC32 */
  46. #define BTRFS_CRC32_SIZE 4
  47. #define BTRFS_EMPTY_DIR_SIZE 6
  48. #define BTRFS_FT_UNKNOWN 0
  49. #define BTRFS_FT_REG_FILE 1
  50. #define BTRFS_FT_DIR 2
  51. #define BTRFS_FT_CHRDEV 3
  52. #define BTRFS_FT_BLKDEV 4
  53. #define BTRFS_FT_FIFO 5
  54. #define BTRFS_FT_SOCK 6
  55. #define BTRFS_FT_SYMLINK 7
  56. #define BTRFS_FT_MAX 8
  57. /*
  58. * the key defines the order in the tree, and so it also defines (optimal)
  59. * block layout. objectid corresonds to the inode number. The flags
  60. * tells us things about the object, and is a kind of stream selector.
  61. * so for a given inode, keys with flags of 1 might refer to the inode
  62. * data, flags of 2 may point to file data in the btree and flags == 3
  63. * may point to extents.
  64. *
  65. * offset is the starting byte offset for this key in the stream.
  66. *
  67. * btrfs_disk_key is in disk byte order. struct btrfs_key is always
  68. * in cpu native order. Otherwise they are identical and their sizes
  69. * should be the same (ie both packed)
  70. */
  71. struct btrfs_disk_key {
  72. __le64 objectid;
  73. u8 type;
  74. __le64 offset;
  75. } __attribute__ ((__packed__));
  76. struct btrfs_key {
  77. u64 objectid;
  78. u8 type;
  79. u64 offset;
  80. } __attribute__ ((__packed__));
  81. #define BTRFS_FSID_SIZE 16
  82. /*
  83. * every tree block (leaf or node) starts with this header.
  84. */
  85. struct btrfs_header {
  86. u8 csum[BTRFS_CSUM_SIZE];
  87. u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
  88. __le64 bytenr; /* which block this node is supposed to live in */
  89. __le64 generation;
  90. __le64 owner;
  91. __le32 nritems;
  92. __le16 flags;
  93. u8 level;
  94. } __attribute__ ((__packed__));
  95. #define BTRFS_MAX_LEVEL 8
  96. #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
  97. sizeof(struct btrfs_header)) / \
  98. (sizeof(struct btrfs_disk_key) + sizeof(u64)))
  99. #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
  100. #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
  101. #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
  102. sizeof(struct btrfs_item) - \
  103. sizeof(struct btrfs_file_extent_item))
  104. /*
  105. * the super block basically lists the main trees of the FS
  106. * it currently lacks any block count etc etc
  107. */
  108. struct btrfs_super_block {
  109. u8 csum[BTRFS_CSUM_SIZE];
  110. /* the first 3 fields must match struct btrfs_header */
  111. u8 fsid[16]; /* FS specific uuid */
  112. __le64 bytenr; /* this block number */
  113. __le64 magic;
  114. __le64 generation;
  115. __le64 root;
  116. __le64 total_bytes;
  117. __le64 bytes_used;
  118. __le64 root_dir_objectid;
  119. __le32 sectorsize;
  120. __le32 nodesize;
  121. __le32 leafsize;
  122. u8 root_level;
  123. } __attribute__ ((__packed__));
  124. /*
  125. * A leaf is full of items. offset and size tell us where to find
  126. * the item in the leaf (relative to the start of the data area)
  127. */
  128. struct btrfs_item {
  129. struct btrfs_disk_key key;
  130. __le32 offset;
  131. __le32 size;
  132. } __attribute__ ((__packed__));
  133. /*
  134. * leaves have an item area and a data area:
  135. * [item0, item1....itemN] [free space] [dataN...data1, data0]
  136. *
  137. * The data is separate from the items to get the keys closer together
  138. * during searches.
  139. */
  140. struct btrfs_leaf {
  141. struct btrfs_header header;
  142. struct btrfs_item items[];
  143. } __attribute__ ((__packed__));
  144. /*
  145. * all non-leaf blocks are nodes, they hold only keys and pointers to
  146. * other blocks
  147. */
  148. struct btrfs_key_ptr {
  149. struct btrfs_disk_key key;
  150. __le64 blockptr;
  151. } __attribute__ ((__packed__));
  152. struct btrfs_node {
  153. struct btrfs_header header;
  154. struct btrfs_key_ptr ptrs[];
  155. } __attribute__ ((__packed__));
  156. /*
  157. * btrfs_paths remember the path taken from the root down to the leaf.
  158. * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
  159. * to any other levels that are present.
  160. *
  161. * The slots array records the index of the item or block pointer
  162. * used while walking the tree.
  163. */
  164. struct btrfs_path {
  165. struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
  166. int slots[BTRFS_MAX_LEVEL];
  167. int reada;
  168. int lowest_level;
  169. };
  170. /*
  171. * items in the extent btree are used to record the objectid of the
  172. * owner of the block and the number of references
  173. */
  174. struct btrfs_extent_item {
  175. __le32 refs;
  176. __le64 owner;
  177. } __attribute__ ((__packed__));
  178. struct btrfs_inode_timespec {
  179. __le64 sec;
  180. __le32 nsec;
  181. } __attribute__ ((__packed__));
  182. /*
  183. * there is no padding here on purpose. If you want to extent the inode,
  184. * make a new item type
  185. */
  186. struct btrfs_inode_item {
  187. __le64 generation;
  188. __le64 size;
  189. __le64 nblocks;
  190. __le64 block_group;
  191. __le32 nlink;
  192. __le32 uid;
  193. __le32 gid;
  194. __le32 mode;
  195. __le32 rdev;
  196. __le16 flags;
  197. __le16 compat_flags;
  198. struct btrfs_inode_timespec atime;
  199. struct btrfs_inode_timespec ctime;
  200. struct btrfs_inode_timespec mtime;
  201. struct btrfs_inode_timespec otime;
  202. } __attribute__ ((__packed__));
  203. struct btrfs_dir_item {
  204. struct btrfs_disk_key location;
  205. __le16 flags;
  206. __le16 name_len;
  207. u8 type;
  208. } __attribute__ ((__packed__));
  209. struct btrfs_root_item {
  210. struct btrfs_inode_item inode;
  211. __le64 root_dirid;
  212. __le64 bytenr;
  213. __le64 byte_limit;
  214. __le64 bytes_used;
  215. __le32 flags;
  216. __le32 refs;
  217. struct btrfs_disk_key drop_progress;
  218. u8 drop_level;
  219. u8 level;
  220. } __attribute__ ((__packed__));
  221. #define BTRFS_FILE_EXTENT_REG 0
  222. #define BTRFS_FILE_EXTENT_INLINE 1
  223. struct btrfs_file_extent_item {
  224. __le64 generation;
  225. u8 type;
  226. /*
  227. * disk space consumed by the extent, checksum blocks are included
  228. * in these numbers
  229. */
  230. __le64 disk_bytenr;
  231. __le64 disk_num_bytes;
  232. /*
  233. * the logical offset in file blocks (no csums)
  234. * this extent record is for. This allows a file extent to point
  235. * into the middle of an existing extent on disk, sharing it
  236. * between two snapshots (useful if some bytes in the middle of the
  237. * extent have changed
  238. */
  239. __le64 offset;
  240. /*
  241. * the logical number of file blocks (no csums included)
  242. */
  243. __le64 num_bytes;
  244. } __attribute__ ((__packed__));
  245. struct btrfs_csum_item {
  246. u8 csum;
  247. } __attribute__ ((__packed__));
  248. /* tag for the radix tree of block groups in ram */
  249. #define BTRFS_BLOCK_GROUP_SIZE (256 * 1024 * 1024)
  250. #define BTRFS_BLOCK_GROUP_DATA 1
  251. struct btrfs_block_group_item {
  252. __le64 used;
  253. u8 flags;
  254. } __attribute__ ((__packed__));
  255. struct btrfs_block_group_cache {
  256. struct btrfs_key key;
  257. struct btrfs_block_group_item item;
  258. int data;
  259. int cached;
  260. };
  261. struct btrfs_fs_info {
  262. u8 fsid[BTRFS_FSID_SIZE];
  263. struct btrfs_root *extent_root;
  264. struct btrfs_root *tree_root;
  265. struct radix_tree_root fs_roots_radix;
  266. struct extent_map_tree free_space_cache;
  267. struct extent_map_tree block_group_cache;
  268. struct extent_map_tree pinned_extents;
  269. struct extent_map_tree pending_del;
  270. struct extent_map_tree extent_ins;
  271. u64 generation;
  272. u64 last_trans_committed;
  273. struct btrfs_transaction *running_transaction;
  274. struct btrfs_super_block super_copy;
  275. struct extent_buffer *sb_buffer;
  276. struct super_block *sb;
  277. struct inode *btree_inode;
  278. struct mutex trans_mutex;
  279. struct mutex fs_mutex;
  280. struct list_head trans_list;
  281. struct list_head dead_roots;
  282. struct delayed_work trans_work;
  283. struct kobject super_kobj;
  284. struct completion kobj_unregister;
  285. int do_barriers;
  286. int closing;
  287. };
  288. /*
  289. * in ram representation of the tree. extent_root is used for all allocations
  290. * and for the extent tree extent_root root.
  291. */
  292. struct btrfs_root {
  293. struct extent_buffer *node;
  294. struct extent_buffer *commit_root;
  295. struct btrfs_root_item root_item;
  296. struct btrfs_key root_key;
  297. struct btrfs_fs_info *fs_info;
  298. struct inode *inode;
  299. struct kobject root_kobj;
  300. struct completion kobj_unregister;
  301. struct rw_semaphore snap_sem;
  302. u64 objectid;
  303. u64 last_trans;
  304. /* data allocations are done in sectorsize units */
  305. u32 sectorsize;
  306. /* node allocations are done in nodesize units */
  307. u32 nodesize;
  308. /* leaf allocations are done in leafsize units */
  309. u32 leafsize;
  310. u32 type;
  311. u64 highest_inode;
  312. u64 last_inode_alloc;
  313. int ref_cows;
  314. struct btrfs_key defrag_progress;
  315. int defrag_running;
  316. int defrag_level;
  317. char *name;
  318. };
  319. /*
  320. * inode items have the data typically returned from stat and store other
  321. * info about object characteristics. There is one for every file and dir in
  322. * the FS
  323. */
  324. #define BTRFS_INODE_ITEM_KEY 1
  325. /* reserve 2-15 close to the inode for later flexibility */
  326. /*
  327. * dir items are the name -> inode pointers in a directory. There is one
  328. * for every name in a directory.
  329. */
  330. #define BTRFS_DIR_ITEM_KEY 16
  331. #define BTRFS_DIR_INDEX_KEY 17
  332. /*
  333. * extent data is for file data
  334. */
  335. #define BTRFS_EXTENT_DATA_KEY 18
  336. /*
  337. * csum items have the checksums for data in the extents
  338. */
  339. #define BTRFS_CSUM_ITEM_KEY 19
  340. /* reserve 20-31 for other file stuff */
  341. /*
  342. * root items point to tree roots. There are typically in the root
  343. * tree used by the super block to find all the other trees
  344. */
  345. #define BTRFS_ROOT_ITEM_KEY 32
  346. /*
  347. * extent items are in the extent map tree. These record which blocks
  348. * are used, and how many references there are to each block
  349. */
  350. #define BTRFS_EXTENT_ITEM_KEY 33
  351. /*
  352. * block groups give us hints into the extent allocation trees. Which
  353. * blocks are free etc etc
  354. */
  355. #define BTRFS_BLOCK_GROUP_ITEM_KEY 34
  356. /*
  357. * string items are for debugging. They just store a short string of
  358. * data in the FS
  359. */
  360. #define BTRFS_STRING_ITEM_KEY 253
  361. /* some macros to generate set/get funcs for the struct fields. This
  362. * assumes there is a lefoo_to_cpu for every type, so lets make a simple
  363. * one for u8:
  364. */
  365. #define le8_to_cpu(v) (v)
  366. #define cpu_to_le8(v) (v)
  367. #define __le8 u8
  368. #define read_eb_member(eb, ptr, type, member, result) ( \
  369. read_extent_buffer(eb, (char *)(result), \
  370. ((unsigned long)(ptr)) + \
  371. offsetof(type, member), \
  372. sizeof(((type *)0)->member)))
  373. #define write_eb_member(eb, ptr, type, member, result) ( \
  374. write_extent_buffer(eb, (char *)(result), \
  375. ((unsigned long)(ptr)) + \
  376. offsetof(type, member), \
  377. sizeof(((type *)0)->member)))
  378. #define BTRFS_SETGET_FUNCS(name, type, member, bits) \
  379. static inline u##bits btrfs_##name(struct extent_buffer *eb, \
  380. type *s) \
  381. { \
  382. int err; \
  383. char *map_token; \
  384. char *kaddr; \
  385. int unmap_on_exit = (eb->map_token == NULL); \
  386. unsigned long map_start; \
  387. unsigned long map_len; \
  388. unsigned long offset = (unsigned long)s + \
  389. offsetof(type, member); \
  390. err = map_extent_buffer(eb, offset, \
  391. sizeof(((type *)0)->member), \
  392. &map_token, &kaddr, \
  393. &map_start, &map_len, KM_USER1); \
  394. if (!err) { \
  395. __le##bits *tmp = (__le##bits *)(kaddr + offset - \
  396. map_start); \
  397. u##bits res = le##bits##_to_cpu(*tmp); \
  398. if (unmap_on_exit) \
  399. unmap_extent_buffer(eb, map_token, KM_USER1); \
  400. return res; \
  401. } else { \
  402. __le##bits res; \
  403. read_eb_member(eb, s, type, member, &res); \
  404. return le##bits##_to_cpu(res); \
  405. } \
  406. } \
  407. static inline void btrfs_set_##name(struct extent_buffer *eb, \
  408. type *s, u##bits val) \
  409. { \
  410. int err; \
  411. char *map_token; \
  412. char *kaddr; \
  413. unsigned long map_start; \
  414. unsigned long map_len; \
  415. int unmap_on_exit = (eb->map_token == NULL); \
  416. unsigned long offset = (unsigned long)s + \
  417. offsetof(type, member); \
  418. err = map_extent_buffer(eb, offset, \
  419. sizeof(((type *)0)->member), \
  420. &map_token, &kaddr, \
  421. &map_start, &map_len, KM_USER1); \
  422. if (!err) { \
  423. __le##bits *tmp = (__le##bits *)(kaddr + offset - \
  424. map_start); \
  425. *tmp = cpu_to_le##bits(val); \
  426. if (unmap_on_exit) \
  427. unmap_extent_buffer(eb, map_token, KM_USER1); \
  428. } else { \
  429. val = cpu_to_le##bits(val); \
  430. write_eb_member(eb, s, type, member, &val); \
  431. } \
  432. }
  433. #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
  434. static inline u##bits btrfs_##name(struct extent_buffer *eb) \
  435. { \
  436. int err; \
  437. char *map_token; \
  438. char *kaddr; \
  439. unsigned long map_start; \
  440. unsigned long map_len; \
  441. unsigned long offset = offsetof(type, member); \
  442. int unmap_on_exit = (eb->map_token == NULL); \
  443. err = map_extent_buffer(eb, offset, \
  444. sizeof(((type *)0)->member), \
  445. &map_token, &kaddr, \
  446. &map_start, &map_len, KM_USER1); \
  447. if (!err) { \
  448. __le##bits *tmp = (__le##bits *)(kaddr + offset - \
  449. map_start); \
  450. u##bits res = le##bits##_to_cpu(*tmp); \
  451. if (unmap_on_exit) \
  452. unmap_extent_buffer(eb, map_token, KM_USER1); \
  453. return res; \
  454. } else { \
  455. __le##bits res; \
  456. read_eb_member(eb, NULL, type, member, &res); \
  457. return le##bits##_to_cpu(res); \
  458. } \
  459. } \
  460. static inline void btrfs_set_##name(struct extent_buffer *eb, \
  461. u##bits val) \
  462. { \
  463. int err; \
  464. char *map_token; \
  465. char *kaddr; \
  466. unsigned long map_start; \
  467. unsigned long map_len; \
  468. unsigned long offset = offsetof(type, member); \
  469. int unmap_on_exit = (eb->map_token == NULL); \
  470. err = map_extent_buffer(eb, offset, \
  471. sizeof(((type *)0)->member), \
  472. &map_token, &kaddr, \
  473. &map_start, &map_len, KM_USER1); \
  474. if (!err) { \
  475. __le##bits *tmp = (__le##bits *)(kaddr + offset - \
  476. map_start); \
  477. *tmp = cpu_to_le##bits(val); \
  478. if (unmap_on_exit) \
  479. unmap_extent_buffer(eb, map_token, KM_USER1); \
  480. } else { \
  481. val = cpu_to_le##bits(val); \
  482. write_eb_member(eb, NULL, type, member, &val); \
  483. } \
  484. }
  485. #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
  486. static inline u##bits btrfs_##name(type *s) \
  487. { \
  488. return le##bits##_to_cpu(s->member); \
  489. } \
  490. static inline void btrfs_set_##name(type *s, u##bits val) \
  491. { \
  492. s->member = cpu_to_le##bits(val); \
  493. }
  494. /* struct btrfs_block_group_item */
  495. BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
  496. used, 64);
  497. BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
  498. used, 64);
  499. /* struct btrfs_inode_item */
  500. BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
  501. BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
  502. BTRFS_SETGET_FUNCS(inode_nblocks, struct btrfs_inode_item, nblocks, 64);
  503. BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
  504. BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
  505. BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
  506. BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
  507. BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
  508. BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 32);
  509. BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 16);
  510. BTRFS_SETGET_FUNCS(inode_compat_flags, struct btrfs_inode_item,
  511. compat_flags, 16);
  512. static inline struct btrfs_inode_timespec *
  513. btrfs_inode_atime(struct btrfs_inode_item *inode_item)
  514. {
  515. unsigned long ptr = (unsigned long)inode_item;
  516. ptr += offsetof(struct btrfs_inode_item, atime);
  517. return (struct btrfs_inode_timespec *)ptr;
  518. }
  519. static inline struct btrfs_inode_timespec *
  520. btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
  521. {
  522. unsigned long ptr = (unsigned long)inode_item;
  523. ptr += offsetof(struct btrfs_inode_item, mtime);
  524. return (struct btrfs_inode_timespec *)ptr;
  525. }
  526. static inline struct btrfs_inode_timespec *
  527. btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
  528. {
  529. unsigned long ptr = (unsigned long)inode_item;
  530. ptr += offsetof(struct btrfs_inode_item, ctime);
  531. return (struct btrfs_inode_timespec *)ptr;
  532. }
  533. static inline struct btrfs_inode_timespec *
  534. btrfs_inode_otime(struct btrfs_inode_item *inode_item)
  535. {
  536. unsigned long ptr = (unsigned long)inode_item;
  537. ptr += offsetof(struct btrfs_inode_item, otime);
  538. return (struct btrfs_inode_timespec *)ptr;
  539. }
  540. BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_inode_timespec, sec, 64);
  541. BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_inode_timespec, nsec, 32);
  542. /* struct btrfs_extent_item */
  543. BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 32);
  544. BTRFS_SETGET_FUNCS(extent_owner, struct btrfs_extent_item, owner, 32);
  545. BTRFS_SETGET_STACK_FUNCS(stack_extent_refs, struct btrfs_extent_item,
  546. refs, 32);
  547. BTRFS_SETGET_STACK_FUNCS(stack_extent_owner, struct btrfs_extent_item,
  548. owner, 32);
  549. /* struct btrfs_node */
  550. BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
  551. static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
  552. {
  553. unsigned long ptr;
  554. ptr = offsetof(struct btrfs_node, ptrs) +
  555. sizeof(struct btrfs_key_ptr) * nr;
  556. return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
  557. }
  558. static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
  559. int nr, u64 val)
  560. {
  561. unsigned long ptr;
  562. ptr = offsetof(struct btrfs_node, ptrs) +
  563. sizeof(struct btrfs_key_ptr) * nr;
  564. btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
  565. }
  566. static unsigned long btrfs_node_key_ptr_offset(int nr)
  567. {
  568. return offsetof(struct btrfs_node, ptrs) +
  569. sizeof(struct btrfs_key_ptr) * nr;
  570. }
  571. static void btrfs_node_key(struct extent_buffer *eb,
  572. struct btrfs_disk_key *disk_key, int nr)
  573. {
  574. unsigned long ptr;
  575. ptr = btrfs_node_key_ptr_offset(nr);
  576. read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
  577. struct btrfs_key_ptr, key, disk_key);
  578. }
  579. static inline void btrfs_set_node_key(struct extent_buffer *eb,
  580. struct btrfs_disk_key *disk_key, int nr)
  581. {
  582. unsigned long ptr;
  583. ptr = btrfs_node_key_ptr_offset(nr);
  584. write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
  585. struct btrfs_key_ptr, key, disk_key);
  586. }
  587. /* struct btrfs_item */
  588. BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
  589. BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
  590. static inline unsigned long btrfs_item_nr_offset(int nr)
  591. {
  592. return offsetof(struct btrfs_leaf, items) +
  593. sizeof(struct btrfs_item) * nr;
  594. }
  595. static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
  596. int nr)
  597. {
  598. return (struct btrfs_item *)btrfs_item_nr_offset(nr);
  599. }
  600. static inline u32 btrfs_item_end(struct extent_buffer *eb,
  601. struct btrfs_item *item)
  602. {
  603. return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
  604. }
  605. static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
  606. {
  607. return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
  608. }
  609. static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
  610. {
  611. return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
  612. }
  613. static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
  614. {
  615. return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
  616. }
  617. static inline void btrfs_item_key(struct extent_buffer *eb,
  618. struct btrfs_disk_key *disk_key, int nr)
  619. {
  620. struct btrfs_item *item = btrfs_item_nr(eb, nr);
  621. read_eb_member(eb, item, struct btrfs_item, key, disk_key);
  622. }
  623. static inline void btrfs_set_item_key(struct extent_buffer *eb,
  624. struct btrfs_disk_key *disk_key, int nr)
  625. {
  626. struct btrfs_item *item = btrfs_item_nr(eb, nr);
  627. write_eb_member(eb, item, struct btrfs_item, key, disk_key);
  628. }
  629. /* struct btrfs_dir_item */
  630. BTRFS_SETGET_FUNCS(dir_flags, struct btrfs_dir_item, flags, 16);
  631. BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
  632. BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
  633. static inline void btrfs_dir_item_key(struct extent_buffer *eb,
  634. struct btrfs_dir_item *item,
  635. struct btrfs_disk_key *key)
  636. {
  637. read_eb_member(eb, item, struct btrfs_dir_item, location, key);
  638. }
  639. static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
  640. struct btrfs_dir_item *item,
  641. struct btrfs_disk_key *key)
  642. {
  643. write_eb_member(eb, item, struct btrfs_dir_item, location, key);
  644. }
  645. /* struct btrfs_disk_key */
  646. BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
  647. objectid, 64);
  648. BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
  649. BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
  650. static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
  651. struct btrfs_disk_key *disk)
  652. {
  653. cpu->offset = le64_to_cpu(disk->offset);
  654. cpu->type = disk->type;
  655. cpu->objectid = le64_to_cpu(disk->objectid);
  656. }
  657. static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
  658. struct btrfs_key *cpu)
  659. {
  660. disk->offset = cpu_to_le64(cpu->offset);
  661. disk->type = cpu->type;
  662. disk->objectid = cpu_to_le64(cpu->objectid);
  663. }
  664. static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
  665. struct btrfs_key *key, int nr)
  666. {
  667. struct btrfs_disk_key disk_key;
  668. btrfs_node_key(eb, &disk_key, nr);
  669. btrfs_disk_key_to_cpu(key, &disk_key);
  670. }
  671. static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
  672. struct btrfs_key *key, int nr)
  673. {
  674. struct btrfs_disk_key disk_key;
  675. btrfs_item_key(eb, &disk_key, nr);
  676. btrfs_disk_key_to_cpu(key, &disk_key);
  677. }
  678. static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
  679. struct btrfs_dir_item *item,
  680. struct btrfs_key *key)
  681. {
  682. struct btrfs_disk_key disk_key;
  683. btrfs_dir_item_key(eb, item, &disk_key);
  684. btrfs_disk_key_to_cpu(key, &disk_key);
  685. }
  686. static inline u8 btrfs_key_type(struct btrfs_key *key)
  687. {
  688. return key->type;
  689. }
  690. static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
  691. {
  692. key->type = val;
  693. }
  694. /* struct btrfs_header */
  695. BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
  696. BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
  697. generation, 64);
  698. BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
  699. BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
  700. BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 16);
  701. BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
  702. static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
  703. {
  704. unsigned long ptr = offsetof(struct btrfs_header, fsid);
  705. return (u8 *)ptr;
  706. }
  707. static inline u8 *btrfs_super_fsid(struct extent_buffer *eb)
  708. {
  709. unsigned long ptr = offsetof(struct btrfs_super_block, fsid);
  710. return (u8 *)ptr;
  711. }
  712. static inline u8 *btrfs_header_csum(struct extent_buffer *eb)
  713. {
  714. unsigned long ptr = offsetof(struct btrfs_header, csum);
  715. return (u8 *)ptr;
  716. }
  717. static inline struct btrfs_node *btrfs_buffer_node(struct extent_buffer *eb)
  718. {
  719. return NULL;
  720. }
  721. static inline struct btrfs_leaf *btrfs_buffer_leaf(struct extent_buffer *eb)
  722. {
  723. return NULL;
  724. }
  725. static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb)
  726. {
  727. return NULL;
  728. }
  729. static inline int btrfs_is_leaf(struct extent_buffer *eb)
  730. {
  731. return (btrfs_header_level(eb) == 0);
  732. }
  733. /* struct btrfs_root_item */
  734. BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
  735. BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
  736. BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
  737. BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
  738. BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
  739. BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
  740. BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
  741. BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 32);
  742. BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
  743. BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
  744. /* struct btrfs_super_block */
  745. BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
  746. BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
  747. generation, 64);
  748. BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
  749. BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
  750. root_level, 8);
  751. BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
  752. total_bytes, 64);
  753. BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
  754. bytes_used, 64);
  755. BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
  756. sectorsize, 32);
  757. BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
  758. nodesize, 32);
  759. BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
  760. leafsize, 32);
  761. BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
  762. root_dir_objectid, 64);
  763. static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
  764. {
  765. return offsetof(struct btrfs_leaf, items);
  766. }
  767. /* struct btrfs_file_extent_item */
  768. BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
  769. static inline unsigned long btrfs_file_extent_inline_start(struct
  770. btrfs_file_extent_item *e)
  771. {
  772. unsigned long offset = (unsigned long)e;
  773. offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
  774. return offset;
  775. }
  776. static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
  777. {
  778. return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
  779. }
  780. static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
  781. struct btrfs_item *e)
  782. {
  783. unsigned long offset;
  784. offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
  785. return btrfs_item_size(eb, e) - offset;
  786. }
  787. BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
  788. disk_bytenr, 64);
  789. BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
  790. generation, 64);
  791. BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
  792. disk_num_bytes, 64);
  793. BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
  794. offset, 64);
  795. BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
  796. num_bytes, 64);
  797. static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
  798. {
  799. return sb->s_fs_info;
  800. }
  801. static inline int btrfs_set_root_name(struct btrfs_root *root,
  802. const char *name, int len)
  803. {
  804. /* if we already have a name just free it */
  805. if (root->name)
  806. kfree(root->name);
  807. root->name = kmalloc(len+1, GFP_KERNEL);
  808. if (!root->name)
  809. return -ENOMEM;
  810. memcpy(root->name, name, len);
  811. root->name[len] ='\0';
  812. return 0;
  813. }
  814. static inline u32 btrfs_level_size(struct btrfs_root *root, int level) {
  815. if (level == 0)
  816. return root->leafsize;
  817. return root->nodesize;
  818. }
  819. /* helper function to cast into the data area of the leaf. */
  820. #define btrfs_item_ptr(leaf, slot, type) \
  821. ((type *)(btrfs_leaf_data(leaf) + \
  822. btrfs_item_offset_nr(leaf, slot)))
  823. #define btrfs_item_ptr_offset(leaf, slot) \
  824. ((unsigned long)(btrfs_leaf_data(leaf) + \
  825. btrfs_item_offset_nr(leaf, slot)))
  826. /* mount option defines and helpers */
  827. #define BTRFS_MOUNT_SUBVOL 0x000001
  828. #define btrfs_clear_opt(o, opt) o &= ~BTRFS_MOUNT_##opt
  829. #define btrfs_set_opt(o, opt) o |= BTRFS_MOUNT_##opt
  830. #define btrfs_test_opt(sb, opt) (BTRFS_SB(sb)->s_mount_opt & \
  831. BTRFS_MOUNT_##opt)
  832. /* extent-tree.c */
  833. int btrfs_extent_post_op(struct btrfs_trans_handle *trans,
  834. struct btrfs_root *root);
  835. int btrfs_copy_pinned(struct btrfs_root *root, struct extent_map_tree *copy);
  836. struct btrfs_block_group_cache *btrfs_lookup_block_group(struct
  837. btrfs_fs_info *info,
  838. u64 bytenr);
  839. struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root,
  840. struct btrfs_block_group_cache
  841. *hint, u64 search_start,
  842. int data, int owner);
  843. int btrfs_inc_root_ref(struct btrfs_trans_handle *trans,
  844. struct btrfs_root *root);
  845. struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
  846. struct btrfs_root *root, u32 size,
  847. u64 hint, u64 empty_size);
  848. int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
  849. struct btrfs_root *root, u64 owner,
  850. u64 num_bytes, u64 empty_size, u64 search_start,
  851. u64 search_end, struct btrfs_key *ins, int data);
  852. int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  853. struct extent_buffer *buf);
  854. int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
  855. *root, u64 bytenr, u64 num_bytes, int pin);
  856. int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
  857. struct btrfs_root *root,
  858. struct extent_map_tree *unpin);
  859. int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
  860. struct btrfs_root *root,
  861. u64 bytenr, u64 num_bytes);
  862. int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
  863. struct btrfs_root *root);
  864. int btrfs_free_block_groups(struct btrfs_fs_info *info);
  865. int btrfs_read_block_groups(struct btrfs_root *root);
  866. /* ctree.c */
  867. int btrfs_cow_block(struct btrfs_trans_handle *trans,
  868. struct btrfs_root *root, struct extent_buffer *buf,
  869. struct extent_buffer *parent, int parent_slot,
  870. struct extent_buffer **cow_ret);
  871. int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
  872. *root, struct btrfs_path *path, u32 data_size);
  873. int btrfs_truncate_item(struct btrfs_trans_handle *trans,
  874. struct btrfs_root *root,
  875. struct btrfs_path *path,
  876. u32 new_size);
  877. int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
  878. *root, struct btrfs_key *key, struct btrfs_path *p, int
  879. ins_len, int cow);
  880. int btrfs_realloc_node(struct btrfs_trans_handle *trans,
  881. struct btrfs_root *root, struct extent_buffer *parent,
  882. int cache_only, u64 *last_ret);
  883. void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
  884. struct btrfs_path *btrfs_alloc_path(void);
  885. void btrfs_free_path(struct btrfs_path *p);
  886. void btrfs_init_path(struct btrfs_path *p);
  887. int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  888. struct btrfs_path *path);
  889. int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
  890. *root, struct btrfs_key *key, void *data, u32 data_size);
  891. int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
  892. *root, struct btrfs_path *path, struct btrfs_key
  893. *cpu_key, u32 data_size);
  894. int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
  895. int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
  896. int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
  897. *root);
  898. /* root-item.c */
  899. int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  900. struct btrfs_key *key);
  901. int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
  902. *root, struct btrfs_key *key, struct btrfs_root_item
  903. *item);
  904. int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
  905. *root, struct btrfs_key *key, struct btrfs_root_item
  906. *item);
  907. int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
  908. btrfs_root_item *item, struct btrfs_key *key);
  909. int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid,
  910. struct btrfs_root *latest_root);
  911. /* dir-item.c */
  912. int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
  913. *root, const char *name, int name_len, u64 dir,
  914. struct btrfs_key *location, u8 type);
  915. struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
  916. struct btrfs_root *root,
  917. struct btrfs_path *path, u64 dir,
  918. const char *name, int name_len,
  919. int mod);
  920. struct btrfs_dir_item *
  921. btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
  922. struct btrfs_root *root,
  923. struct btrfs_path *path, u64 dir,
  924. u64 objectid, const char *name, int name_len,
  925. int mod);
  926. struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
  927. struct btrfs_path *path,
  928. const char *name, int name_len);
  929. int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
  930. struct btrfs_root *root,
  931. struct btrfs_path *path,
  932. struct btrfs_dir_item *di);
  933. /* inode-map.c */
  934. int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
  935. struct btrfs_root *fs_root,
  936. u64 dirid, u64 *objectid);
  937. int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid);
  938. /* inode-item.c */
  939. int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
  940. struct btrfs_root *root,
  941. struct btrfs_path *path, u64 objectid);
  942. int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
  943. *root, struct btrfs_path *path,
  944. struct btrfs_key *location, int mod);
  945. /* file-item.c */
  946. int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
  947. struct btrfs_root *root,
  948. u64 objectid, u64 pos, u64 offset,
  949. u64 disk_num_bytes,
  950. u64 num_bytes);
  951. int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
  952. struct btrfs_root *root,
  953. struct btrfs_path *path, u64 objectid,
  954. u64 bytenr, int mod);
  955. int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
  956. struct btrfs_root *root,
  957. u64 objectid, u64 offset,
  958. char *data, size_t len);
  959. struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
  960. struct btrfs_root *root,
  961. struct btrfs_path *path,
  962. u64 objectid, u64 offset,
  963. int cow);
  964. int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
  965. struct btrfs_root *root, struct btrfs_path *path,
  966. u64 isize);
  967. /* inode.c */
  968. int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page);
  969. int btrfs_readpage(struct file *file, struct page *page);
  970. void btrfs_delete_inode(struct inode *inode);
  971. void btrfs_read_locked_inode(struct inode *inode);
  972. int btrfs_write_inode(struct inode *inode, int wait);
  973. void btrfs_dirty_inode(struct inode *inode);
  974. struct inode *btrfs_alloc_inode(struct super_block *sb);
  975. void btrfs_destroy_inode(struct inode *inode);
  976. int btrfs_init_cachep(void);
  977. void btrfs_destroy_cachep(void);
  978. long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
  979. struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
  980. struct btrfs_root *root);
  981. int btrfs_commit_write(struct file *file, struct page *page,
  982. unsigned from, unsigned to);
  983. struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
  984. size_t page_offset, u64 start, u64 end,
  985. int create);
  986. int btrfs_update_inode(struct btrfs_trans_handle *trans,
  987. struct btrfs_root *root,
  988. struct inode *inode);
  989. /* file.c */
  990. int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end);
  991. extern struct file_operations btrfs_file_operations;
  992. int btrfs_drop_extents(struct btrfs_trans_handle *trans,
  993. struct btrfs_root *root, struct inode *inode,
  994. u64 start, u64 end, u64 *hint_block);
  995. /* tree-defrag.c */
  996. int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
  997. struct btrfs_root *root, int cache_only);
  998. /* sysfs.c */
  999. int btrfs_init_sysfs(void);
  1000. void btrfs_exit_sysfs(void);
  1001. int btrfs_sysfs_add_super(struct btrfs_fs_info *fs);
  1002. int btrfs_sysfs_add_root(struct btrfs_root *root);
  1003. void btrfs_sysfs_del_root(struct btrfs_root *root);
  1004. void btrfs_sysfs_del_super(struct btrfs_fs_info *root);
  1005. #endif