inode.c 63 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508
  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. #include <linux/buffer_head.h>
  19. #include <linux/fs.h>
  20. #include <linux/pagemap.h>
  21. #include <linux/highmem.h>
  22. #include <linux/time.h>
  23. #include <linux/init.h>
  24. #include <linux/string.h>
  25. #include <linux/smp_lock.h>
  26. #include <linux/backing-dev.h>
  27. #include <linux/mpage.h>
  28. #include <linux/swap.h>
  29. #include <linux/writeback.h>
  30. #include <linux/statfs.h>
  31. #include <linux/compat.h>
  32. #include <linux/bit_spinlock.h>
  33. #include <linux/version.h>
  34. #include "ctree.h"
  35. #include "disk-io.h"
  36. #include "transaction.h"
  37. #include "btrfs_inode.h"
  38. #include "ioctl.h"
  39. #include "print-tree.h"
  40. struct btrfs_iget_args {
  41. u64 ino;
  42. struct btrfs_root *root;
  43. };
  44. static struct inode_operations btrfs_dir_inode_operations;
  45. static struct inode_operations btrfs_symlink_inode_operations;
  46. static struct inode_operations btrfs_dir_ro_inode_operations;
  47. static struct inode_operations btrfs_special_inode_operations;
  48. static struct inode_operations btrfs_file_inode_operations;
  49. static struct address_space_operations btrfs_aops;
  50. static struct address_space_operations btrfs_symlink_aops;
  51. static struct file_operations btrfs_dir_file_operations;
  52. static struct extent_map_ops btrfs_extent_map_ops;
  53. static struct kmem_cache *btrfs_inode_cachep;
  54. struct kmem_cache *btrfs_trans_handle_cachep;
  55. struct kmem_cache *btrfs_transaction_cachep;
  56. struct kmem_cache *btrfs_bit_radix_cachep;
  57. struct kmem_cache *btrfs_path_cachep;
  58. #define S_SHIFT 12
  59. static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
  60. [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
  61. [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
  62. [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
  63. [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
  64. [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
  65. [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
  66. [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
  67. };
  68. static int run_delalloc_range(struct inode *inode, u64 start, u64 end)
  69. {
  70. struct btrfs_root *root = BTRFS_I(inode)->root;
  71. struct btrfs_trans_handle *trans;
  72. struct btrfs_key ins;
  73. u64 alloc_hint = 0;
  74. u64 num_bytes;
  75. int ret;
  76. u64 blocksize = root->sectorsize;
  77. mutex_lock(&root->fs_info->fs_mutex);
  78. trans = btrfs_start_transaction(root, 1);
  79. btrfs_set_trans_block_group(trans, inode);
  80. BUG_ON(!trans);
  81. num_bytes = (end - start + blocksize) & ~(blocksize - 1);
  82. ret = btrfs_drop_extents(trans, root, inode,
  83. start, start + num_bytes, &alloc_hint);
  84. ret = btrfs_alloc_extent(trans, root, inode->i_ino, num_bytes, 0,
  85. alloc_hint, (u64)-1, &ins, 1);
  86. if (ret) {
  87. WARN_ON(1);
  88. goto out;
  89. }
  90. ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
  91. start, ins.objectid, ins.offset,
  92. ins.offset);
  93. out:
  94. btrfs_end_transaction(trans, root);
  95. mutex_unlock(&root->fs_info->fs_mutex);
  96. return ret;
  97. }
  98. int btrfs_writepage_io_hook(struct page *page, u64 start, u64 end)
  99. {
  100. struct inode *inode = page->mapping->host;
  101. struct btrfs_root *root = BTRFS_I(inode)->root;
  102. struct btrfs_trans_handle *trans;
  103. char *kaddr;
  104. int ret;
  105. u64 page_start = page->index << PAGE_CACHE_SHIFT;
  106. size_t offset = start - page_start;
  107. mutex_lock(&root->fs_info->fs_mutex);
  108. trans = btrfs_start_transaction(root, 1);
  109. btrfs_set_trans_block_group(trans, inode);
  110. kaddr = kmap(page);
  111. btrfs_csum_file_block(trans, root, inode->i_ino,
  112. start, kaddr + offset, end - start + 1);
  113. kunmap(page);
  114. ret = btrfs_end_transaction(trans, root);
  115. BUG_ON(ret);
  116. mutex_unlock(&root->fs_info->fs_mutex);
  117. return ret;
  118. }
  119. int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
  120. {
  121. int ret = 0;
  122. struct inode *inode = page->mapping->host;
  123. struct btrfs_root *root = BTRFS_I(inode)->root;
  124. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  125. struct btrfs_csum_item *item;
  126. struct btrfs_path *path = NULL;
  127. u64 private;
  128. mutex_lock(&root->fs_info->fs_mutex);
  129. path = btrfs_alloc_path();
  130. item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, start, 0);
  131. if (IS_ERR(item)) {
  132. ret = PTR_ERR(item);
  133. /* a csum that isn't present is a preallocated region. */
  134. if (ret == -ENOENT || ret == -EFBIG)
  135. ret = 0;
  136. private = 0;
  137. goto out;
  138. }
  139. memcpy((char *)&private, &item->csum, BTRFS_CRC32_SIZE);
  140. set_state_private(em_tree, start, private);
  141. out:
  142. if (path)
  143. btrfs_free_path(path);
  144. mutex_unlock(&root->fs_info->fs_mutex);
  145. return ret;
  146. }
  147. int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
  148. {
  149. size_t offset = start - (page->index << PAGE_CACHE_SHIFT);
  150. struct inode *inode = page->mapping->host;
  151. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  152. char *kaddr;
  153. u64 private;
  154. int ret;
  155. ret = get_state_private(em_tree, start, &private);
  156. kaddr = kmap_atomic(page, KM_IRQ0);
  157. if (ret) {
  158. goto zeroit;
  159. }
  160. /*
  161. struct btrfs_root *root = BTRFS_I(inode)->root;
  162. char csum[BTRFS_CRC32_SIZE];
  163. ret = btrfs_csum_data(root, kaddr + offset, end - start + 1, csum);
  164. BUG_ON(ret);
  165. if (memcmp(csum, &private, BTRFS_CRC32_SIZE)) {
  166. goto zeroit;
  167. }
  168. */
  169. kunmap_atomic(kaddr, KM_IRQ0);
  170. return 0;
  171. zeroit:
  172. printk("btrfs csum failed ino %lu off %llu\n",
  173. page->mapping->host->i_ino, (unsigned long long)start);
  174. memset(kaddr + offset, 1, end - start + 1);
  175. flush_dcache_page(page);
  176. kunmap_atomic(kaddr, KM_IRQ0);
  177. return 0;
  178. }
  179. void btrfs_read_locked_inode(struct inode *inode)
  180. {
  181. struct btrfs_path *path;
  182. struct extent_buffer *leaf;
  183. struct btrfs_inode_item *inode_item;
  184. struct btrfs_inode_timespec *tspec;
  185. struct btrfs_root *root = BTRFS_I(inode)->root;
  186. struct btrfs_key location;
  187. u64 alloc_group_block;
  188. u32 rdev;
  189. int ret;
  190. path = btrfs_alloc_path();
  191. BUG_ON(!path);
  192. mutex_lock(&root->fs_info->fs_mutex);
  193. memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
  194. ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
  195. if (ret)
  196. goto make_bad;
  197. leaf = path->nodes[0];
  198. inode_item = btrfs_item_ptr(leaf, path->slots[0],
  199. struct btrfs_inode_item);
  200. inode->i_mode = btrfs_inode_mode(leaf, inode_item);
  201. inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
  202. inode->i_uid = btrfs_inode_uid(leaf, inode_item);
  203. inode->i_gid = btrfs_inode_gid(leaf, inode_item);
  204. inode->i_size = btrfs_inode_size(leaf, inode_item);
  205. tspec = btrfs_inode_atime(inode_item);
  206. inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
  207. inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
  208. tspec = btrfs_inode_mtime(inode_item);
  209. inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
  210. inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
  211. tspec = btrfs_inode_ctime(inode_item);
  212. inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
  213. inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
  214. inode->i_blocks = btrfs_inode_nblocks(leaf, inode_item);
  215. inode->i_generation = btrfs_inode_generation(leaf, inode_item);
  216. inode->i_rdev = 0;
  217. rdev = btrfs_inode_rdev(leaf, inode_item);
  218. alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
  219. BTRFS_I(inode)->block_group = btrfs_lookup_block_group(root->fs_info,
  220. alloc_group_block);
  221. btrfs_free_path(path);
  222. inode_item = NULL;
  223. mutex_unlock(&root->fs_info->fs_mutex);
  224. switch (inode->i_mode & S_IFMT) {
  225. case S_IFREG:
  226. inode->i_mapping->a_ops = &btrfs_aops;
  227. BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
  228. inode->i_fop = &btrfs_file_operations;
  229. inode->i_op = &btrfs_file_inode_operations;
  230. break;
  231. case S_IFDIR:
  232. inode->i_fop = &btrfs_dir_file_operations;
  233. if (root == root->fs_info->tree_root)
  234. inode->i_op = &btrfs_dir_ro_inode_operations;
  235. else
  236. inode->i_op = &btrfs_dir_inode_operations;
  237. break;
  238. case S_IFLNK:
  239. inode->i_op = &btrfs_symlink_inode_operations;
  240. inode->i_mapping->a_ops = &btrfs_symlink_aops;
  241. break;
  242. default:
  243. init_special_inode(inode, inode->i_mode, rdev);
  244. break;
  245. }
  246. return;
  247. make_bad:
  248. btrfs_release_path(root, path);
  249. btrfs_free_path(path);
  250. mutex_unlock(&root->fs_info->fs_mutex);
  251. make_bad_inode(inode);
  252. }
  253. static void fill_inode_item(struct extent_buffer *leaf,
  254. struct btrfs_inode_item *item,
  255. struct inode *inode)
  256. {
  257. btrfs_set_inode_uid(leaf, item, inode->i_uid);
  258. btrfs_set_inode_gid(leaf, item, inode->i_gid);
  259. btrfs_set_inode_size(leaf, item, inode->i_size);
  260. btrfs_set_inode_mode(leaf, item, inode->i_mode);
  261. btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
  262. btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
  263. inode->i_atime.tv_sec);
  264. btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
  265. inode->i_atime.tv_nsec);
  266. btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
  267. inode->i_mtime.tv_sec);
  268. btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
  269. inode->i_mtime.tv_nsec);
  270. btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
  271. inode->i_ctime.tv_sec);
  272. btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
  273. inode->i_ctime.tv_nsec);
  274. btrfs_set_inode_nblocks(leaf, item, inode->i_blocks);
  275. btrfs_set_inode_generation(leaf, item, inode->i_generation);
  276. btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
  277. btrfs_set_inode_block_group(leaf, item,
  278. BTRFS_I(inode)->block_group->key.objectid);
  279. }
  280. int btrfs_update_inode(struct btrfs_trans_handle *trans,
  281. struct btrfs_root *root,
  282. struct inode *inode)
  283. {
  284. struct btrfs_inode_item *inode_item;
  285. struct btrfs_path *path;
  286. struct extent_buffer *leaf;
  287. int ret;
  288. path = btrfs_alloc_path();
  289. BUG_ON(!path);
  290. ret = btrfs_lookup_inode(trans, root, path,
  291. &BTRFS_I(inode)->location, 1);
  292. if (ret) {
  293. if (ret > 0)
  294. ret = -ENOENT;
  295. goto failed;
  296. }
  297. leaf = path->nodes[0];
  298. inode_item = btrfs_item_ptr(leaf, path->slots[0],
  299. struct btrfs_inode_item);
  300. fill_inode_item(leaf, inode_item, inode);
  301. btrfs_mark_buffer_dirty(leaf);
  302. btrfs_set_inode_last_trans(trans, inode);
  303. ret = 0;
  304. failed:
  305. btrfs_release_path(root, path);
  306. btrfs_free_path(path);
  307. return ret;
  308. }
  309. static int btrfs_unlink_trans(struct btrfs_trans_handle *trans,
  310. struct btrfs_root *root,
  311. struct inode *dir,
  312. struct dentry *dentry)
  313. {
  314. struct btrfs_path *path;
  315. const char *name = dentry->d_name.name;
  316. int name_len = dentry->d_name.len;
  317. int ret = 0;
  318. struct extent_buffer *leaf;
  319. struct btrfs_dir_item *di;
  320. struct btrfs_key key;
  321. path = btrfs_alloc_path();
  322. if (!path) {
  323. ret = -ENOMEM;
  324. goto err;
  325. }
  326. di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
  327. name, name_len, -1);
  328. if (IS_ERR(di)) {
  329. ret = PTR_ERR(di);
  330. goto err;
  331. }
  332. if (!di) {
  333. ret = -ENOENT;
  334. goto err;
  335. }
  336. leaf = path->nodes[0];
  337. btrfs_dir_item_key_to_cpu(leaf, di, &key);
  338. ret = btrfs_delete_one_dir_name(trans, root, path, di);
  339. if (ret)
  340. goto err;
  341. btrfs_release_path(root, path);
  342. di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
  343. key.objectid, name, name_len, -1);
  344. if (IS_ERR(di)) {
  345. ret = PTR_ERR(di);
  346. goto err;
  347. }
  348. if (!di) {
  349. ret = -ENOENT;
  350. goto err;
  351. }
  352. ret = btrfs_delete_one_dir_name(trans, root, path, di);
  353. dentry->d_inode->i_ctime = dir->i_ctime;
  354. err:
  355. btrfs_free_path(path);
  356. if (!ret) {
  357. dir->i_size -= name_len * 2;
  358. dir->i_mtime = dir->i_ctime = CURRENT_TIME;
  359. btrfs_update_inode(trans, root, dir);
  360. drop_nlink(dentry->d_inode);
  361. ret = btrfs_update_inode(trans, root, dentry->d_inode);
  362. dir->i_sb->s_dirt = 1;
  363. }
  364. return ret;
  365. }
  366. static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
  367. {
  368. struct btrfs_root *root;
  369. struct btrfs_trans_handle *trans;
  370. int ret;
  371. unsigned long nr;
  372. root = BTRFS_I(dir)->root;
  373. mutex_lock(&root->fs_info->fs_mutex);
  374. trans = btrfs_start_transaction(root, 1);
  375. btrfs_set_trans_block_group(trans, dir);
  376. ret = btrfs_unlink_trans(trans, root, dir, dentry);
  377. nr = trans->blocks_used;
  378. btrfs_end_transaction(trans, root);
  379. mutex_unlock(&root->fs_info->fs_mutex);
  380. btrfs_btree_balance_dirty(root, nr);
  381. return ret;
  382. }
  383. static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
  384. {
  385. struct inode *inode = dentry->d_inode;
  386. int err;
  387. int ret;
  388. struct btrfs_root *root = BTRFS_I(dir)->root;
  389. struct btrfs_path *path;
  390. struct btrfs_key key;
  391. struct btrfs_trans_handle *trans;
  392. struct btrfs_key found_key;
  393. int found_type;
  394. struct extent_buffer *leaf;
  395. char *goodnames = "..";
  396. unsigned long nr;
  397. path = btrfs_alloc_path();
  398. BUG_ON(!path);
  399. mutex_lock(&root->fs_info->fs_mutex);
  400. trans = btrfs_start_transaction(root, 1);
  401. btrfs_set_trans_block_group(trans, dir);
  402. key.objectid = inode->i_ino;
  403. key.offset = (u64)-1;
  404. key.type = (u8)-1;
  405. while(1) {
  406. ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
  407. if (ret < 0) {
  408. err = ret;
  409. goto out;
  410. }
  411. BUG_ON(ret == 0);
  412. if (path->slots[0] == 0) {
  413. err = -ENOENT;
  414. goto out;
  415. }
  416. path->slots[0]--;
  417. leaf = path->nodes[0];
  418. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  419. found_type = btrfs_key_type(&found_key);
  420. if (found_key.objectid != inode->i_ino) {
  421. err = -ENOENT;
  422. goto out;
  423. }
  424. if ((found_type != BTRFS_DIR_ITEM_KEY &&
  425. found_type != BTRFS_DIR_INDEX_KEY) ||
  426. (!btrfs_match_dir_item_name(root, path, goodnames, 2) &&
  427. !btrfs_match_dir_item_name(root, path, goodnames, 1))) {
  428. err = -ENOTEMPTY;
  429. goto out;
  430. }
  431. ret = btrfs_del_item(trans, root, path);
  432. BUG_ON(ret);
  433. if (found_type == BTRFS_DIR_ITEM_KEY && found_key.offset == 1)
  434. break;
  435. btrfs_release_path(root, path);
  436. }
  437. ret = 0;
  438. btrfs_release_path(root, path);
  439. /* now the directory is empty */
  440. err = btrfs_unlink_trans(trans, root, dir, dentry);
  441. if (!err) {
  442. inode->i_size = 0;
  443. }
  444. out:
  445. btrfs_release_path(root, path);
  446. btrfs_free_path(path);
  447. mutex_unlock(&root->fs_info->fs_mutex);
  448. nr = trans->blocks_used;
  449. ret = btrfs_end_transaction(trans, root);
  450. btrfs_btree_balance_dirty(root, nr);
  451. if (ret && !err)
  452. err = ret;
  453. return err;
  454. }
  455. static int btrfs_free_inode(struct btrfs_trans_handle *trans,
  456. struct btrfs_root *root,
  457. struct inode *inode)
  458. {
  459. struct btrfs_path *path;
  460. int ret;
  461. clear_inode(inode);
  462. path = btrfs_alloc_path();
  463. BUG_ON(!path);
  464. ret = btrfs_lookup_inode(trans, root, path,
  465. &BTRFS_I(inode)->location, -1);
  466. if (ret > 0)
  467. ret = -ENOENT;
  468. if (!ret)
  469. ret = btrfs_del_item(trans, root, path);
  470. btrfs_free_path(path);
  471. return ret;
  472. }
  473. /*
  474. * this can truncate away extent items, csum items and directory items.
  475. * It starts at a high offset and removes keys until it can't find
  476. * any higher than i_size.
  477. *
  478. * csum items that cross the new i_size are truncated to the new size
  479. * as well.
  480. */
  481. static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
  482. struct btrfs_root *root,
  483. struct inode *inode)
  484. {
  485. int ret;
  486. struct btrfs_path *path;
  487. struct btrfs_key key;
  488. struct btrfs_key found_key;
  489. u32 found_type;
  490. struct extent_buffer *leaf;
  491. struct btrfs_file_extent_item *fi;
  492. u64 extent_start = 0;
  493. u64 extent_num_bytes = 0;
  494. u64 item_end = 0;
  495. int found_extent;
  496. int del_item;
  497. btrfs_drop_extent_cache(inode, inode->i_size, (u64)-1);
  498. path = btrfs_alloc_path();
  499. path->reada = -1;
  500. BUG_ON(!path);
  501. /* FIXME, add redo link to tree so we don't leak on crash */
  502. key.objectid = inode->i_ino;
  503. key.offset = (u64)-1;
  504. key.type = (u8)-1;
  505. while(1) {
  506. btrfs_init_path(path);
  507. fi = NULL;
  508. ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
  509. if (ret < 0) {
  510. goto error;
  511. }
  512. if (ret > 0) {
  513. BUG_ON(path->slots[0] == 0);
  514. path->slots[0]--;
  515. }
  516. leaf = path->nodes[0];
  517. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  518. found_type = btrfs_key_type(&found_key);
  519. if (found_key.objectid != inode->i_ino)
  520. break;
  521. if (found_type != BTRFS_CSUM_ITEM_KEY &&
  522. found_type != BTRFS_DIR_ITEM_KEY &&
  523. found_type != BTRFS_DIR_INDEX_KEY &&
  524. found_type != BTRFS_EXTENT_DATA_KEY)
  525. break;
  526. item_end = found_key.offset;
  527. if (found_type == BTRFS_EXTENT_DATA_KEY) {
  528. fi = btrfs_item_ptr(leaf, path->slots[0],
  529. struct btrfs_file_extent_item);
  530. if (btrfs_file_extent_type(leaf, fi) !=
  531. BTRFS_FILE_EXTENT_INLINE) {
  532. item_end +=
  533. btrfs_file_extent_num_bytes(leaf, fi);
  534. }
  535. }
  536. if (found_type == BTRFS_CSUM_ITEM_KEY) {
  537. ret = btrfs_csum_truncate(trans, root, path,
  538. inode->i_size);
  539. BUG_ON(ret);
  540. }
  541. if (item_end < inode->i_size) {
  542. if (found_type == BTRFS_DIR_ITEM_KEY) {
  543. found_type = BTRFS_INODE_ITEM_KEY;
  544. } else if (found_type == BTRFS_EXTENT_ITEM_KEY) {
  545. found_type = BTRFS_CSUM_ITEM_KEY;
  546. } else if (found_type) {
  547. found_type--;
  548. } else {
  549. break;
  550. }
  551. btrfs_set_key_type(&key, found_type);
  552. continue;
  553. }
  554. if (found_key.offset >= inode->i_size)
  555. del_item = 1;
  556. else
  557. del_item = 0;
  558. found_extent = 0;
  559. /* FIXME, shrink the extent if the ref count is only 1 */
  560. if (found_type == BTRFS_EXTENT_DATA_KEY &&
  561. btrfs_file_extent_type(leaf, fi) !=
  562. BTRFS_FILE_EXTENT_INLINE) {
  563. u64 num_dec;
  564. extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
  565. if (!del_item) {
  566. u64 orig_num_bytes =
  567. btrfs_file_extent_num_bytes(leaf, fi);
  568. extent_num_bytes = inode->i_size -
  569. found_key.offset + root->sectorsize - 1;
  570. btrfs_set_file_extent_num_bytes(leaf, fi,
  571. extent_num_bytes);
  572. num_dec = (orig_num_bytes -
  573. extent_num_bytes) >> 9;
  574. if (extent_start != 0) {
  575. inode->i_blocks -= num_dec;
  576. }
  577. btrfs_mark_buffer_dirty(leaf);
  578. } else {
  579. extent_num_bytes =
  580. btrfs_file_extent_disk_num_bytes(leaf,
  581. fi);
  582. /* FIXME blocksize != 4096 */
  583. num_dec = btrfs_file_extent_num_bytes(leaf,
  584. fi) >> 9;
  585. if (extent_start != 0) {
  586. found_extent = 1;
  587. inode->i_blocks -= num_dec;
  588. }
  589. }
  590. }
  591. if (del_item) {
  592. ret = btrfs_del_item(trans, root, path);
  593. if (ret)
  594. goto error;
  595. } else {
  596. break;
  597. }
  598. btrfs_release_path(root, path);
  599. if (found_extent) {
  600. ret = btrfs_free_extent(trans, root, extent_start,
  601. extent_num_bytes, 0);
  602. BUG_ON(ret);
  603. }
  604. }
  605. ret = 0;
  606. error:
  607. btrfs_release_path(root, path);
  608. btrfs_free_path(path);
  609. inode->i_sb->s_dirt = 1;
  610. return ret;
  611. }
  612. static int btrfs_cow_one_page(struct inode *inode, struct page *page,
  613. size_t zero_start)
  614. {
  615. char *kaddr;
  616. int ret = 0;
  617. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  618. u64 page_start = page->index << PAGE_CACHE_SHIFT;
  619. u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
  620. set_page_extent_mapped(page);
  621. lock_extent(em_tree, page_start, page_end, GFP_NOFS);
  622. set_extent_delalloc(&BTRFS_I(inode)->extent_tree, page_start,
  623. page_end, GFP_NOFS);
  624. if (zero_start != PAGE_CACHE_SIZE) {
  625. kaddr = kmap(page);
  626. memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
  627. flush_dcache_page(page);
  628. kunmap(page);
  629. }
  630. set_page_dirty(page);
  631. unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
  632. return ret;
  633. }
  634. /*
  635. * taken from block_truncate_page, but does cow as it zeros out
  636. * any bytes left in the last page in the file.
  637. */
  638. static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
  639. {
  640. struct inode *inode = mapping->host;
  641. struct btrfs_root *root = BTRFS_I(inode)->root;
  642. u32 blocksize = root->sectorsize;
  643. pgoff_t index = from >> PAGE_CACHE_SHIFT;
  644. unsigned offset = from & (PAGE_CACHE_SIZE-1);
  645. struct page *page;
  646. int ret = 0;
  647. u64 page_start;
  648. if ((offset & (blocksize - 1)) == 0)
  649. goto out;
  650. down_read(&root->snap_sem);
  651. ret = -ENOMEM;
  652. page = grab_cache_page(mapping, index);
  653. if (!page)
  654. goto out;
  655. if (!PageUptodate(page)) {
  656. ret = btrfs_readpage(NULL, page);
  657. lock_page(page);
  658. if (!PageUptodate(page)) {
  659. ret = -EIO;
  660. goto out;
  661. }
  662. }
  663. page_start = page->index << PAGE_CACHE_SHIFT;
  664. ret = btrfs_cow_one_page(inode, page, offset);
  665. unlock_page(page);
  666. page_cache_release(page);
  667. up_read(&BTRFS_I(inode)->root->snap_sem);
  668. out:
  669. return ret;
  670. }
  671. static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
  672. {
  673. struct inode *inode = dentry->d_inode;
  674. int err;
  675. err = inode_change_ok(inode, attr);
  676. if (err)
  677. return err;
  678. if (S_ISREG(inode->i_mode) &&
  679. attr->ia_valid & ATTR_SIZE && attr->ia_size > inode->i_size) {
  680. struct btrfs_trans_handle *trans;
  681. struct btrfs_root *root = BTRFS_I(inode)->root;
  682. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  683. u64 mask = root->sectorsize - 1;
  684. u64 pos = (inode->i_size + mask) & ~mask;
  685. u64 block_end = attr->ia_size | mask;
  686. u64 hole_size;
  687. u64 alloc_hint;
  688. if (attr->ia_size <= pos)
  689. goto out;
  690. btrfs_truncate_page(inode->i_mapping, inode->i_size);
  691. lock_extent(em_tree, pos, block_end, GFP_NOFS);
  692. hole_size = (attr->ia_size - pos + mask) & ~mask;
  693. mutex_lock(&root->fs_info->fs_mutex);
  694. trans = btrfs_start_transaction(root, 1);
  695. btrfs_set_trans_block_group(trans, inode);
  696. err = btrfs_drop_extents(trans, root, inode,
  697. pos, pos + hole_size, &alloc_hint);
  698. err = btrfs_insert_file_extent(trans, root, inode->i_ino,
  699. pos, 0, 0, hole_size);
  700. btrfs_end_transaction(trans, root);
  701. mutex_unlock(&root->fs_info->fs_mutex);
  702. unlock_extent(em_tree, pos, block_end, GFP_NOFS);
  703. if (err)
  704. return err;
  705. }
  706. out:
  707. err = inode_setattr(inode, attr);
  708. return err;
  709. }
  710. void btrfs_delete_inode(struct inode *inode)
  711. {
  712. struct btrfs_trans_handle *trans;
  713. struct btrfs_root *root = BTRFS_I(inode)->root;
  714. unsigned long nr;
  715. int ret;
  716. truncate_inode_pages(&inode->i_data, 0);
  717. if (is_bad_inode(inode)) {
  718. goto no_delete;
  719. }
  720. inode->i_size = 0;
  721. mutex_lock(&root->fs_info->fs_mutex);
  722. trans = btrfs_start_transaction(root, 1);
  723. btrfs_set_trans_block_group(trans, inode);
  724. ret = btrfs_truncate_in_trans(trans, root, inode);
  725. if (ret)
  726. goto no_delete_lock;
  727. ret = btrfs_free_inode(trans, root, inode);
  728. if (ret)
  729. goto no_delete_lock;
  730. nr = trans->blocks_used;
  731. btrfs_end_transaction(trans, root);
  732. mutex_unlock(&root->fs_info->fs_mutex);
  733. btrfs_btree_balance_dirty(root, nr);
  734. return;
  735. no_delete_lock:
  736. nr = trans->blocks_used;
  737. btrfs_end_transaction(trans, root);
  738. mutex_unlock(&root->fs_info->fs_mutex);
  739. btrfs_btree_balance_dirty(root, nr);
  740. no_delete:
  741. clear_inode(inode);
  742. }
  743. /*
  744. * this returns the key found in the dir entry in the location pointer.
  745. * If no dir entries were found, location->objectid is 0.
  746. */
  747. static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
  748. struct btrfs_key *location)
  749. {
  750. const char *name = dentry->d_name.name;
  751. int namelen = dentry->d_name.len;
  752. struct btrfs_dir_item *di;
  753. struct btrfs_path *path;
  754. struct btrfs_root *root = BTRFS_I(dir)->root;
  755. int ret;
  756. path = btrfs_alloc_path();
  757. BUG_ON(!path);
  758. di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
  759. namelen, 0);
  760. if (!di || IS_ERR(di)) {
  761. location->objectid = 0;
  762. ret = 0;
  763. goto out;
  764. }
  765. btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
  766. out:
  767. btrfs_release_path(root, path);
  768. btrfs_free_path(path);
  769. return ret;
  770. }
  771. /*
  772. * when we hit a tree root in a directory, the btrfs part of the inode
  773. * needs to be changed to reflect the root directory of the tree root. This
  774. * is kind of like crossing a mount point.
  775. */
  776. static int fixup_tree_root_location(struct btrfs_root *root,
  777. struct btrfs_key *location,
  778. struct btrfs_root **sub_root,
  779. struct dentry *dentry)
  780. {
  781. struct btrfs_path *path;
  782. struct btrfs_root_item *ri;
  783. if (btrfs_key_type(location) != BTRFS_ROOT_ITEM_KEY)
  784. return 0;
  785. if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
  786. return 0;
  787. path = btrfs_alloc_path();
  788. BUG_ON(!path);
  789. mutex_lock(&root->fs_info->fs_mutex);
  790. *sub_root = btrfs_read_fs_root(root->fs_info, location,
  791. dentry->d_name.name,
  792. dentry->d_name.len);
  793. if (IS_ERR(*sub_root))
  794. return PTR_ERR(*sub_root);
  795. ri = &(*sub_root)->root_item;
  796. location->objectid = btrfs_root_dirid(ri);
  797. btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
  798. location->offset = 0;
  799. btrfs_free_path(path);
  800. mutex_unlock(&root->fs_info->fs_mutex);
  801. return 0;
  802. }
  803. static int btrfs_init_locked_inode(struct inode *inode, void *p)
  804. {
  805. struct btrfs_iget_args *args = p;
  806. inode->i_ino = args->ino;
  807. BTRFS_I(inode)->root = args->root;
  808. extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
  809. inode->i_mapping, GFP_NOFS);
  810. return 0;
  811. }
  812. static int btrfs_find_actor(struct inode *inode, void *opaque)
  813. {
  814. struct btrfs_iget_args *args = opaque;
  815. return (args->ino == inode->i_ino &&
  816. args->root == BTRFS_I(inode)->root);
  817. }
  818. struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
  819. struct btrfs_root *root)
  820. {
  821. struct inode *inode;
  822. struct btrfs_iget_args args;
  823. args.ino = objectid;
  824. args.root = root;
  825. inode = iget5_locked(s, objectid, btrfs_find_actor,
  826. btrfs_init_locked_inode,
  827. (void *)&args);
  828. return inode;
  829. }
  830. static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
  831. struct nameidata *nd)
  832. {
  833. struct inode * inode;
  834. struct btrfs_inode *bi = BTRFS_I(dir);
  835. struct btrfs_root *root = bi->root;
  836. struct btrfs_root *sub_root = root;
  837. struct btrfs_key location;
  838. int ret;
  839. if (dentry->d_name.len > BTRFS_NAME_LEN)
  840. return ERR_PTR(-ENAMETOOLONG);
  841. mutex_lock(&root->fs_info->fs_mutex);
  842. ret = btrfs_inode_by_name(dir, dentry, &location);
  843. mutex_unlock(&root->fs_info->fs_mutex);
  844. if (ret < 0)
  845. return ERR_PTR(ret);
  846. inode = NULL;
  847. if (location.objectid) {
  848. ret = fixup_tree_root_location(root, &location, &sub_root,
  849. dentry);
  850. if (ret < 0)
  851. return ERR_PTR(ret);
  852. if (ret > 0)
  853. return ERR_PTR(-ENOENT);
  854. inode = btrfs_iget_locked(dir->i_sb, location.objectid,
  855. sub_root);
  856. if (!inode)
  857. return ERR_PTR(-EACCES);
  858. if (inode->i_state & I_NEW) {
  859. /* the inode and parent dir are two different roots */
  860. if (sub_root != root) {
  861. igrab(inode);
  862. sub_root->inode = inode;
  863. }
  864. BTRFS_I(inode)->root = sub_root;
  865. memcpy(&BTRFS_I(inode)->location, &location,
  866. sizeof(location));
  867. btrfs_read_locked_inode(inode);
  868. unlock_new_inode(inode);
  869. }
  870. }
  871. return d_splice_alias(inode, dentry);
  872. }
  873. static unsigned char btrfs_filetype_table[] = {
  874. DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
  875. };
  876. static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
  877. {
  878. struct inode *inode = filp->f_path.dentry->d_inode;
  879. struct btrfs_root *root = BTRFS_I(inode)->root;
  880. struct btrfs_item *item;
  881. struct btrfs_dir_item *di;
  882. struct btrfs_key key;
  883. struct btrfs_key found_key;
  884. struct btrfs_path *path;
  885. int ret;
  886. u32 nritems;
  887. struct extent_buffer *leaf;
  888. int slot;
  889. int advance;
  890. unsigned char d_type;
  891. int over = 0;
  892. u32 di_cur;
  893. u32 di_total;
  894. u32 di_len;
  895. int key_type = BTRFS_DIR_INDEX_KEY;
  896. char tmp_name[32];
  897. char *name_ptr;
  898. int name_len;
  899. /* FIXME, use a real flag for deciding about the key type */
  900. if (root->fs_info->tree_root == root)
  901. key_type = BTRFS_DIR_ITEM_KEY;
  902. mutex_lock(&root->fs_info->fs_mutex);
  903. key.objectid = inode->i_ino;
  904. btrfs_set_key_type(&key, key_type);
  905. key.offset = filp->f_pos;
  906. path = btrfs_alloc_path();
  907. path->reada = 2;
  908. ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
  909. if (ret < 0)
  910. goto err;
  911. advance = 0;
  912. while(1) {
  913. leaf = path->nodes[0];
  914. nritems = btrfs_header_nritems(leaf);
  915. slot = path->slots[0];
  916. if (advance || slot >= nritems) {
  917. if (slot >= nritems -1) {
  918. ret = btrfs_next_leaf(root, path);
  919. if (ret)
  920. break;
  921. leaf = path->nodes[0];
  922. nritems = btrfs_header_nritems(leaf);
  923. slot = path->slots[0];
  924. } else {
  925. slot++;
  926. path->slots[0]++;
  927. }
  928. }
  929. advance = 1;
  930. item = btrfs_item_nr(leaf, slot);
  931. btrfs_item_key_to_cpu(leaf, &found_key, slot);
  932. if (found_key.objectid != key.objectid)
  933. break;
  934. if (btrfs_key_type(&found_key) != key_type)
  935. break;
  936. if (found_key.offset < filp->f_pos)
  937. continue;
  938. filp->f_pos = found_key.offset;
  939. advance = 1;
  940. di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
  941. di_cur = 0;
  942. di_total = btrfs_item_size(leaf, item);
  943. while(di_cur < di_total) {
  944. struct btrfs_key location;
  945. name_len = btrfs_dir_name_len(leaf, di);
  946. if (name_len < 32) {
  947. name_ptr = tmp_name;
  948. } else {
  949. name_ptr = kmalloc(name_len, GFP_NOFS);
  950. BUG_ON(!name_ptr);
  951. }
  952. read_extent_buffer(leaf, name_ptr,
  953. (unsigned long)(di + 1), name_len);
  954. d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
  955. btrfs_dir_item_key_to_cpu(leaf, di, &location);
  956. over = filldir(dirent, name_ptr, name_len,
  957. found_key.offset,
  958. location.objectid,
  959. d_type);
  960. if (name_ptr != tmp_name)
  961. kfree(name_ptr);
  962. if (over)
  963. goto nopos;
  964. di_len = btrfs_dir_name_len(leaf, di) + sizeof(*di);
  965. di_cur += di_len;
  966. di = (struct btrfs_dir_item *)((char *)di + di_len);
  967. }
  968. }
  969. filp->f_pos++;
  970. nopos:
  971. ret = 0;
  972. err:
  973. btrfs_release_path(root, path);
  974. btrfs_free_path(path);
  975. mutex_unlock(&root->fs_info->fs_mutex);
  976. return ret;
  977. }
  978. int btrfs_write_inode(struct inode *inode, int wait)
  979. {
  980. struct btrfs_root *root = BTRFS_I(inode)->root;
  981. struct btrfs_trans_handle *trans;
  982. int ret = 0;
  983. if (wait) {
  984. mutex_lock(&root->fs_info->fs_mutex);
  985. trans = btrfs_start_transaction(root, 1);
  986. btrfs_set_trans_block_group(trans, inode);
  987. ret = btrfs_commit_transaction(trans, root);
  988. mutex_unlock(&root->fs_info->fs_mutex);
  989. }
  990. return ret;
  991. }
  992. /*
  993. * This is somewhat expensive, updating the tree every time the
  994. * inode changes. But, it is most likely to find the inode in cache.
  995. * FIXME, needs more benchmarking...there are no reasons other than performance
  996. * to keep or drop this code.
  997. */
  998. void btrfs_dirty_inode(struct inode *inode)
  999. {
  1000. struct btrfs_root *root = BTRFS_I(inode)->root;
  1001. struct btrfs_trans_handle *trans;
  1002. mutex_lock(&root->fs_info->fs_mutex);
  1003. trans = btrfs_start_transaction(root, 1);
  1004. btrfs_set_trans_block_group(trans, inode);
  1005. btrfs_update_inode(trans, root, inode);
  1006. btrfs_end_transaction(trans, root);
  1007. mutex_unlock(&root->fs_info->fs_mutex);
  1008. }
  1009. static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
  1010. struct btrfs_root *root,
  1011. u64 objectid,
  1012. struct btrfs_block_group_cache *group,
  1013. int mode)
  1014. {
  1015. struct inode *inode;
  1016. struct btrfs_inode_item *inode_item;
  1017. struct btrfs_key *location;
  1018. struct btrfs_path *path;
  1019. int ret;
  1020. int owner;
  1021. path = btrfs_alloc_path();
  1022. BUG_ON(!path);
  1023. inode = new_inode(root->fs_info->sb);
  1024. if (!inode)
  1025. return ERR_PTR(-ENOMEM);
  1026. extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
  1027. inode->i_mapping, GFP_NOFS);
  1028. BTRFS_I(inode)->root = root;
  1029. if (mode & S_IFDIR)
  1030. owner = 0;
  1031. else
  1032. owner = 1;
  1033. group = btrfs_find_block_group(root, group, 0, 0, owner);
  1034. BTRFS_I(inode)->block_group = group;
  1035. ret = btrfs_insert_empty_inode(trans, root, path, objectid);
  1036. if (ret)
  1037. goto fail;
  1038. inode->i_uid = current->fsuid;
  1039. inode->i_gid = current->fsgid;
  1040. inode->i_mode = mode;
  1041. inode->i_ino = objectid;
  1042. inode->i_blocks = 0;
  1043. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  1044. inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
  1045. struct btrfs_inode_item);
  1046. fill_inode_item(path->nodes[0], inode_item, inode);
  1047. btrfs_mark_buffer_dirty(path->nodes[0]);
  1048. btrfs_free_path(path);
  1049. location = &BTRFS_I(inode)->location;
  1050. location->objectid = objectid;
  1051. location->offset = 0;
  1052. btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
  1053. insert_inode_hash(inode);
  1054. return inode;
  1055. fail:
  1056. btrfs_free_path(path);
  1057. return ERR_PTR(ret);
  1058. }
  1059. static inline u8 btrfs_inode_type(struct inode *inode)
  1060. {
  1061. return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
  1062. }
  1063. static int btrfs_add_link(struct btrfs_trans_handle *trans,
  1064. struct dentry *dentry, struct inode *inode)
  1065. {
  1066. int ret;
  1067. struct btrfs_key key;
  1068. struct btrfs_root *root = BTRFS_I(dentry->d_parent->d_inode)->root;
  1069. struct inode *parent_inode;
  1070. key.objectid = inode->i_ino;
  1071. btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
  1072. key.offset = 0;
  1073. ret = btrfs_insert_dir_item(trans, root,
  1074. dentry->d_name.name, dentry->d_name.len,
  1075. dentry->d_parent->d_inode->i_ino,
  1076. &key, btrfs_inode_type(inode));
  1077. if (ret == 0) {
  1078. parent_inode = dentry->d_parent->d_inode;
  1079. parent_inode->i_size += dentry->d_name.len * 2;
  1080. parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
  1081. ret = btrfs_update_inode(trans, root,
  1082. dentry->d_parent->d_inode);
  1083. }
  1084. return ret;
  1085. }
  1086. static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
  1087. struct dentry *dentry, struct inode *inode)
  1088. {
  1089. int err = btrfs_add_link(trans, dentry, inode);
  1090. if (!err) {
  1091. d_instantiate(dentry, inode);
  1092. return 0;
  1093. }
  1094. if (err > 0)
  1095. err = -EEXIST;
  1096. return err;
  1097. }
  1098. static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
  1099. int mode, dev_t rdev)
  1100. {
  1101. struct btrfs_trans_handle *trans;
  1102. struct btrfs_root *root = BTRFS_I(dir)->root;
  1103. struct inode *inode;
  1104. int err;
  1105. int drop_inode = 0;
  1106. u64 objectid;
  1107. unsigned long nr;
  1108. if (!new_valid_dev(rdev))
  1109. return -EINVAL;
  1110. mutex_lock(&root->fs_info->fs_mutex);
  1111. trans = btrfs_start_transaction(root, 1);
  1112. btrfs_set_trans_block_group(trans, dir);
  1113. err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
  1114. if (err) {
  1115. err = -ENOSPC;
  1116. goto out_unlock;
  1117. }
  1118. inode = btrfs_new_inode(trans, root, objectid,
  1119. BTRFS_I(dir)->block_group, mode);
  1120. err = PTR_ERR(inode);
  1121. if (IS_ERR(inode))
  1122. goto out_unlock;
  1123. btrfs_set_trans_block_group(trans, inode);
  1124. err = btrfs_add_nondir(trans, dentry, inode);
  1125. if (err)
  1126. drop_inode = 1;
  1127. else {
  1128. inode->i_op = &btrfs_special_inode_operations;
  1129. init_special_inode(inode, inode->i_mode, rdev);
  1130. btrfs_update_inode(trans, root, inode);
  1131. }
  1132. dir->i_sb->s_dirt = 1;
  1133. btrfs_update_inode_block_group(trans, inode);
  1134. btrfs_update_inode_block_group(trans, dir);
  1135. out_unlock:
  1136. nr = trans->blocks_used;
  1137. btrfs_end_transaction(trans, root);
  1138. mutex_unlock(&root->fs_info->fs_mutex);
  1139. if (drop_inode) {
  1140. inode_dec_link_count(inode);
  1141. iput(inode);
  1142. }
  1143. btrfs_btree_balance_dirty(root, nr);
  1144. return err;
  1145. }
  1146. static int btrfs_create(struct inode *dir, struct dentry *dentry,
  1147. int mode, struct nameidata *nd)
  1148. {
  1149. struct btrfs_trans_handle *trans;
  1150. struct btrfs_root *root = BTRFS_I(dir)->root;
  1151. struct inode *inode;
  1152. int err;
  1153. int drop_inode = 0;
  1154. unsigned long nr;
  1155. u64 objectid;
  1156. mutex_lock(&root->fs_info->fs_mutex);
  1157. trans = btrfs_start_transaction(root, 1);
  1158. btrfs_set_trans_block_group(trans, dir);
  1159. err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
  1160. if (err) {
  1161. err = -ENOSPC;
  1162. goto out_unlock;
  1163. }
  1164. inode = btrfs_new_inode(trans, root, objectid,
  1165. BTRFS_I(dir)->block_group, mode);
  1166. err = PTR_ERR(inode);
  1167. if (IS_ERR(inode))
  1168. goto out_unlock;
  1169. btrfs_set_trans_block_group(trans, inode);
  1170. err = btrfs_add_nondir(trans, dentry, inode);
  1171. if (err)
  1172. drop_inode = 1;
  1173. else {
  1174. inode->i_mapping->a_ops = &btrfs_aops;
  1175. inode->i_fop = &btrfs_file_operations;
  1176. inode->i_op = &btrfs_file_inode_operations;
  1177. extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
  1178. inode->i_mapping, GFP_NOFS);
  1179. BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
  1180. }
  1181. dir->i_sb->s_dirt = 1;
  1182. btrfs_update_inode_block_group(trans, inode);
  1183. btrfs_update_inode_block_group(trans, dir);
  1184. out_unlock:
  1185. nr = trans->blocks_used;
  1186. btrfs_end_transaction(trans, root);
  1187. mutex_unlock(&root->fs_info->fs_mutex);
  1188. if (drop_inode) {
  1189. inode_dec_link_count(inode);
  1190. iput(inode);
  1191. }
  1192. btrfs_btree_balance_dirty(root, nr);
  1193. return err;
  1194. }
  1195. static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
  1196. struct dentry *dentry)
  1197. {
  1198. struct btrfs_trans_handle *trans;
  1199. struct btrfs_root *root = BTRFS_I(dir)->root;
  1200. struct inode *inode = old_dentry->d_inode;
  1201. unsigned long nr;
  1202. int err;
  1203. int drop_inode = 0;
  1204. if (inode->i_nlink == 0)
  1205. return -ENOENT;
  1206. inc_nlink(inode);
  1207. mutex_lock(&root->fs_info->fs_mutex);
  1208. trans = btrfs_start_transaction(root, 1);
  1209. btrfs_set_trans_block_group(trans, dir);
  1210. atomic_inc(&inode->i_count);
  1211. err = btrfs_add_nondir(trans, dentry, inode);
  1212. if (err)
  1213. drop_inode = 1;
  1214. dir->i_sb->s_dirt = 1;
  1215. btrfs_update_inode_block_group(trans, dir);
  1216. err = btrfs_update_inode(trans, root, inode);
  1217. if (err)
  1218. drop_inode = 1;
  1219. nr = trans->blocks_used;
  1220. btrfs_end_transaction(trans, root);
  1221. mutex_unlock(&root->fs_info->fs_mutex);
  1222. if (drop_inode) {
  1223. inode_dec_link_count(inode);
  1224. iput(inode);
  1225. }
  1226. btrfs_btree_balance_dirty(root, nr);
  1227. return err;
  1228. }
  1229. static int btrfs_make_empty_dir(struct btrfs_trans_handle *trans,
  1230. struct btrfs_root *root,
  1231. u64 objectid, u64 dirid)
  1232. {
  1233. int ret;
  1234. char buf[2];
  1235. struct btrfs_key key;
  1236. buf[0] = '.';
  1237. buf[1] = '.';
  1238. key.objectid = objectid;
  1239. key.offset = 0;
  1240. btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
  1241. ret = btrfs_insert_dir_item(trans, root, buf, 1, objectid,
  1242. &key, BTRFS_FT_DIR);
  1243. if (ret)
  1244. goto error;
  1245. key.objectid = dirid;
  1246. ret = btrfs_insert_dir_item(trans, root, buf, 2, objectid,
  1247. &key, BTRFS_FT_DIR);
  1248. if (ret)
  1249. goto error;
  1250. error:
  1251. return ret;
  1252. }
  1253. static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  1254. {
  1255. struct inode *inode;
  1256. struct btrfs_trans_handle *trans;
  1257. struct btrfs_root *root = BTRFS_I(dir)->root;
  1258. int err = 0;
  1259. int drop_on_err = 0;
  1260. u64 objectid;
  1261. unsigned long nr = 1;
  1262. mutex_lock(&root->fs_info->fs_mutex);
  1263. trans = btrfs_start_transaction(root, 1);
  1264. btrfs_set_trans_block_group(trans, dir);
  1265. if (IS_ERR(trans)) {
  1266. err = PTR_ERR(trans);
  1267. goto out_unlock;
  1268. }
  1269. err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
  1270. if (err) {
  1271. err = -ENOSPC;
  1272. goto out_unlock;
  1273. }
  1274. inode = btrfs_new_inode(trans, root, objectid,
  1275. BTRFS_I(dir)->block_group, S_IFDIR | mode);
  1276. if (IS_ERR(inode)) {
  1277. err = PTR_ERR(inode);
  1278. goto out_fail;
  1279. }
  1280. drop_on_err = 1;
  1281. inode->i_op = &btrfs_dir_inode_operations;
  1282. inode->i_fop = &btrfs_dir_file_operations;
  1283. btrfs_set_trans_block_group(trans, inode);
  1284. err = btrfs_make_empty_dir(trans, root, inode->i_ino, dir->i_ino);
  1285. if (err)
  1286. goto out_fail;
  1287. inode->i_size = 6;
  1288. err = btrfs_update_inode(trans, root, inode);
  1289. if (err)
  1290. goto out_fail;
  1291. err = btrfs_add_link(trans, dentry, inode);
  1292. if (err)
  1293. goto out_fail;
  1294. d_instantiate(dentry, inode);
  1295. drop_on_err = 0;
  1296. dir->i_sb->s_dirt = 1;
  1297. btrfs_update_inode_block_group(trans, inode);
  1298. btrfs_update_inode_block_group(trans, dir);
  1299. out_fail:
  1300. nr = trans->blocks_used;
  1301. btrfs_end_transaction(trans, root);
  1302. out_unlock:
  1303. mutex_unlock(&root->fs_info->fs_mutex);
  1304. if (drop_on_err)
  1305. iput(inode);
  1306. btrfs_btree_balance_dirty(root, nr);
  1307. return err;
  1308. }
  1309. struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
  1310. size_t page_offset, u64 start, u64 end,
  1311. int create)
  1312. {
  1313. int ret;
  1314. int err = 0;
  1315. u64 bytenr;
  1316. u64 extent_start = 0;
  1317. u64 extent_end = 0;
  1318. u64 objectid = inode->i_ino;
  1319. u32 found_type;
  1320. int failed_insert = 0;
  1321. struct btrfs_path *path;
  1322. struct btrfs_root *root = BTRFS_I(inode)->root;
  1323. struct btrfs_file_extent_item *item;
  1324. struct extent_buffer *leaf;
  1325. struct btrfs_key found_key;
  1326. struct extent_map *em = NULL;
  1327. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  1328. struct btrfs_trans_handle *trans = NULL;
  1329. path = btrfs_alloc_path();
  1330. BUG_ON(!path);
  1331. mutex_lock(&root->fs_info->fs_mutex);
  1332. again:
  1333. em = lookup_extent_mapping(em_tree, start, end);
  1334. if (em) {
  1335. goto out;
  1336. }
  1337. if (!em) {
  1338. em = alloc_extent_map(GFP_NOFS);
  1339. if (!em) {
  1340. err = -ENOMEM;
  1341. goto out;
  1342. }
  1343. em->start = EXTENT_MAP_HOLE;
  1344. em->end = EXTENT_MAP_HOLE;
  1345. }
  1346. em->bdev = inode->i_sb->s_bdev;
  1347. ret = btrfs_lookup_file_extent(NULL, root, path,
  1348. objectid, start, 0);
  1349. if (ret < 0) {
  1350. err = ret;
  1351. goto out;
  1352. }
  1353. if (ret != 0) {
  1354. if (path->slots[0] == 0)
  1355. goto not_found;
  1356. path->slots[0]--;
  1357. }
  1358. leaf = path->nodes[0];
  1359. item = btrfs_item_ptr(leaf, path->slots[0],
  1360. struct btrfs_file_extent_item);
  1361. /* are we inside the extent that was found? */
  1362. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  1363. found_type = btrfs_key_type(&found_key);
  1364. if (found_key.objectid != objectid ||
  1365. found_type != BTRFS_EXTENT_DATA_KEY) {
  1366. goto not_found;
  1367. }
  1368. found_type = btrfs_file_extent_type(leaf, item);
  1369. extent_start = found_key.offset;
  1370. if (found_type == BTRFS_FILE_EXTENT_REG) {
  1371. extent_end = extent_start +
  1372. btrfs_file_extent_num_bytes(leaf, item);
  1373. err = 0;
  1374. if (start < extent_start || start >= extent_end) {
  1375. em->start = start;
  1376. if (start < extent_start) {
  1377. if (end < extent_start)
  1378. goto not_found;
  1379. em->end = extent_end - 1;
  1380. } else {
  1381. em->end = end;
  1382. }
  1383. goto not_found_em;
  1384. }
  1385. bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
  1386. if (bytenr == 0) {
  1387. em->start = extent_start;
  1388. em->end = extent_end - 1;
  1389. em->block_start = EXTENT_MAP_HOLE;
  1390. em->block_end = EXTENT_MAP_HOLE;
  1391. goto insert;
  1392. }
  1393. bytenr += btrfs_file_extent_offset(leaf, item);
  1394. em->block_start = bytenr;
  1395. em->block_end = em->block_start +
  1396. btrfs_file_extent_num_bytes(leaf, item) - 1;
  1397. em->start = extent_start;
  1398. em->end = extent_end - 1;
  1399. goto insert;
  1400. } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
  1401. unsigned long ptr;
  1402. char *map;
  1403. u32 size;
  1404. size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
  1405. path->slots[0]));
  1406. extent_end = (extent_start + size) |
  1407. ((u64)root->sectorsize - 1);
  1408. if (start < extent_start || start >= extent_end) {
  1409. em->start = start;
  1410. if (start < extent_start) {
  1411. if (end < extent_start)
  1412. goto not_found;
  1413. em->end = extent_end;
  1414. } else {
  1415. em->end = end;
  1416. }
  1417. goto not_found_em;
  1418. }
  1419. em->block_start = EXTENT_MAP_INLINE;
  1420. em->block_end = EXTENT_MAP_INLINE;
  1421. em->start = extent_start;
  1422. em->end = extent_end;
  1423. if (!page) {
  1424. goto insert;
  1425. }
  1426. ptr = btrfs_file_extent_inline_start(item);
  1427. map = kmap(page);
  1428. read_extent_buffer(leaf, map + page_offset, ptr, size);
  1429. /*
  1430. memset(map + page_offset + size, 0,
  1431. root->sectorsize - (page_offset + size));
  1432. */
  1433. flush_dcache_page(page);
  1434. kunmap(page);
  1435. set_extent_uptodate(em_tree, extent_start,
  1436. extent_end, GFP_NOFS);
  1437. goto insert;
  1438. } else {
  1439. printk("unkknown found_type %d\n", found_type);
  1440. WARN_ON(1);
  1441. }
  1442. not_found:
  1443. em->start = start;
  1444. em->end = end;
  1445. not_found_em:
  1446. em->block_start = EXTENT_MAP_HOLE;
  1447. em->block_end = EXTENT_MAP_HOLE;
  1448. insert:
  1449. btrfs_release_path(root, path);
  1450. if (em->start > start || em->end < start) {
  1451. printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->end, start, end);
  1452. err = -EIO;
  1453. goto out;
  1454. }
  1455. ret = add_extent_mapping(em_tree, em);
  1456. if (ret == -EEXIST) {
  1457. free_extent_map(em);
  1458. em = NULL;
  1459. failed_insert++;
  1460. if (failed_insert > 5) {
  1461. printk("failing to insert %Lu %Lu\n", start, end);
  1462. err = -EIO;
  1463. goto out;
  1464. }
  1465. goto again;
  1466. }
  1467. err = 0;
  1468. out:
  1469. btrfs_free_path(path);
  1470. if (trans) {
  1471. ret = btrfs_end_transaction(trans, root);
  1472. if (!err)
  1473. err = ret;
  1474. }
  1475. mutex_unlock(&root->fs_info->fs_mutex);
  1476. if (err) {
  1477. free_extent_map(em);
  1478. WARN_ON(1);
  1479. return ERR_PTR(err);
  1480. }
  1481. return em;
  1482. }
  1483. static sector_t btrfs_bmap(struct address_space *mapping, sector_t iblock)
  1484. {
  1485. return extent_bmap(mapping, iblock, btrfs_get_extent);
  1486. }
  1487. static int btrfs_prepare_write(struct file *file, struct page *page,
  1488. unsigned from, unsigned to)
  1489. {
  1490. return extent_prepare_write(&BTRFS_I(page->mapping->host)->extent_tree,
  1491. page->mapping->host, page, from, to,
  1492. btrfs_get_extent);
  1493. }
  1494. int btrfs_readpage(struct file *file, struct page *page)
  1495. {
  1496. struct extent_map_tree *tree;
  1497. tree = &BTRFS_I(page->mapping->host)->extent_tree;
  1498. return extent_read_full_page(tree, page, btrfs_get_extent);
  1499. }
  1500. static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
  1501. {
  1502. struct extent_map_tree *tree;
  1503. if (current->flags & PF_MEMALLOC) {
  1504. redirty_page_for_writepage(wbc, page);
  1505. unlock_page(page);
  1506. return 0;
  1507. }
  1508. tree = &BTRFS_I(page->mapping->host)->extent_tree;
  1509. return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
  1510. }
  1511. static int btrfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
  1512. {
  1513. struct extent_map_tree *tree;
  1514. int ret;
  1515. if (page->private != 1) {
  1516. WARN_ON(1);
  1517. return try_to_free_buffers(page);
  1518. }
  1519. tree = &BTRFS_I(page->mapping->host)->extent_tree;
  1520. ret = try_release_extent_mapping(tree, page);
  1521. if (ret == 1) {
  1522. ClearPagePrivate(page);
  1523. set_page_private(page, 0);
  1524. page_cache_release(page);
  1525. }
  1526. return ret;
  1527. }
  1528. static void btrfs_invalidatepage(struct page *page, unsigned long offset)
  1529. {
  1530. struct extent_map_tree *tree;
  1531. tree = &BTRFS_I(page->mapping->host)->extent_tree;
  1532. extent_invalidatepage(tree, page, offset);
  1533. btrfs_releasepage(page, GFP_NOFS);
  1534. }
  1535. /*
  1536. * btrfs_page_mkwrite() is not allowed to change the file size as it gets
  1537. * called from a page fault handler when a page is first dirtied. Hence we must
  1538. * be careful to check for EOF conditions here. We set the page up correctly
  1539. * for a written page which means we get ENOSPC checking when writing into
  1540. * holes and correct delalloc and unwritten extent mapping on filesystems that
  1541. * support these features.
  1542. *
  1543. * We are not allowed to take the i_mutex here so we have to play games to
  1544. * protect against truncate races as the page could now be beyond EOF. Because
  1545. * vmtruncate() writes the inode size before removing pages, once we have the
  1546. * page lock we can determine safely if the page is beyond EOF. If it is not
  1547. * beyond EOF, then the page is guaranteed safe against truncation until we
  1548. * unlock the page.
  1549. */
  1550. int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page)
  1551. {
  1552. struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
  1553. unsigned long end;
  1554. loff_t size;
  1555. int ret = -EINVAL;
  1556. u64 page_start;
  1557. down_read(&BTRFS_I(inode)->root->snap_sem);
  1558. lock_page(page);
  1559. wait_on_page_writeback(page);
  1560. size = i_size_read(inode);
  1561. page_start = page->index << PAGE_CACHE_SHIFT;
  1562. if ((page->mapping != inode->i_mapping) ||
  1563. (page_start > size)) {
  1564. /* page got truncated out from underneath us */
  1565. goto out_unlock;
  1566. }
  1567. /* page is wholly or partially inside EOF */
  1568. if (page_start + PAGE_CACHE_SIZE > size)
  1569. end = size & ~PAGE_CACHE_MASK;
  1570. else
  1571. end = PAGE_CACHE_SIZE;
  1572. ret = btrfs_cow_one_page(inode, page, end);
  1573. out_unlock:
  1574. up_read(&BTRFS_I(inode)->root->snap_sem);
  1575. unlock_page(page);
  1576. return ret;
  1577. }
  1578. static void btrfs_truncate(struct inode *inode)
  1579. {
  1580. struct btrfs_root *root = BTRFS_I(inode)->root;
  1581. int ret;
  1582. struct btrfs_trans_handle *trans;
  1583. unsigned long nr;
  1584. if (!S_ISREG(inode->i_mode))
  1585. return;
  1586. if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
  1587. return;
  1588. btrfs_truncate_page(inode->i_mapping, inode->i_size);
  1589. mutex_lock(&root->fs_info->fs_mutex);
  1590. trans = btrfs_start_transaction(root, 1);
  1591. btrfs_set_trans_block_group(trans, inode);
  1592. /* FIXME, add redo link to tree so we don't leak on crash */
  1593. ret = btrfs_truncate_in_trans(trans, root, inode);
  1594. btrfs_update_inode(trans, root, inode);
  1595. nr = trans->blocks_used;
  1596. ret = btrfs_end_transaction(trans, root);
  1597. BUG_ON(ret);
  1598. mutex_unlock(&root->fs_info->fs_mutex);
  1599. btrfs_btree_balance_dirty(root, nr);
  1600. }
  1601. int btrfs_commit_write(struct file *file, struct page *page,
  1602. unsigned from, unsigned to)
  1603. {
  1604. return extent_commit_write(&BTRFS_I(page->mapping->host)->extent_tree,
  1605. page->mapping->host, page, from, to);
  1606. }
  1607. static int create_subvol(struct btrfs_root *root, char *name, int namelen)
  1608. {
  1609. struct btrfs_trans_handle *trans;
  1610. struct btrfs_key key;
  1611. struct btrfs_root_item root_item;
  1612. struct btrfs_inode_item *inode_item;
  1613. struct extent_buffer *leaf;
  1614. struct btrfs_root *new_root;
  1615. struct inode *inode;
  1616. struct inode *dir;
  1617. int ret;
  1618. int err;
  1619. u64 objectid;
  1620. u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
  1621. unsigned long nr = 1;
  1622. mutex_lock(&root->fs_info->fs_mutex);
  1623. trans = btrfs_start_transaction(root, 1);
  1624. BUG_ON(!trans);
  1625. leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0, 0);
  1626. if (IS_ERR(leaf))
  1627. return PTR_ERR(leaf);
  1628. btrfs_set_header_nritems(leaf, 0);
  1629. btrfs_set_header_level(leaf, 0);
  1630. btrfs_set_header_bytenr(leaf, leaf->start);
  1631. btrfs_set_header_generation(leaf, trans->transid);
  1632. btrfs_set_header_owner(leaf, root->root_key.objectid);
  1633. write_extent_buffer(leaf, root->fs_info->fsid,
  1634. (unsigned long)btrfs_header_fsid(leaf),
  1635. BTRFS_FSID_SIZE);
  1636. btrfs_mark_buffer_dirty(leaf);
  1637. inode_item = &root_item.inode;
  1638. memset(inode_item, 0, sizeof(*inode_item));
  1639. inode_item->generation = cpu_to_le64(1);
  1640. inode_item->size = cpu_to_le64(3);
  1641. inode_item->nlink = cpu_to_le32(1);
  1642. inode_item->nblocks = cpu_to_le64(1);
  1643. inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
  1644. btrfs_set_root_bytenr(&root_item, leaf->start);
  1645. btrfs_set_root_level(&root_item, 0);
  1646. btrfs_set_root_refs(&root_item, 1);
  1647. btrfs_set_root_used(&root_item, 0);
  1648. memset(&root_item.drop_progress, 0, sizeof(root_item.drop_progress));
  1649. root_item.drop_level = 0;
  1650. free_extent_buffer(leaf);
  1651. leaf = NULL;
  1652. ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
  1653. 0, &objectid);
  1654. if (ret)
  1655. goto fail;
  1656. btrfs_set_root_dirid(&root_item, new_dirid);
  1657. key.objectid = objectid;
  1658. key.offset = 1;
  1659. btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
  1660. ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
  1661. &root_item);
  1662. if (ret)
  1663. goto fail;
  1664. /*
  1665. * insert the directory item
  1666. */
  1667. key.offset = (u64)-1;
  1668. dir = root->fs_info->sb->s_root->d_inode;
  1669. ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
  1670. name, namelen, dir->i_ino, &key,
  1671. BTRFS_FT_DIR);
  1672. if (ret)
  1673. goto fail;
  1674. ret = btrfs_commit_transaction(trans, root);
  1675. if (ret)
  1676. goto fail_commit;
  1677. new_root = btrfs_read_fs_root(root->fs_info, &key, name, namelen);
  1678. BUG_ON(!new_root);
  1679. trans = btrfs_start_transaction(new_root, 1);
  1680. BUG_ON(!trans);
  1681. inode = btrfs_new_inode(trans, new_root, new_dirid,
  1682. BTRFS_I(dir)->block_group, S_IFDIR | 0700);
  1683. if (IS_ERR(inode))
  1684. goto fail;
  1685. inode->i_op = &btrfs_dir_inode_operations;
  1686. inode->i_fop = &btrfs_dir_file_operations;
  1687. new_root->inode = inode;
  1688. ret = btrfs_make_empty_dir(trans, new_root, new_dirid, new_dirid);
  1689. if (ret)
  1690. goto fail;
  1691. inode->i_nlink = 1;
  1692. inode->i_size = 6;
  1693. ret = btrfs_update_inode(trans, new_root, inode);
  1694. if (ret)
  1695. goto fail;
  1696. fail:
  1697. nr = trans->blocks_used;
  1698. err = btrfs_commit_transaction(trans, root);
  1699. if (err && !ret)
  1700. ret = err;
  1701. fail_commit:
  1702. mutex_unlock(&root->fs_info->fs_mutex);
  1703. btrfs_btree_balance_dirty(root, nr);
  1704. return ret;
  1705. }
  1706. static int create_snapshot(struct btrfs_root *root, char *name, int namelen)
  1707. {
  1708. struct btrfs_trans_handle *trans;
  1709. struct btrfs_key key;
  1710. struct btrfs_root_item new_root_item;
  1711. struct extent_buffer *tmp;
  1712. int ret;
  1713. int err;
  1714. u64 objectid;
  1715. unsigned long nr;
  1716. if (!root->ref_cows)
  1717. return -EINVAL;
  1718. down_write(&root->snap_sem);
  1719. freeze_bdev(root->fs_info->sb->s_bdev);
  1720. thaw_bdev(root->fs_info->sb->s_bdev, root->fs_info->sb);
  1721. mutex_lock(&root->fs_info->fs_mutex);
  1722. trans = btrfs_start_transaction(root, 1);
  1723. BUG_ON(!trans);
  1724. ret = btrfs_update_inode(trans, root, root->inode);
  1725. if (ret)
  1726. goto fail;
  1727. ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
  1728. 0, &objectid);
  1729. if (ret)
  1730. goto fail;
  1731. memcpy(&new_root_item, &root->root_item,
  1732. sizeof(new_root_item));
  1733. key.objectid = objectid;
  1734. key.offset = 1;
  1735. btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
  1736. btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp);
  1737. btrfs_set_root_bytenr(&new_root_item, root->node->start);
  1738. btrfs_set_root_level(&new_root_item, btrfs_header_level(root->node));
  1739. ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
  1740. &new_root_item);
  1741. if (ret)
  1742. goto fail;
  1743. /*
  1744. * insert the directory item
  1745. */
  1746. key.offset = (u64)-1;
  1747. ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
  1748. name, namelen,
  1749. root->fs_info->sb->s_root->d_inode->i_ino,
  1750. &key, BTRFS_FT_DIR);
  1751. if (ret)
  1752. goto fail;
  1753. ret = btrfs_inc_root_ref(trans, root);
  1754. if (ret)
  1755. goto fail;
  1756. fail:
  1757. nr = trans->blocks_used;
  1758. err = btrfs_commit_transaction(trans, root);
  1759. if (err && !ret)
  1760. ret = err;
  1761. mutex_unlock(&root->fs_info->fs_mutex);
  1762. up_write(&root->snap_sem);
  1763. btrfs_btree_balance_dirty(root, nr);
  1764. return ret;
  1765. }
  1766. static unsigned long force_ra(struct address_space *mapping,
  1767. struct file_ra_state *ra, struct file *file,
  1768. pgoff_t offset, pgoff_t last_index)
  1769. {
  1770. pgoff_t req_size;
  1771. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
  1772. req_size = last_index - offset + 1;
  1773. offset = page_cache_readahead(mapping, ra, file, offset, req_size);
  1774. return offset;
  1775. #else
  1776. req_size = min(last_index - offset + 1, (pgoff_t)128);
  1777. page_cache_sync_readahead(mapping, ra, file, offset, req_size);
  1778. return offset + req_size;
  1779. #endif
  1780. }
  1781. int btrfs_defrag_file(struct file *file) {
  1782. struct inode *inode = file->f_path.dentry->d_inode;
  1783. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  1784. struct page *page;
  1785. unsigned long last_index;
  1786. unsigned long ra_index = 0;
  1787. u64 page_start;
  1788. u64 page_end;
  1789. unsigned long i;
  1790. mutex_lock(&inode->i_mutex);
  1791. last_index = inode->i_size >> PAGE_CACHE_SHIFT;
  1792. for (i = 0; i <= last_index; i++) {
  1793. if (i == ra_index) {
  1794. ra_index = force_ra(inode->i_mapping, &file->f_ra,
  1795. file, ra_index, last_index);
  1796. }
  1797. page = grab_cache_page(inode->i_mapping, i);
  1798. if (!page)
  1799. goto out_unlock;
  1800. if (!PageUptodate(page)) {
  1801. btrfs_readpage(NULL, page);
  1802. lock_page(page);
  1803. if (!PageUptodate(page)) {
  1804. unlock_page(page);
  1805. page_cache_release(page);
  1806. goto out_unlock;
  1807. }
  1808. }
  1809. page_start = page->index << PAGE_CACHE_SHIFT;
  1810. page_end = page_start + PAGE_CACHE_SIZE - 1;
  1811. lock_extent(em_tree, page_start, page_end, GFP_NOFS);
  1812. set_extent_delalloc(em_tree, page_start,
  1813. page_end, GFP_NOFS);
  1814. unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
  1815. set_page_dirty(page);
  1816. unlock_page(page);
  1817. page_cache_release(page);
  1818. balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1);
  1819. }
  1820. out_unlock:
  1821. mutex_unlock(&inode->i_mutex);
  1822. return 0;
  1823. }
  1824. static int btrfs_ioctl_snap_create(struct btrfs_root *root, void __user *arg)
  1825. {
  1826. struct btrfs_ioctl_vol_args vol_args;
  1827. struct btrfs_dir_item *di;
  1828. struct btrfs_path *path;
  1829. int namelen;
  1830. u64 root_dirid;
  1831. if (copy_from_user(&vol_args, arg, sizeof(vol_args)))
  1832. return -EFAULT;
  1833. namelen = strlen(vol_args.name);
  1834. if (namelen > BTRFS_VOL_NAME_MAX)
  1835. return -EINVAL;
  1836. if (strchr(vol_args.name, '/'))
  1837. return -EINVAL;
  1838. path = btrfs_alloc_path();
  1839. if (!path)
  1840. return -ENOMEM;
  1841. root_dirid = root->fs_info->sb->s_root->d_inode->i_ino,
  1842. mutex_lock(&root->fs_info->fs_mutex);
  1843. di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root,
  1844. path, root_dirid,
  1845. vol_args.name, namelen, 0);
  1846. mutex_unlock(&root->fs_info->fs_mutex);
  1847. btrfs_free_path(path);
  1848. if (di && !IS_ERR(di))
  1849. return -EEXIST;
  1850. if (IS_ERR(di))
  1851. return PTR_ERR(di);
  1852. if (root == root->fs_info->tree_root)
  1853. return create_subvol(root, vol_args.name, namelen);
  1854. return create_snapshot(root, vol_args.name, namelen);
  1855. }
  1856. static int btrfs_ioctl_defrag(struct file *file)
  1857. {
  1858. struct inode *inode = file->f_path.dentry->d_inode;
  1859. struct btrfs_root *root = BTRFS_I(inode)->root;
  1860. switch (inode->i_mode & S_IFMT) {
  1861. case S_IFDIR:
  1862. mutex_lock(&root->fs_info->fs_mutex);
  1863. btrfs_defrag_root(root, 0);
  1864. btrfs_defrag_root(root->fs_info->extent_root, 0);
  1865. mutex_unlock(&root->fs_info->fs_mutex);
  1866. break;
  1867. case S_IFREG:
  1868. btrfs_defrag_file(file);
  1869. break;
  1870. }
  1871. return 0;
  1872. }
  1873. long btrfs_ioctl(struct file *file, unsigned int
  1874. cmd, unsigned long arg)
  1875. {
  1876. struct btrfs_root *root = BTRFS_I(file->f_path.dentry->d_inode)->root;
  1877. switch (cmd) {
  1878. case BTRFS_IOC_SNAP_CREATE:
  1879. return btrfs_ioctl_snap_create(root, (void __user *)arg);
  1880. case BTRFS_IOC_DEFRAG:
  1881. return btrfs_ioctl_defrag(file);
  1882. }
  1883. return -ENOTTY;
  1884. }
  1885. /*
  1886. * Called inside transaction, so use GFP_NOFS
  1887. */
  1888. struct inode *btrfs_alloc_inode(struct super_block *sb)
  1889. {
  1890. struct btrfs_inode *ei;
  1891. ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
  1892. if (!ei)
  1893. return NULL;
  1894. ei->last_trans = 0;
  1895. return &ei->vfs_inode;
  1896. }
  1897. void btrfs_destroy_inode(struct inode *inode)
  1898. {
  1899. WARN_ON(!list_empty(&inode->i_dentry));
  1900. WARN_ON(inode->i_data.nrpages);
  1901. kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
  1902. }
  1903. static void init_once(void * foo, struct kmem_cache * cachep,
  1904. unsigned long flags)
  1905. {
  1906. struct btrfs_inode *ei = (struct btrfs_inode *) foo;
  1907. inode_init_once(&ei->vfs_inode);
  1908. }
  1909. void btrfs_destroy_cachep(void)
  1910. {
  1911. if (btrfs_inode_cachep)
  1912. kmem_cache_destroy(btrfs_inode_cachep);
  1913. if (btrfs_trans_handle_cachep)
  1914. kmem_cache_destroy(btrfs_trans_handle_cachep);
  1915. if (btrfs_transaction_cachep)
  1916. kmem_cache_destroy(btrfs_transaction_cachep);
  1917. if (btrfs_bit_radix_cachep)
  1918. kmem_cache_destroy(btrfs_bit_radix_cachep);
  1919. if (btrfs_path_cachep)
  1920. kmem_cache_destroy(btrfs_path_cachep);
  1921. }
  1922. struct kmem_cache *btrfs_cache_create(const char *name, size_t size,
  1923. unsigned long extra_flags,
  1924. void (*ctor)(void *, struct kmem_cache *,
  1925. unsigned long))
  1926. {
  1927. return kmem_cache_create(name, size, 0, (SLAB_RECLAIM_ACCOUNT |
  1928. SLAB_MEM_SPREAD | extra_flags), ctor
  1929. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
  1930. ,NULL
  1931. #endif
  1932. );
  1933. }
  1934. int btrfs_init_cachep(void)
  1935. {
  1936. btrfs_inode_cachep = btrfs_cache_create("btrfs_inode_cache",
  1937. sizeof(struct btrfs_inode),
  1938. 0, init_once);
  1939. if (!btrfs_inode_cachep)
  1940. goto fail;
  1941. btrfs_trans_handle_cachep =
  1942. btrfs_cache_create("btrfs_trans_handle_cache",
  1943. sizeof(struct btrfs_trans_handle),
  1944. 0, NULL);
  1945. if (!btrfs_trans_handle_cachep)
  1946. goto fail;
  1947. btrfs_transaction_cachep = btrfs_cache_create("btrfs_transaction_cache",
  1948. sizeof(struct btrfs_transaction),
  1949. 0, NULL);
  1950. if (!btrfs_transaction_cachep)
  1951. goto fail;
  1952. btrfs_path_cachep = btrfs_cache_create("btrfs_path_cache",
  1953. sizeof(struct btrfs_path),
  1954. 0, NULL);
  1955. if (!btrfs_path_cachep)
  1956. goto fail;
  1957. btrfs_bit_radix_cachep = btrfs_cache_create("btrfs_radix", 256,
  1958. SLAB_DESTROY_BY_RCU, NULL);
  1959. if (!btrfs_bit_radix_cachep)
  1960. goto fail;
  1961. return 0;
  1962. fail:
  1963. btrfs_destroy_cachep();
  1964. return -ENOMEM;
  1965. }
  1966. static int btrfs_getattr(struct vfsmount *mnt,
  1967. struct dentry *dentry, struct kstat *stat)
  1968. {
  1969. struct inode *inode = dentry->d_inode;
  1970. generic_fillattr(inode, stat);
  1971. stat->blksize = 256 * 1024;
  1972. return 0;
  1973. }
  1974. static int btrfs_rename(struct inode * old_dir, struct dentry *old_dentry,
  1975. struct inode * new_dir,struct dentry *new_dentry)
  1976. {
  1977. struct btrfs_trans_handle *trans;
  1978. struct btrfs_root *root = BTRFS_I(old_dir)->root;
  1979. struct inode *new_inode = new_dentry->d_inode;
  1980. struct inode *old_inode = old_dentry->d_inode;
  1981. struct timespec ctime = CURRENT_TIME;
  1982. struct btrfs_path *path;
  1983. struct btrfs_dir_item *di;
  1984. int ret;
  1985. if (S_ISDIR(old_inode->i_mode) && new_inode &&
  1986. new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
  1987. return -ENOTEMPTY;
  1988. }
  1989. mutex_lock(&root->fs_info->fs_mutex);
  1990. trans = btrfs_start_transaction(root, 1);
  1991. btrfs_set_trans_block_group(trans, new_dir);
  1992. path = btrfs_alloc_path();
  1993. if (!path) {
  1994. ret = -ENOMEM;
  1995. goto out_fail;
  1996. }
  1997. old_dentry->d_inode->i_nlink++;
  1998. old_dir->i_ctime = old_dir->i_mtime = ctime;
  1999. new_dir->i_ctime = new_dir->i_mtime = ctime;
  2000. old_inode->i_ctime = ctime;
  2001. if (S_ISDIR(old_inode->i_mode) && old_dir != new_dir) {
  2002. struct btrfs_key *location = &BTRFS_I(new_dir)->location;
  2003. struct btrfs_key old_parent_key;
  2004. di = btrfs_lookup_dir_item(trans, root, path, old_inode->i_ino,
  2005. "..", 2, -1);
  2006. if (IS_ERR(di)) {
  2007. ret = PTR_ERR(di);
  2008. goto out_fail;
  2009. }
  2010. if (!di) {
  2011. ret = -ENOENT;
  2012. goto out_fail;
  2013. }
  2014. btrfs_dir_item_key_to_cpu(path->nodes[0], di, &old_parent_key);
  2015. ret = btrfs_del_item(trans, root, path);
  2016. if (ret) {
  2017. goto out_fail;
  2018. }
  2019. btrfs_release_path(root, path);
  2020. di = btrfs_lookup_dir_index_item(trans, root, path,
  2021. old_inode->i_ino,
  2022. old_parent_key.objectid,
  2023. "..", 2, -1);
  2024. if (IS_ERR(di)) {
  2025. ret = PTR_ERR(di);
  2026. goto out_fail;
  2027. }
  2028. if (!di) {
  2029. ret = -ENOENT;
  2030. goto out_fail;
  2031. }
  2032. ret = btrfs_del_item(trans, root, path);
  2033. if (ret) {
  2034. goto out_fail;
  2035. }
  2036. btrfs_release_path(root, path);
  2037. ret = btrfs_insert_dir_item(trans, root, "..", 2,
  2038. old_inode->i_ino, location,
  2039. BTRFS_FT_DIR);
  2040. if (ret)
  2041. goto out_fail;
  2042. }
  2043. ret = btrfs_unlink_trans(trans, root, old_dir, old_dentry);
  2044. if (ret)
  2045. goto out_fail;
  2046. if (new_inode) {
  2047. new_inode->i_ctime = CURRENT_TIME;
  2048. ret = btrfs_unlink_trans(trans, root, new_dir, new_dentry);
  2049. if (ret)
  2050. goto out_fail;
  2051. }
  2052. ret = btrfs_add_link(trans, new_dentry, old_inode);
  2053. if (ret)
  2054. goto out_fail;
  2055. out_fail:
  2056. btrfs_free_path(path);
  2057. btrfs_end_transaction(trans, root);
  2058. mutex_unlock(&root->fs_info->fs_mutex);
  2059. return ret;
  2060. }
  2061. static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
  2062. const char *symname)
  2063. {
  2064. struct btrfs_trans_handle *trans;
  2065. struct btrfs_root *root = BTRFS_I(dir)->root;
  2066. struct btrfs_path *path;
  2067. struct btrfs_key key;
  2068. struct inode *inode;
  2069. int err;
  2070. int drop_inode = 0;
  2071. u64 objectid;
  2072. int name_len;
  2073. int datasize;
  2074. unsigned long ptr;
  2075. struct btrfs_file_extent_item *ei;
  2076. struct extent_buffer *leaf;
  2077. unsigned long nr;
  2078. name_len = strlen(symname) + 1;
  2079. if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
  2080. return -ENAMETOOLONG;
  2081. mutex_lock(&root->fs_info->fs_mutex);
  2082. trans = btrfs_start_transaction(root, 1);
  2083. btrfs_set_trans_block_group(trans, dir);
  2084. err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
  2085. if (err) {
  2086. err = -ENOSPC;
  2087. goto out_unlock;
  2088. }
  2089. inode = btrfs_new_inode(trans, root, objectid,
  2090. BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO);
  2091. err = PTR_ERR(inode);
  2092. if (IS_ERR(inode))
  2093. goto out_unlock;
  2094. btrfs_set_trans_block_group(trans, inode);
  2095. err = btrfs_add_nondir(trans, dentry, inode);
  2096. if (err)
  2097. drop_inode = 1;
  2098. else {
  2099. inode->i_mapping->a_ops = &btrfs_aops;
  2100. inode->i_fop = &btrfs_file_operations;
  2101. inode->i_op = &btrfs_file_inode_operations;
  2102. extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
  2103. inode->i_mapping, GFP_NOFS);
  2104. BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
  2105. }
  2106. dir->i_sb->s_dirt = 1;
  2107. btrfs_update_inode_block_group(trans, inode);
  2108. btrfs_update_inode_block_group(trans, dir);
  2109. if (drop_inode)
  2110. goto out_unlock;
  2111. path = btrfs_alloc_path();
  2112. BUG_ON(!path);
  2113. key.objectid = inode->i_ino;
  2114. key.offset = 0;
  2115. btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
  2116. datasize = btrfs_file_extent_calc_inline_size(name_len);
  2117. err = btrfs_insert_empty_item(trans, root, path, &key,
  2118. datasize);
  2119. if (err) {
  2120. drop_inode = 1;
  2121. goto out_unlock;
  2122. }
  2123. leaf = path->nodes[0];
  2124. ei = btrfs_item_ptr(leaf, path->slots[0],
  2125. struct btrfs_file_extent_item);
  2126. btrfs_set_file_extent_generation(leaf, ei, trans->transid);
  2127. btrfs_set_file_extent_type(leaf, ei,
  2128. BTRFS_FILE_EXTENT_INLINE);
  2129. ptr = btrfs_file_extent_inline_start(ei);
  2130. write_extent_buffer(leaf, symname, ptr, name_len);
  2131. btrfs_mark_buffer_dirty(leaf);
  2132. btrfs_free_path(path);
  2133. inode->i_op = &btrfs_symlink_inode_operations;
  2134. inode->i_mapping->a_ops = &btrfs_symlink_aops;
  2135. inode->i_size = name_len - 1;
  2136. err = btrfs_update_inode(trans, root, inode);
  2137. if (err)
  2138. drop_inode = 1;
  2139. out_unlock:
  2140. nr = trans->blocks_used;
  2141. btrfs_end_transaction(trans, root);
  2142. mutex_unlock(&root->fs_info->fs_mutex);
  2143. if (drop_inode) {
  2144. inode_dec_link_count(inode);
  2145. iput(inode);
  2146. }
  2147. btrfs_btree_balance_dirty(root, nr);
  2148. return err;
  2149. }
  2150. static struct inode_operations btrfs_dir_inode_operations = {
  2151. .lookup = btrfs_lookup,
  2152. .create = btrfs_create,
  2153. .unlink = btrfs_unlink,
  2154. .link = btrfs_link,
  2155. .mkdir = btrfs_mkdir,
  2156. .rmdir = btrfs_rmdir,
  2157. .rename = btrfs_rename,
  2158. .symlink = btrfs_symlink,
  2159. .setattr = btrfs_setattr,
  2160. .mknod = btrfs_mknod,
  2161. };
  2162. static struct inode_operations btrfs_dir_ro_inode_operations = {
  2163. .lookup = btrfs_lookup,
  2164. };
  2165. static struct file_operations btrfs_dir_file_operations = {
  2166. .llseek = generic_file_llseek,
  2167. .read = generic_read_dir,
  2168. .readdir = btrfs_readdir,
  2169. .unlocked_ioctl = btrfs_ioctl,
  2170. #ifdef CONFIG_COMPAT
  2171. .compat_ioctl = btrfs_ioctl,
  2172. #endif
  2173. };
  2174. static struct extent_map_ops btrfs_extent_map_ops = {
  2175. .fill_delalloc = run_delalloc_range,
  2176. .writepage_io_hook = btrfs_writepage_io_hook,
  2177. .readpage_io_hook = btrfs_readpage_io_hook,
  2178. .readpage_end_io_hook = btrfs_readpage_end_io_hook,
  2179. };
  2180. static struct address_space_operations btrfs_aops = {
  2181. .readpage = btrfs_readpage,
  2182. .writepage = btrfs_writepage,
  2183. .sync_page = block_sync_page,
  2184. .prepare_write = btrfs_prepare_write,
  2185. .commit_write = btrfs_commit_write,
  2186. .bmap = btrfs_bmap,
  2187. .invalidatepage = btrfs_invalidatepage,
  2188. .releasepage = btrfs_releasepage,
  2189. .set_page_dirty = __set_page_dirty_nobuffers,
  2190. };
  2191. static struct address_space_operations btrfs_symlink_aops = {
  2192. .readpage = btrfs_readpage,
  2193. .writepage = btrfs_writepage,
  2194. .invalidatepage = btrfs_invalidatepage,
  2195. .releasepage = btrfs_releasepage,
  2196. };
  2197. static struct inode_operations btrfs_file_inode_operations = {
  2198. .truncate = btrfs_truncate,
  2199. .getattr = btrfs_getattr,
  2200. .setattr = btrfs_setattr,
  2201. };
  2202. static struct inode_operations btrfs_special_inode_operations = {
  2203. .getattr = btrfs_getattr,
  2204. .setattr = btrfs_setattr,
  2205. };
  2206. static struct inode_operations btrfs_symlink_inode_operations = {
  2207. .readlink = generic_readlink,
  2208. .follow_link = page_follow_link_light,
  2209. .put_link = page_put_link,
  2210. };