inode.c 64 KB

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