tree-log.c 85 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288
  1. /*
  2. * Copyright (C) 2008 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/sched.h>
  19. #include <linux/slab.h>
  20. #include "ctree.h"
  21. #include "transaction.h"
  22. #include "disk-io.h"
  23. #include "locking.h"
  24. #include "print-tree.h"
  25. #include "compat.h"
  26. #include "tree-log.h"
  27. /* magic values for the inode_only field in btrfs_log_inode:
  28. *
  29. * LOG_INODE_ALL means to log everything
  30. * LOG_INODE_EXISTS means to log just enough to recreate the inode
  31. * during log replay
  32. */
  33. #define LOG_INODE_ALL 0
  34. #define LOG_INODE_EXISTS 1
  35. /*
  36. * directory trouble cases
  37. *
  38. * 1) on rename or unlink, if the inode being unlinked isn't in the fsync
  39. * log, we must force a full commit before doing an fsync of the directory
  40. * where the unlink was done.
  41. * ---> record transid of last unlink/rename per directory
  42. *
  43. * mkdir foo/some_dir
  44. * normal commit
  45. * rename foo/some_dir foo2/some_dir
  46. * mkdir foo/some_dir
  47. * fsync foo/some_dir/some_file
  48. *
  49. * The fsync above will unlink the original some_dir without recording
  50. * it in its new location (foo2). After a crash, some_dir will be gone
  51. * unless the fsync of some_file forces a full commit
  52. *
  53. * 2) we must log any new names for any file or dir that is in the fsync
  54. * log. ---> check inode while renaming/linking.
  55. *
  56. * 2a) we must log any new names for any file or dir during rename
  57. * when the directory they are being removed from was logged.
  58. * ---> check inode and old parent dir during rename
  59. *
  60. * 2a is actually the more important variant. With the extra logging
  61. * a crash might unlink the old name without recreating the new one
  62. *
  63. * 3) after a crash, we must go through any directories with a link count
  64. * of zero and redo the rm -rf
  65. *
  66. * mkdir f1/foo
  67. * normal commit
  68. * rm -rf f1/foo
  69. * fsync(f1)
  70. *
  71. * The directory f1 was fully removed from the FS, but fsync was never
  72. * called on f1, only its parent dir. After a crash the rm -rf must
  73. * be replayed. This must be able to recurse down the entire
  74. * directory tree. The inode link count fixup code takes care of the
  75. * ugly details.
  76. */
  77. /*
  78. * stages for the tree walking. The first
  79. * stage (0) is to only pin down the blocks we find
  80. * the second stage (1) is to make sure that all the inodes
  81. * we find in the log are created in the subvolume.
  82. *
  83. * The last stage is to deal with directories and links and extents
  84. * and all the other fun semantics
  85. */
  86. #define LOG_WALK_PIN_ONLY 0
  87. #define LOG_WALK_REPLAY_INODES 1
  88. #define LOG_WALK_REPLAY_ALL 2
  89. static int btrfs_log_inode(struct btrfs_trans_handle *trans,
  90. struct btrfs_root *root, struct inode *inode,
  91. int inode_only);
  92. static int link_to_fixup_dir(struct btrfs_trans_handle *trans,
  93. struct btrfs_root *root,
  94. struct btrfs_path *path, u64 objectid);
  95. static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
  96. struct btrfs_root *root,
  97. struct btrfs_root *log,
  98. struct btrfs_path *path,
  99. u64 dirid, int del_all);
  100. /*
  101. * tree logging is a special write ahead log used to make sure that
  102. * fsyncs and O_SYNCs can happen without doing full tree commits.
  103. *
  104. * Full tree commits are expensive because they require commonly
  105. * modified blocks to be recowed, creating many dirty pages in the
  106. * extent tree an 4x-6x higher write load than ext3.
  107. *
  108. * Instead of doing a tree commit on every fsync, we use the
  109. * key ranges and transaction ids to find items for a given file or directory
  110. * that have changed in this transaction. Those items are copied into
  111. * a special tree (one per subvolume root), that tree is written to disk
  112. * and then the fsync is considered complete.
  113. *
  114. * After a crash, items are copied out of the log-tree back into the
  115. * subvolume tree. Any file data extents found are recorded in the extent
  116. * allocation tree, and the log-tree freed.
  117. *
  118. * The log tree is read three times, once to pin down all the extents it is
  119. * using in ram and once, once to create all the inodes logged in the tree
  120. * and once to do all the other items.
  121. */
  122. /*
  123. * start a sub transaction and setup the log tree
  124. * this increments the log tree writer count to make the people
  125. * syncing the tree wait for us to finish
  126. */
  127. static int start_log_trans(struct btrfs_trans_handle *trans,
  128. struct btrfs_root *root)
  129. {
  130. int ret;
  131. int err = 0;
  132. mutex_lock(&root->log_mutex);
  133. if (root->log_root) {
  134. if (!root->log_start_pid) {
  135. root->log_start_pid = current->pid;
  136. root->log_multiple_pids = false;
  137. } else if (root->log_start_pid != current->pid) {
  138. root->log_multiple_pids = true;
  139. }
  140. root->log_batch++;
  141. atomic_inc(&root->log_writers);
  142. mutex_unlock(&root->log_mutex);
  143. return 0;
  144. }
  145. root->log_multiple_pids = false;
  146. root->log_start_pid = current->pid;
  147. mutex_lock(&root->fs_info->tree_log_mutex);
  148. if (!root->fs_info->log_root_tree) {
  149. ret = btrfs_init_log_root_tree(trans, root->fs_info);
  150. if (ret)
  151. err = ret;
  152. }
  153. if (err == 0 && !root->log_root) {
  154. ret = btrfs_add_log_tree(trans, root);
  155. if (ret)
  156. err = ret;
  157. }
  158. mutex_unlock(&root->fs_info->tree_log_mutex);
  159. root->log_batch++;
  160. atomic_inc(&root->log_writers);
  161. mutex_unlock(&root->log_mutex);
  162. return err;
  163. }
  164. /*
  165. * returns 0 if there was a log transaction running and we were able
  166. * to join, or returns -ENOENT if there were not transactions
  167. * in progress
  168. */
  169. static int join_running_log_trans(struct btrfs_root *root)
  170. {
  171. int ret = -ENOENT;
  172. smp_mb();
  173. if (!root->log_root)
  174. return -ENOENT;
  175. mutex_lock(&root->log_mutex);
  176. if (root->log_root) {
  177. ret = 0;
  178. atomic_inc(&root->log_writers);
  179. }
  180. mutex_unlock(&root->log_mutex);
  181. return ret;
  182. }
  183. /*
  184. * This either makes the current running log transaction wait
  185. * until you call btrfs_end_log_trans() or it makes any future
  186. * log transactions wait until you call btrfs_end_log_trans()
  187. */
  188. int btrfs_pin_log_trans(struct btrfs_root *root)
  189. {
  190. int ret = -ENOENT;
  191. mutex_lock(&root->log_mutex);
  192. atomic_inc(&root->log_writers);
  193. mutex_unlock(&root->log_mutex);
  194. return ret;
  195. }
  196. /*
  197. * indicate we're done making changes to the log tree
  198. * and wake up anyone waiting to do a sync
  199. */
  200. int btrfs_end_log_trans(struct btrfs_root *root)
  201. {
  202. if (atomic_dec_and_test(&root->log_writers)) {
  203. smp_mb();
  204. if (waitqueue_active(&root->log_writer_wait))
  205. wake_up(&root->log_writer_wait);
  206. }
  207. return 0;
  208. }
  209. /*
  210. * the walk control struct is used to pass state down the chain when
  211. * processing the log tree. The stage field tells us which part
  212. * of the log tree processing we are currently doing. The others
  213. * are state fields used for that specific part
  214. */
  215. struct walk_control {
  216. /* should we free the extent on disk when done? This is used
  217. * at transaction commit time while freeing a log tree
  218. */
  219. int free;
  220. /* should we write out the extent buffer? This is used
  221. * while flushing the log tree to disk during a sync
  222. */
  223. int write;
  224. /* should we wait for the extent buffer io to finish? Also used
  225. * while flushing the log tree to disk for a sync
  226. */
  227. int wait;
  228. /* pin only walk, we record which extents on disk belong to the
  229. * log trees
  230. */
  231. int pin;
  232. /* what stage of the replay code we're currently in */
  233. int stage;
  234. /* the root we are currently replaying */
  235. struct btrfs_root *replay_dest;
  236. /* the trans handle for the current replay */
  237. struct btrfs_trans_handle *trans;
  238. /* the function that gets used to process blocks we find in the
  239. * tree. Note the extent_buffer might not be up to date when it is
  240. * passed in, and it must be checked or read if you need the data
  241. * inside it
  242. */
  243. int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb,
  244. struct walk_control *wc, u64 gen);
  245. };
  246. /*
  247. * process_func used to pin down extents, write them or wait on them
  248. */
  249. static int process_one_buffer(struct btrfs_root *log,
  250. struct extent_buffer *eb,
  251. struct walk_control *wc, u64 gen)
  252. {
  253. if (wc->pin)
  254. btrfs_pin_extent(log->fs_info->extent_root,
  255. eb->start, eb->len, 0);
  256. if (btrfs_buffer_uptodate(eb, gen)) {
  257. if (wc->write)
  258. btrfs_write_tree_block(eb);
  259. if (wc->wait)
  260. btrfs_wait_tree_block_writeback(eb);
  261. }
  262. return 0;
  263. }
  264. /*
  265. * Item overwrite used by replay and tree logging. eb, slot and key all refer
  266. * to the src data we are copying out.
  267. *
  268. * root is the tree we are copying into, and path is a scratch
  269. * path for use in this function (it should be released on entry and
  270. * will be released on exit).
  271. *
  272. * If the key is already in the destination tree the existing item is
  273. * overwritten. If the existing item isn't big enough, it is extended.
  274. * If it is too large, it is truncated.
  275. *
  276. * If the key isn't in the destination yet, a new item is inserted.
  277. */
  278. static noinline int overwrite_item(struct btrfs_trans_handle *trans,
  279. struct btrfs_root *root,
  280. struct btrfs_path *path,
  281. struct extent_buffer *eb, int slot,
  282. struct btrfs_key *key)
  283. {
  284. int ret;
  285. u32 item_size;
  286. u64 saved_i_size = 0;
  287. int save_old_i_size = 0;
  288. unsigned long src_ptr;
  289. unsigned long dst_ptr;
  290. int overwrite_root = 0;
  291. if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
  292. overwrite_root = 1;
  293. item_size = btrfs_item_size_nr(eb, slot);
  294. src_ptr = btrfs_item_ptr_offset(eb, slot);
  295. /* look for the key in the destination tree */
  296. ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
  297. if (ret == 0) {
  298. char *src_copy;
  299. char *dst_copy;
  300. u32 dst_size = btrfs_item_size_nr(path->nodes[0],
  301. path->slots[0]);
  302. if (dst_size != item_size)
  303. goto insert;
  304. if (item_size == 0) {
  305. btrfs_release_path(root, path);
  306. return 0;
  307. }
  308. dst_copy = kmalloc(item_size, GFP_NOFS);
  309. src_copy = kmalloc(item_size, GFP_NOFS);
  310. if (!dst_copy || !src_copy) {
  311. btrfs_release_path(root, path);
  312. kfree(dst_copy);
  313. kfree(src_copy);
  314. return -ENOMEM;
  315. }
  316. read_extent_buffer(eb, src_copy, src_ptr, item_size);
  317. dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
  318. read_extent_buffer(path->nodes[0], dst_copy, dst_ptr,
  319. item_size);
  320. ret = memcmp(dst_copy, src_copy, item_size);
  321. kfree(dst_copy);
  322. kfree(src_copy);
  323. /*
  324. * they have the same contents, just return, this saves
  325. * us from cowing blocks in the destination tree and doing
  326. * extra writes that may not have been done by a previous
  327. * sync
  328. */
  329. if (ret == 0) {
  330. btrfs_release_path(root, path);
  331. return 0;
  332. }
  333. }
  334. insert:
  335. btrfs_release_path(root, path);
  336. /* try to insert the key into the destination tree */
  337. ret = btrfs_insert_empty_item(trans, root, path,
  338. key, item_size);
  339. /* make sure any existing item is the correct size */
  340. if (ret == -EEXIST) {
  341. u32 found_size;
  342. found_size = btrfs_item_size_nr(path->nodes[0],
  343. path->slots[0]);
  344. if (found_size > item_size) {
  345. btrfs_truncate_item(trans, root, path, item_size, 1);
  346. } else if (found_size < item_size) {
  347. ret = btrfs_extend_item(trans, root, path,
  348. item_size - found_size);
  349. BUG_ON(ret);
  350. }
  351. } else if (ret) {
  352. return ret;
  353. }
  354. dst_ptr = btrfs_item_ptr_offset(path->nodes[0],
  355. path->slots[0]);
  356. /* don't overwrite an existing inode if the generation number
  357. * was logged as zero. This is done when the tree logging code
  358. * is just logging an inode to make sure it exists after recovery.
  359. *
  360. * Also, don't overwrite i_size on directories during replay.
  361. * log replay inserts and removes directory items based on the
  362. * state of the tree found in the subvolume, and i_size is modified
  363. * as it goes
  364. */
  365. if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
  366. struct btrfs_inode_item *src_item;
  367. struct btrfs_inode_item *dst_item;
  368. src_item = (struct btrfs_inode_item *)src_ptr;
  369. dst_item = (struct btrfs_inode_item *)dst_ptr;
  370. if (btrfs_inode_generation(eb, src_item) == 0)
  371. goto no_copy;
  372. if (overwrite_root &&
  373. S_ISDIR(btrfs_inode_mode(eb, src_item)) &&
  374. S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) {
  375. save_old_i_size = 1;
  376. saved_i_size = btrfs_inode_size(path->nodes[0],
  377. dst_item);
  378. }
  379. }
  380. copy_extent_buffer(path->nodes[0], eb, dst_ptr,
  381. src_ptr, item_size);
  382. if (save_old_i_size) {
  383. struct btrfs_inode_item *dst_item;
  384. dst_item = (struct btrfs_inode_item *)dst_ptr;
  385. btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size);
  386. }
  387. /* make sure the generation is filled in */
  388. if (key->type == BTRFS_INODE_ITEM_KEY) {
  389. struct btrfs_inode_item *dst_item;
  390. dst_item = (struct btrfs_inode_item *)dst_ptr;
  391. if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) {
  392. btrfs_set_inode_generation(path->nodes[0], dst_item,
  393. trans->transid);
  394. }
  395. }
  396. no_copy:
  397. btrfs_mark_buffer_dirty(path->nodes[0]);
  398. btrfs_release_path(root, path);
  399. return 0;
  400. }
  401. /*
  402. * simple helper to read an inode off the disk from a given root
  403. * This can only be called for subvolume roots and not for the log
  404. */
  405. static noinline struct inode *read_one_inode(struct btrfs_root *root,
  406. u64 objectid)
  407. {
  408. struct btrfs_key key;
  409. struct inode *inode;
  410. key.objectid = objectid;
  411. key.type = BTRFS_INODE_ITEM_KEY;
  412. key.offset = 0;
  413. inode = btrfs_iget(root->fs_info->sb, &key, root, NULL);
  414. if (IS_ERR(inode)) {
  415. inode = NULL;
  416. } else if (is_bad_inode(inode)) {
  417. iput(inode);
  418. inode = NULL;
  419. }
  420. return inode;
  421. }
  422. /* replays a single extent in 'eb' at 'slot' with 'key' into the
  423. * subvolume 'root'. path is released on entry and should be released
  424. * on exit.
  425. *
  426. * extents in the log tree have not been allocated out of the extent
  427. * tree yet. So, this completes the allocation, taking a reference
  428. * as required if the extent already exists or creating a new extent
  429. * if it isn't in the extent allocation tree yet.
  430. *
  431. * The extent is inserted into the file, dropping any existing extents
  432. * from the file that overlap the new one.
  433. */
  434. static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
  435. struct btrfs_root *root,
  436. struct btrfs_path *path,
  437. struct extent_buffer *eb, int slot,
  438. struct btrfs_key *key)
  439. {
  440. int found_type;
  441. u64 mask = root->sectorsize - 1;
  442. u64 extent_end;
  443. u64 alloc_hint;
  444. u64 start = key->offset;
  445. u64 saved_nbytes;
  446. struct btrfs_file_extent_item *item;
  447. struct inode *inode = NULL;
  448. unsigned long size;
  449. int ret = 0;
  450. item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
  451. found_type = btrfs_file_extent_type(eb, item);
  452. if (found_type == BTRFS_FILE_EXTENT_REG ||
  453. found_type == BTRFS_FILE_EXTENT_PREALLOC)
  454. extent_end = start + btrfs_file_extent_num_bytes(eb, item);
  455. else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
  456. size = btrfs_file_extent_inline_len(eb, item);
  457. extent_end = (start + size + mask) & ~mask;
  458. } else {
  459. ret = 0;
  460. goto out;
  461. }
  462. inode = read_one_inode(root, key->objectid);
  463. if (!inode) {
  464. ret = -EIO;
  465. goto out;
  466. }
  467. /*
  468. * first check to see if we already have this extent in the
  469. * file. This must be done before the btrfs_drop_extents run
  470. * so we don't try to drop this extent.
  471. */
  472. ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
  473. start, 0);
  474. if (ret == 0 &&
  475. (found_type == BTRFS_FILE_EXTENT_REG ||
  476. found_type == BTRFS_FILE_EXTENT_PREALLOC)) {
  477. struct btrfs_file_extent_item cmp1;
  478. struct btrfs_file_extent_item cmp2;
  479. struct btrfs_file_extent_item *existing;
  480. struct extent_buffer *leaf;
  481. leaf = path->nodes[0];
  482. existing = btrfs_item_ptr(leaf, path->slots[0],
  483. struct btrfs_file_extent_item);
  484. read_extent_buffer(eb, &cmp1, (unsigned long)item,
  485. sizeof(cmp1));
  486. read_extent_buffer(leaf, &cmp2, (unsigned long)existing,
  487. sizeof(cmp2));
  488. /*
  489. * we already have a pointer to this exact extent,
  490. * we don't have to do anything
  491. */
  492. if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) {
  493. btrfs_release_path(root, path);
  494. goto out;
  495. }
  496. }
  497. btrfs_release_path(root, path);
  498. saved_nbytes = inode_get_bytes(inode);
  499. /* drop any overlapping extents */
  500. ret = btrfs_drop_extents(trans, inode, start, extent_end,
  501. &alloc_hint, 1);
  502. BUG_ON(ret);
  503. if (found_type == BTRFS_FILE_EXTENT_REG ||
  504. found_type == BTRFS_FILE_EXTENT_PREALLOC) {
  505. u64 offset;
  506. unsigned long dest_offset;
  507. struct btrfs_key ins;
  508. ret = btrfs_insert_empty_item(trans, root, path, key,
  509. sizeof(*item));
  510. BUG_ON(ret);
  511. dest_offset = btrfs_item_ptr_offset(path->nodes[0],
  512. path->slots[0]);
  513. copy_extent_buffer(path->nodes[0], eb, dest_offset,
  514. (unsigned long)item, sizeof(*item));
  515. ins.objectid = btrfs_file_extent_disk_bytenr(eb, item);
  516. ins.offset = btrfs_file_extent_disk_num_bytes(eb, item);
  517. ins.type = BTRFS_EXTENT_ITEM_KEY;
  518. offset = key->offset - btrfs_file_extent_offset(eb, item);
  519. if (ins.objectid > 0) {
  520. u64 csum_start;
  521. u64 csum_end;
  522. LIST_HEAD(ordered_sums);
  523. /*
  524. * is this extent already allocated in the extent
  525. * allocation tree? If so, just add a reference
  526. */
  527. ret = btrfs_lookup_extent(root, ins.objectid,
  528. ins.offset);
  529. if (ret == 0) {
  530. ret = btrfs_inc_extent_ref(trans, root,
  531. ins.objectid, ins.offset,
  532. 0, root->root_key.objectid,
  533. key->objectid, offset);
  534. } else {
  535. /*
  536. * insert the extent pointer in the extent
  537. * allocation tree
  538. */
  539. ret = btrfs_alloc_logged_file_extent(trans,
  540. root, root->root_key.objectid,
  541. key->objectid, offset, &ins);
  542. BUG_ON(ret);
  543. }
  544. btrfs_release_path(root, path);
  545. if (btrfs_file_extent_compression(eb, item)) {
  546. csum_start = ins.objectid;
  547. csum_end = csum_start + ins.offset;
  548. } else {
  549. csum_start = ins.objectid +
  550. btrfs_file_extent_offset(eb, item);
  551. csum_end = csum_start +
  552. btrfs_file_extent_num_bytes(eb, item);
  553. }
  554. ret = btrfs_lookup_csums_range(root->log_root,
  555. csum_start, csum_end - 1,
  556. &ordered_sums);
  557. BUG_ON(ret);
  558. while (!list_empty(&ordered_sums)) {
  559. struct btrfs_ordered_sum *sums;
  560. sums = list_entry(ordered_sums.next,
  561. struct btrfs_ordered_sum,
  562. list);
  563. ret = btrfs_csum_file_blocks(trans,
  564. root->fs_info->csum_root,
  565. sums);
  566. BUG_ON(ret);
  567. list_del(&sums->list);
  568. kfree(sums);
  569. }
  570. } else {
  571. btrfs_release_path(root, path);
  572. }
  573. } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
  574. /* inline extents are easy, we just overwrite them */
  575. ret = overwrite_item(trans, root, path, eb, slot, key);
  576. BUG_ON(ret);
  577. }
  578. inode_set_bytes(inode, saved_nbytes);
  579. btrfs_update_inode(trans, root, inode);
  580. out:
  581. if (inode)
  582. iput(inode);
  583. return ret;
  584. }
  585. /*
  586. * when cleaning up conflicts between the directory names in the
  587. * subvolume, directory names in the log and directory names in the
  588. * inode back references, we may have to unlink inodes from directories.
  589. *
  590. * This is a helper function to do the unlink of a specific directory
  591. * item
  592. */
  593. static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
  594. struct btrfs_root *root,
  595. struct btrfs_path *path,
  596. struct inode *dir,
  597. struct btrfs_dir_item *di)
  598. {
  599. struct inode *inode;
  600. char *name;
  601. int name_len;
  602. struct extent_buffer *leaf;
  603. struct btrfs_key location;
  604. int ret;
  605. leaf = path->nodes[0];
  606. btrfs_dir_item_key_to_cpu(leaf, di, &location);
  607. name_len = btrfs_dir_name_len(leaf, di);
  608. name = kmalloc(name_len, GFP_NOFS);
  609. if (!name)
  610. return -ENOMEM;
  611. read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len);
  612. btrfs_release_path(root, path);
  613. inode = read_one_inode(root, location.objectid);
  614. BUG_ON(!inode);
  615. ret = link_to_fixup_dir(trans, root, path, location.objectid);
  616. BUG_ON(ret);
  617. ret = btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
  618. BUG_ON(ret);
  619. kfree(name);
  620. iput(inode);
  621. return ret;
  622. }
  623. /*
  624. * helper function to see if a given name and sequence number found
  625. * in an inode back reference are already in a directory and correctly
  626. * point to this inode
  627. */
  628. static noinline int inode_in_dir(struct btrfs_root *root,
  629. struct btrfs_path *path,
  630. u64 dirid, u64 objectid, u64 index,
  631. const char *name, int name_len)
  632. {
  633. struct btrfs_dir_item *di;
  634. struct btrfs_key location;
  635. int match = 0;
  636. di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
  637. index, name, name_len, 0);
  638. if (di && !IS_ERR(di)) {
  639. btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
  640. if (location.objectid != objectid)
  641. goto out;
  642. } else
  643. goto out;
  644. btrfs_release_path(root, path);
  645. di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
  646. if (di && !IS_ERR(di)) {
  647. btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
  648. if (location.objectid != objectid)
  649. goto out;
  650. } else
  651. goto out;
  652. match = 1;
  653. out:
  654. btrfs_release_path(root, path);
  655. return match;
  656. }
  657. /*
  658. * helper function to check a log tree for a named back reference in
  659. * an inode. This is used to decide if a back reference that is
  660. * found in the subvolume conflicts with what we find in the log.
  661. *
  662. * inode backreferences may have multiple refs in a single item,
  663. * during replay we process one reference at a time, and we don't
  664. * want to delete valid links to a file from the subvolume if that
  665. * link is also in the log.
  666. */
  667. static noinline int backref_in_log(struct btrfs_root *log,
  668. struct btrfs_key *key,
  669. char *name, int namelen)
  670. {
  671. struct btrfs_path *path;
  672. struct btrfs_inode_ref *ref;
  673. unsigned long ptr;
  674. unsigned long ptr_end;
  675. unsigned long name_ptr;
  676. int found_name_len;
  677. int item_size;
  678. int ret;
  679. int match = 0;
  680. path = btrfs_alloc_path();
  681. if (!path)
  682. return -ENOMEM;
  683. ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
  684. if (ret != 0)
  685. goto out;
  686. item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
  687. ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
  688. ptr_end = ptr + item_size;
  689. while (ptr < ptr_end) {
  690. ref = (struct btrfs_inode_ref *)ptr;
  691. found_name_len = btrfs_inode_ref_name_len(path->nodes[0], ref);
  692. if (found_name_len == namelen) {
  693. name_ptr = (unsigned long)(ref + 1);
  694. ret = memcmp_extent_buffer(path->nodes[0], name,
  695. name_ptr, namelen);
  696. if (ret == 0) {
  697. match = 1;
  698. goto out;
  699. }
  700. }
  701. ptr = (unsigned long)(ref + 1) + found_name_len;
  702. }
  703. out:
  704. btrfs_free_path(path);
  705. return match;
  706. }
  707. /*
  708. * replay one inode back reference item found in the log tree.
  709. * eb, slot and key refer to the buffer and key found in the log tree.
  710. * root is the destination we are replaying into, and path is for temp
  711. * use by this function. (it should be released on return).
  712. */
  713. static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
  714. struct btrfs_root *root,
  715. struct btrfs_root *log,
  716. struct btrfs_path *path,
  717. struct extent_buffer *eb, int slot,
  718. struct btrfs_key *key)
  719. {
  720. struct inode *dir;
  721. int ret;
  722. struct btrfs_inode_ref *ref;
  723. struct inode *inode;
  724. char *name;
  725. int namelen;
  726. unsigned long ref_ptr;
  727. unsigned long ref_end;
  728. int search_done = 0;
  729. /*
  730. * it is possible that we didn't log all the parent directories
  731. * for a given inode. If we don't find the dir, just don't
  732. * copy the back ref in. The link count fixup code will take
  733. * care of the rest
  734. */
  735. dir = read_one_inode(root, key->offset);
  736. if (!dir)
  737. return -ENOENT;
  738. inode = read_one_inode(root, key->objectid);
  739. BUG_ON(!inode);
  740. ref_ptr = btrfs_item_ptr_offset(eb, slot);
  741. ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
  742. again:
  743. ref = (struct btrfs_inode_ref *)ref_ptr;
  744. namelen = btrfs_inode_ref_name_len(eb, ref);
  745. name = kmalloc(namelen, GFP_NOFS);
  746. BUG_ON(!name);
  747. read_extent_buffer(eb, name, (unsigned long)(ref + 1), namelen);
  748. /* if we already have a perfect match, we're done */
  749. if (inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
  750. btrfs_inode_ref_index(eb, ref),
  751. name, namelen)) {
  752. goto out;
  753. }
  754. /*
  755. * look for a conflicting back reference in the metadata.
  756. * if we find one we have to unlink that name of the file
  757. * before we add our new link. Later on, we overwrite any
  758. * existing back reference, and we don't want to create
  759. * dangling pointers in the directory.
  760. */
  761. if (search_done)
  762. goto insert;
  763. ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
  764. if (ret == 0) {
  765. char *victim_name;
  766. int victim_name_len;
  767. struct btrfs_inode_ref *victim_ref;
  768. unsigned long ptr;
  769. unsigned long ptr_end;
  770. struct extent_buffer *leaf = path->nodes[0];
  771. /* are we trying to overwrite a back ref for the root directory
  772. * if so, just jump out, we're done
  773. */
  774. if (key->objectid == key->offset)
  775. goto out_nowrite;
  776. /* check all the names in this back reference to see
  777. * if they are in the log. if so, we allow them to stay
  778. * otherwise they must be unlinked as a conflict
  779. */
  780. ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
  781. ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]);
  782. while (ptr < ptr_end) {
  783. victim_ref = (struct btrfs_inode_ref *)ptr;
  784. victim_name_len = btrfs_inode_ref_name_len(leaf,
  785. victim_ref);
  786. victim_name = kmalloc(victim_name_len, GFP_NOFS);
  787. BUG_ON(!victim_name);
  788. read_extent_buffer(leaf, victim_name,
  789. (unsigned long)(victim_ref + 1),
  790. victim_name_len);
  791. if (!backref_in_log(log, key, victim_name,
  792. victim_name_len)) {
  793. btrfs_inc_nlink(inode);
  794. btrfs_release_path(root, path);
  795. ret = btrfs_unlink_inode(trans, root, dir,
  796. inode, victim_name,
  797. victim_name_len);
  798. }
  799. kfree(victim_name);
  800. ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
  801. }
  802. BUG_ON(ret);
  803. /*
  804. * NOTE: we have searched root tree and checked the
  805. * coresponding ref, it does not need to check again.
  806. */
  807. search_done = 1;
  808. }
  809. btrfs_release_path(root, path);
  810. insert:
  811. /* insert our name */
  812. ret = btrfs_add_link(trans, dir, inode, name, namelen, 0,
  813. btrfs_inode_ref_index(eb, ref));
  814. BUG_ON(ret);
  815. btrfs_update_inode(trans, root, inode);
  816. out:
  817. ref_ptr = (unsigned long)(ref + 1) + namelen;
  818. kfree(name);
  819. if (ref_ptr < ref_end)
  820. goto again;
  821. /* finally write the back reference in the inode */
  822. ret = overwrite_item(trans, root, path, eb, slot, key);
  823. BUG_ON(ret);
  824. out_nowrite:
  825. btrfs_release_path(root, path);
  826. iput(dir);
  827. iput(inode);
  828. return 0;
  829. }
  830. static int insert_orphan_item(struct btrfs_trans_handle *trans,
  831. struct btrfs_root *root, u64 offset)
  832. {
  833. int ret;
  834. ret = btrfs_find_orphan_item(root, offset);
  835. if (ret > 0)
  836. ret = btrfs_insert_orphan_item(trans, root, offset);
  837. return ret;
  838. }
  839. /*
  840. * There are a few corners where the link count of the file can't
  841. * be properly maintained during replay. So, instead of adding
  842. * lots of complexity to the log code, we just scan the backrefs
  843. * for any file that has been through replay.
  844. *
  845. * The scan will update the link count on the inode to reflect the
  846. * number of back refs found. If it goes down to zero, the iput
  847. * will free the inode.
  848. */
  849. static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
  850. struct btrfs_root *root,
  851. struct inode *inode)
  852. {
  853. struct btrfs_path *path;
  854. int ret;
  855. struct btrfs_key key;
  856. u64 nlink = 0;
  857. unsigned long ptr;
  858. unsigned long ptr_end;
  859. int name_len;
  860. u64 ino = btrfs_ino(inode);
  861. key.objectid = ino;
  862. key.type = BTRFS_INODE_REF_KEY;
  863. key.offset = (u64)-1;
  864. path = btrfs_alloc_path();
  865. if (!path)
  866. return -ENOMEM;
  867. while (1) {
  868. ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
  869. if (ret < 0)
  870. break;
  871. if (ret > 0) {
  872. if (path->slots[0] == 0)
  873. break;
  874. path->slots[0]--;
  875. }
  876. btrfs_item_key_to_cpu(path->nodes[0], &key,
  877. path->slots[0]);
  878. if (key.objectid != ino ||
  879. key.type != BTRFS_INODE_REF_KEY)
  880. break;
  881. ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
  882. ptr_end = ptr + btrfs_item_size_nr(path->nodes[0],
  883. path->slots[0]);
  884. while (ptr < ptr_end) {
  885. struct btrfs_inode_ref *ref;
  886. ref = (struct btrfs_inode_ref *)ptr;
  887. name_len = btrfs_inode_ref_name_len(path->nodes[0],
  888. ref);
  889. ptr = (unsigned long)(ref + 1) + name_len;
  890. nlink++;
  891. }
  892. if (key.offset == 0)
  893. break;
  894. key.offset--;
  895. btrfs_release_path(root, path);
  896. }
  897. btrfs_release_path(root, path);
  898. if (nlink != inode->i_nlink) {
  899. inode->i_nlink = nlink;
  900. btrfs_update_inode(trans, root, inode);
  901. }
  902. BTRFS_I(inode)->index_cnt = (u64)-1;
  903. if (inode->i_nlink == 0) {
  904. if (S_ISDIR(inode->i_mode)) {
  905. ret = replay_dir_deletes(trans, root, NULL, path,
  906. ino, 1);
  907. BUG_ON(ret);
  908. }
  909. ret = insert_orphan_item(trans, root, ino);
  910. BUG_ON(ret);
  911. }
  912. btrfs_free_path(path);
  913. return 0;
  914. }
  915. static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
  916. struct btrfs_root *root,
  917. struct btrfs_path *path)
  918. {
  919. int ret;
  920. struct btrfs_key key;
  921. struct inode *inode;
  922. key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
  923. key.type = BTRFS_ORPHAN_ITEM_KEY;
  924. key.offset = (u64)-1;
  925. while (1) {
  926. ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
  927. if (ret < 0)
  928. break;
  929. if (ret == 1) {
  930. if (path->slots[0] == 0)
  931. break;
  932. path->slots[0]--;
  933. }
  934. btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
  935. if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
  936. key.type != BTRFS_ORPHAN_ITEM_KEY)
  937. break;
  938. ret = btrfs_del_item(trans, root, path);
  939. BUG_ON(ret);
  940. btrfs_release_path(root, path);
  941. inode = read_one_inode(root, key.offset);
  942. BUG_ON(!inode);
  943. ret = fixup_inode_link_count(trans, root, inode);
  944. BUG_ON(ret);
  945. iput(inode);
  946. /*
  947. * fixup on a directory may create new entries,
  948. * make sure we always look for the highset possible
  949. * offset
  950. */
  951. key.offset = (u64)-1;
  952. }
  953. btrfs_release_path(root, path);
  954. return 0;
  955. }
  956. /*
  957. * record a given inode in the fixup dir so we can check its link
  958. * count when replay is done. The link count is incremented here
  959. * so the inode won't go away until we check it
  960. */
  961. static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
  962. struct btrfs_root *root,
  963. struct btrfs_path *path,
  964. u64 objectid)
  965. {
  966. struct btrfs_key key;
  967. int ret = 0;
  968. struct inode *inode;
  969. inode = read_one_inode(root, objectid);
  970. BUG_ON(!inode);
  971. key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
  972. btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
  973. key.offset = objectid;
  974. ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
  975. btrfs_release_path(root, path);
  976. if (ret == 0) {
  977. btrfs_inc_nlink(inode);
  978. btrfs_update_inode(trans, root, inode);
  979. } else if (ret == -EEXIST) {
  980. ret = 0;
  981. } else {
  982. BUG();
  983. }
  984. iput(inode);
  985. return ret;
  986. }
  987. /*
  988. * when replaying the log for a directory, we only insert names
  989. * for inodes that actually exist. This means an fsync on a directory
  990. * does not implicitly fsync all the new files in it
  991. */
  992. static noinline int insert_one_name(struct btrfs_trans_handle *trans,
  993. struct btrfs_root *root,
  994. struct btrfs_path *path,
  995. u64 dirid, u64 index,
  996. char *name, int name_len, u8 type,
  997. struct btrfs_key *location)
  998. {
  999. struct inode *inode;
  1000. struct inode *dir;
  1001. int ret;
  1002. inode = read_one_inode(root, location->objectid);
  1003. if (!inode)
  1004. return -ENOENT;
  1005. dir = read_one_inode(root, dirid);
  1006. if (!dir) {
  1007. iput(inode);
  1008. return -EIO;
  1009. }
  1010. ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index);
  1011. /* FIXME, put inode into FIXUP list */
  1012. iput(inode);
  1013. iput(dir);
  1014. return ret;
  1015. }
  1016. /*
  1017. * take a single entry in a log directory item and replay it into
  1018. * the subvolume.
  1019. *
  1020. * if a conflicting item exists in the subdirectory already,
  1021. * the inode it points to is unlinked and put into the link count
  1022. * fix up tree.
  1023. *
  1024. * If a name from the log points to a file or directory that does
  1025. * not exist in the FS, it is skipped. fsyncs on directories
  1026. * do not force down inodes inside that directory, just changes to the
  1027. * names or unlinks in a directory.
  1028. */
  1029. static noinline int replay_one_name(struct btrfs_trans_handle *trans,
  1030. struct btrfs_root *root,
  1031. struct btrfs_path *path,
  1032. struct extent_buffer *eb,
  1033. struct btrfs_dir_item *di,
  1034. struct btrfs_key *key)
  1035. {
  1036. char *name;
  1037. int name_len;
  1038. struct btrfs_dir_item *dst_di;
  1039. struct btrfs_key found_key;
  1040. struct btrfs_key log_key;
  1041. struct inode *dir;
  1042. u8 log_type;
  1043. int exists;
  1044. int ret;
  1045. dir = read_one_inode(root, key->objectid);
  1046. BUG_ON(!dir);
  1047. name_len = btrfs_dir_name_len(eb, di);
  1048. name = kmalloc(name_len, GFP_NOFS);
  1049. if (!name)
  1050. return -ENOMEM;
  1051. log_type = btrfs_dir_type(eb, di);
  1052. read_extent_buffer(eb, name, (unsigned long)(di + 1),
  1053. name_len);
  1054. btrfs_dir_item_key_to_cpu(eb, di, &log_key);
  1055. exists = btrfs_lookup_inode(trans, root, path, &log_key, 0);
  1056. if (exists == 0)
  1057. exists = 1;
  1058. else
  1059. exists = 0;
  1060. btrfs_release_path(root, path);
  1061. if (key->type == BTRFS_DIR_ITEM_KEY) {
  1062. dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
  1063. name, name_len, 1);
  1064. } else if (key->type == BTRFS_DIR_INDEX_KEY) {
  1065. dst_di = btrfs_lookup_dir_index_item(trans, root, path,
  1066. key->objectid,
  1067. key->offset, name,
  1068. name_len, 1);
  1069. } else {
  1070. BUG();
  1071. }
  1072. if (!dst_di || IS_ERR(dst_di)) {
  1073. /* we need a sequence number to insert, so we only
  1074. * do inserts for the BTRFS_DIR_INDEX_KEY types
  1075. */
  1076. if (key->type != BTRFS_DIR_INDEX_KEY)
  1077. goto out;
  1078. goto insert;
  1079. }
  1080. btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key);
  1081. /* the existing item matches the logged item */
  1082. if (found_key.objectid == log_key.objectid &&
  1083. found_key.type == log_key.type &&
  1084. found_key.offset == log_key.offset &&
  1085. btrfs_dir_type(path->nodes[0], dst_di) == log_type) {
  1086. goto out;
  1087. }
  1088. /*
  1089. * don't drop the conflicting directory entry if the inode
  1090. * for the new entry doesn't exist
  1091. */
  1092. if (!exists)
  1093. goto out;
  1094. ret = drop_one_dir_item(trans, root, path, dir, dst_di);
  1095. BUG_ON(ret);
  1096. if (key->type == BTRFS_DIR_INDEX_KEY)
  1097. goto insert;
  1098. out:
  1099. btrfs_release_path(root, path);
  1100. kfree(name);
  1101. iput(dir);
  1102. return 0;
  1103. insert:
  1104. btrfs_release_path(root, path);
  1105. ret = insert_one_name(trans, root, path, key->objectid, key->offset,
  1106. name, name_len, log_type, &log_key);
  1107. BUG_ON(ret && ret != -ENOENT);
  1108. goto out;
  1109. }
  1110. /*
  1111. * find all the names in a directory item and reconcile them into
  1112. * the subvolume. Only BTRFS_DIR_ITEM_KEY types will have more than
  1113. * one name in a directory item, but the same code gets used for
  1114. * both directory index types
  1115. */
  1116. static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
  1117. struct btrfs_root *root,
  1118. struct btrfs_path *path,
  1119. struct extent_buffer *eb, int slot,
  1120. struct btrfs_key *key)
  1121. {
  1122. int ret;
  1123. u32 item_size = btrfs_item_size_nr(eb, slot);
  1124. struct btrfs_dir_item *di;
  1125. int name_len;
  1126. unsigned long ptr;
  1127. unsigned long ptr_end;
  1128. ptr = btrfs_item_ptr_offset(eb, slot);
  1129. ptr_end = ptr + item_size;
  1130. while (ptr < ptr_end) {
  1131. di = (struct btrfs_dir_item *)ptr;
  1132. if (verify_dir_item(root, eb, di))
  1133. return -EIO;
  1134. name_len = btrfs_dir_name_len(eb, di);
  1135. ret = replay_one_name(trans, root, path, eb, di, key);
  1136. BUG_ON(ret);
  1137. ptr = (unsigned long)(di + 1);
  1138. ptr += name_len;
  1139. }
  1140. return 0;
  1141. }
  1142. /*
  1143. * directory replay has two parts. There are the standard directory
  1144. * items in the log copied from the subvolume, and range items
  1145. * created in the log while the subvolume was logged.
  1146. *
  1147. * The range items tell us which parts of the key space the log
  1148. * is authoritative for. During replay, if a key in the subvolume
  1149. * directory is in a logged range item, but not actually in the log
  1150. * that means it was deleted from the directory before the fsync
  1151. * and should be removed.
  1152. */
  1153. static noinline int find_dir_range(struct btrfs_root *root,
  1154. struct btrfs_path *path,
  1155. u64 dirid, int key_type,
  1156. u64 *start_ret, u64 *end_ret)
  1157. {
  1158. struct btrfs_key key;
  1159. u64 found_end;
  1160. struct btrfs_dir_log_item *item;
  1161. int ret;
  1162. int nritems;
  1163. if (*start_ret == (u64)-1)
  1164. return 1;
  1165. key.objectid = dirid;
  1166. key.type = key_type;
  1167. key.offset = *start_ret;
  1168. ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
  1169. if (ret < 0)
  1170. goto out;
  1171. if (ret > 0) {
  1172. if (path->slots[0] == 0)
  1173. goto out;
  1174. path->slots[0]--;
  1175. }
  1176. if (ret != 0)
  1177. btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
  1178. if (key.type != key_type || key.objectid != dirid) {
  1179. ret = 1;
  1180. goto next;
  1181. }
  1182. item = btrfs_item_ptr(path->nodes[0], path->slots[0],
  1183. struct btrfs_dir_log_item);
  1184. found_end = btrfs_dir_log_end(path->nodes[0], item);
  1185. if (*start_ret >= key.offset && *start_ret <= found_end) {
  1186. ret = 0;
  1187. *start_ret = key.offset;
  1188. *end_ret = found_end;
  1189. goto out;
  1190. }
  1191. ret = 1;
  1192. next:
  1193. /* check the next slot in the tree to see if it is a valid item */
  1194. nritems = btrfs_header_nritems(path->nodes[0]);
  1195. if (path->slots[0] >= nritems) {
  1196. ret = btrfs_next_leaf(root, path);
  1197. if (ret)
  1198. goto out;
  1199. } else {
  1200. path->slots[0]++;
  1201. }
  1202. btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
  1203. if (key.type != key_type || key.objectid != dirid) {
  1204. ret = 1;
  1205. goto out;
  1206. }
  1207. item = btrfs_item_ptr(path->nodes[0], path->slots[0],
  1208. struct btrfs_dir_log_item);
  1209. found_end = btrfs_dir_log_end(path->nodes[0], item);
  1210. *start_ret = key.offset;
  1211. *end_ret = found_end;
  1212. ret = 0;
  1213. out:
  1214. btrfs_release_path(root, path);
  1215. return ret;
  1216. }
  1217. /*
  1218. * this looks for a given directory item in the log. If the directory
  1219. * item is not in the log, the item is removed and the inode it points
  1220. * to is unlinked
  1221. */
  1222. static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
  1223. struct btrfs_root *root,
  1224. struct btrfs_root *log,
  1225. struct btrfs_path *path,
  1226. struct btrfs_path *log_path,
  1227. struct inode *dir,
  1228. struct btrfs_key *dir_key)
  1229. {
  1230. int ret;
  1231. struct extent_buffer *eb;
  1232. int slot;
  1233. u32 item_size;
  1234. struct btrfs_dir_item *di;
  1235. struct btrfs_dir_item *log_di;
  1236. int name_len;
  1237. unsigned long ptr;
  1238. unsigned long ptr_end;
  1239. char *name;
  1240. struct inode *inode;
  1241. struct btrfs_key location;
  1242. again:
  1243. eb = path->nodes[0];
  1244. slot = path->slots[0];
  1245. item_size = btrfs_item_size_nr(eb, slot);
  1246. ptr = btrfs_item_ptr_offset(eb, slot);
  1247. ptr_end = ptr + item_size;
  1248. while (ptr < ptr_end) {
  1249. di = (struct btrfs_dir_item *)ptr;
  1250. if (verify_dir_item(root, eb, di)) {
  1251. ret = -EIO;
  1252. goto out;
  1253. }
  1254. name_len = btrfs_dir_name_len(eb, di);
  1255. name = kmalloc(name_len, GFP_NOFS);
  1256. if (!name) {
  1257. ret = -ENOMEM;
  1258. goto out;
  1259. }
  1260. read_extent_buffer(eb, name, (unsigned long)(di + 1),
  1261. name_len);
  1262. log_di = NULL;
  1263. if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) {
  1264. log_di = btrfs_lookup_dir_item(trans, log, log_path,
  1265. dir_key->objectid,
  1266. name, name_len, 0);
  1267. } else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) {
  1268. log_di = btrfs_lookup_dir_index_item(trans, log,
  1269. log_path,
  1270. dir_key->objectid,
  1271. dir_key->offset,
  1272. name, name_len, 0);
  1273. }
  1274. if (!log_di || IS_ERR(log_di)) {
  1275. btrfs_dir_item_key_to_cpu(eb, di, &location);
  1276. btrfs_release_path(root, path);
  1277. btrfs_release_path(log, log_path);
  1278. inode = read_one_inode(root, location.objectid);
  1279. BUG_ON(!inode);
  1280. ret = link_to_fixup_dir(trans, root,
  1281. path, location.objectid);
  1282. BUG_ON(ret);
  1283. btrfs_inc_nlink(inode);
  1284. ret = btrfs_unlink_inode(trans, root, dir, inode,
  1285. name, name_len);
  1286. BUG_ON(ret);
  1287. kfree(name);
  1288. iput(inode);
  1289. /* there might still be more names under this key
  1290. * check and repeat if required
  1291. */
  1292. ret = btrfs_search_slot(NULL, root, dir_key, path,
  1293. 0, 0);
  1294. if (ret == 0)
  1295. goto again;
  1296. ret = 0;
  1297. goto out;
  1298. }
  1299. btrfs_release_path(log, log_path);
  1300. kfree(name);
  1301. ptr = (unsigned long)(di + 1);
  1302. ptr += name_len;
  1303. }
  1304. ret = 0;
  1305. out:
  1306. btrfs_release_path(root, path);
  1307. btrfs_release_path(log, log_path);
  1308. return ret;
  1309. }
  1310. /*
  1311. * deletion replay happens before we copy any new directory items
  1312. * out of the log or out of backreferences from inodes. It
  1313. * scans the log to find ranges of keys that log is authoritative for,
  1314. * and then scans the directory to find items in those ranges that are
  1315. * not present in the log.
  1316. *
  1317. * Anything we don't find in the log is unlinked and removed from the
  1318. * directory.
  1319. */
  1320. static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
  1321. struct btrfs_root *root,
  1322. struct btrfs_root *log,
  1323. struct btrfs_path *path,
  1324. u64 dirid, int del_all)
  1325. {
  1326. u64 range_start;
  1327. u64 range_end;
  1328. int key_type = BTRFS_DIR_LOG_ITEM_KEY;
  1329. int ret = 0;
  1330. struct btrfs_key dir_key;
  1331. struct btrfs_key found_key;
  1332. struct btrfs_path *log_path;
  1333. struct inode *dir;
  1334. dir_key.objectid = dirid;
  1335. dir_key.type = BTRFS_DIR_ITEM_KEY;
  1336. log_path = btrfs_alloc_path();
  1337. if (!log_path)
  1338. return -ENOMEM;
  1339. dir = read_one_inode(root, dirid);
  1340. /* it isn't an error if the inode isn't there, that can happen
  1341. * because we replay the deletes before we copy in the inode item
  1342. * from the log
  1343. */
  1344. if (!dir) {
  1345. btrfs_free_path(log_path);
  1346. return 0;
  1347. }
  1348. again:
  1349. range_start = 0;
  1350. range_end = 0;
  1351. while (1) {
  1352. if (del_all)
  1353. range_end = (u64)-1;
  1354. else {
  1355. ret = find_dir_range(log, path, dirid, key_type,
  1356. &range_start, &range_end);
  1357. if (ret != 0)
  1358. break;
  1359. }
  1360. dir_key.offset = range_start;
  1361. while (1) {
  1362. int nritems;
  1363. ret = btrfs_search_slot(NULL, root, &dir_key, path,
  1364. 0, 0);
  1365. if (ret < 0)
  1366. goto out;
  1367. nritems = btrfs_header_nritems(path->nodes[0]);
  1368. if (path->slots[0] >= nritems) {
  1369. ret = btrfs_next_leaf(root, path);
  1370. if (ret)
  1371. break;
  1372. }
  1373. btrfs_item_key_to_cpu(path->nodes[0], &found_key,
  1374. path->slots[0]);
  1375. if (found_key.objectid != dirid ||
  1376. found_key.type != dir_key.type)
  1377. goto next_type;
  1378. if (found_key.offset > range_end)
  1379. break;
  1380. ret = check_item_in_log(trans, root, log, path,
  1381. log_path, dir,
  1382. &found_key);
  1383. BUG_ON(ret);
  1384. if (found_key.offset == (u64)-1)
  1385. break;
  1386. dir_key.offset = found_key.offset + 1;
  1387. }
  1388. btrfs_release_path(root, path);
  1389. if (range_end == (u64)-1)
  1390. break;
  1391. range_start = range_end + 1;
  1392. }
  1393. next_type:
  1394. ret = 0;
  1395. if (key_type == BTRFS_DIR_LOG_ITEM_KEY) {
  1396. key_type = BTRFS_DIR_LOG_INDEX_KEY;
  1397. dir_key.type = BTRFS_DIR_INDEX_KEY;
  1398. btrfs_release_path(root, path);
  1399. goto again;
  1400. }
  1401. out:
  1402. btrfs_release_path(root, path);
  1403. btrfs_free_path(log_path);
  1404. iput(dir);
  1405. return ret;
  1406. }
  1407. /*
  1408. * the process_func used to replay items from the log tree. This
  1409. * gets called in two different stages. The first stage just looks
  1410. * for inodes and makes sure they are all copied into the subvolume.
  1411. *
  1412. * The second stage copies all the other item types from the log into
  1413. * the subvolume. The two stage approach is slower, but gets rid of
  1414. * lots of complexity around inodes referencing other inodes that exist
  1415. * only in the log (references come from either directory items or inode
  1416. * back refs).
  1417. */
  1418. static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
  1419. struct walk_control *wc, u64 gen)
  1420. {
  1421. int nritems;
  1422. struct btrfs_path *path;
  1423. struct btrfs_root *root = wc->replay_dest;
  1424. struct btrfs_key key;
  1425. int level;
  1426. int i;
  1427. int ret;
  1428. btrfs_read_buffer(eb, gen);
  1429. level = btrfs_header_level(eb);
  1430. if (level != 0)
  1431. return 0;
  1432. path = btrfs_alloc_path();
  1433. BUG_ON(!path);
  1434. nritems = btrfs_header_nritems(eb);
  1435. for (i = 0; i < nritems; i++) {
  1436. btrfs_item_key_to_cpu(eb, &key, i);
  1437. /* inode keys are done during the first stage */
  1438. if (key.type == BTRFS_INODE_ITEM_KEY &&
  1439. wc->stage == LOG_WALK_REPLAY_INODES) {
  1440. struct btrfs_inode_item *inode_item;
  1441. u32 mode;
  1442. inode_item = btrfs_item_ptr(eb, i,
  1443. struct btrfs_inode_item);
  1444. mode = btrfs_inode_mode(eb, inode_item);
  1445. if (S_ISDIR(mode)) {
  1446. ret = replay_dir_deletes(wc->trans,
  1447. root, log, path, key.objectid, 0);
  1448. BUG_ON(ret);
  1449. }
  1450. ret = overwrite_item(wc->trans, root, path,
  1451. eb, i, &key);
  1452. BUG_ON(ret);
  1453. /* for regular files, make sure corresponding
  1454. * orhpan item exist. extents past the new EOF
  1455. * will be truncated later by orphan cleanup.
  1456. */
  1457. if (S_ISREG(mode)) {
  1458. ret = insert_orphan_item(wc->trans, root,
  1459. key.objectid);
  1460. BUG_ON(ret);
  1461. }
  1462. ret = link_to_fixup_dir(wc->trans, root,
  1463. path, key.objectid);
  1464. BUG_ON(ret);
  1465. }
  1466. if (wc->stage < LOG_WALK_REPLAY_ALL)
  1467. continue;
  1468. /* these keys are simply copied */
  1469. if (key.type == BTRFS_XATTR_ITEM_KEY) {
  1470. ret = overwrite_item(wc->trans, root, path,
  1471. eb, i, &key);
  1472. BUG_ON(ret);
  1473. } else if (key.type == BTRFS_INODE_REF_KEY) {
  1474. ret = add_inode_ref(wc->trans, root, log, path,
  1475. eb, i, &key);
  1476. BUG_ON(ret && ret != -ENOENT);
  1477. } else if (key.type == BTRFS_EXTENT_DATA_KEY) {
  1478. ret = replay_one_extent(wc->trans, root, path,
  1479. eb, i, &key);
  1480. BUG_ON(ret);
  1481. } else if (key.type == BTRFS_DIR_ITEM_KEY ||
  1482. key.type == BTRFS_DIR_INDEX_KEY) {
  1483. ret = replay_one_dir_item(wc->trans, root, path,
  1484. eb, i, &key);
  1485. BUG_ON(ret);
  1486. }
  1487. }
  1488. btrfs_free_path(path);
  1489. return 0;
  1490. }
  1491. static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
  1492. struct btrfs_root *root,
  1493. struct btrfs_path *path, int *level,
  1494. struct walk_control *wc)
  1495. {
  1496. u64 root_owner;
  1497. u64 bytenr;
  1498. u64 ptr_gen;
  1499. struct extent_buffer *next;
  1500. struct extent_buffer *cur;
  1501. struct extent_buffer *parent;
  1502. u32 blocksize;
  1503. int ret = 0;
  1504. WARN_ON(*level < 0);
  1505. WARN_ON(*level >= BTRFS_MAX_LEVEL);
  1506. while (*level > 0) {
  1507. WARN_ON(*level < 0);
  1508. WARN_ON(*level >= BTRFS_MAX_LEVEL);
  1509. cur = path->nodes[*level];
  1510. if (btrfs_header_level(cur) != *level)
  1511. WARN_ON(1);
  1512. if (path->slots[*level] >=
  1513. btrfs_header_nritems(cur))
  1514. break;
  1515. bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
  1516. ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
  1517. blocksize = btrfs_level_size(root, *level - 1);
  1518. parent = path->nodes[*level];
  1519. root_owner = btrfs_header_owner(parent);
  1520. next = btrfs_find_create_tree_block(root, bytenr, blocksize);
  1521. if (!next)
  1522. return -ENOMEM;
  1523. if (*level == 1) {
  1524. wc->process_func(root, next, wc, ptr_gen);
  1525. path->slots[*level]++;
  1526. if (wc->free) {
  1527. btrfs_read_buffer(next, ptr_gen);
  1528. btrfs_tree_lock(next);
  1529. clean_tree_block(trans, root, next);
  1530. btrfs_set_lock_blocking(next);
  1531. btrfs_wait_tree_block_writeback(next);
  1532. btrfs_tree_unlock(next);
  1533. WARN_ON(root_owner !=
  1534. BTRFS_TREE_LOG_OBJECTID);
  1535. ret = btrfs_free_reserved_extent(root,
  1536. bytenr, blocksize);
  1537. BUG_ON(ret);
  1538. }
  1539. free_extent_buffer(next);
  1540. continue;
  1541. }
  1542. btrfs_read_buffer(next, ptr_gen);
  1543. WARN_ON(*level <= 0);
  1544. if (path->nodes[*level-1])
  1545. free_extent_buffer(path->nodes[*level-1]);
  1546. path->nodes[*level-1] = next;
  1547. *level = btrfs_header_level(next);
  1548. path->slots[*level] = 0;
  1549. cond_resched();
  1550. }
  1551. WARN_ON(*level < 0);
  1552. WARN_ON(*level >= BTRFS_MAX_LEVEL);
  1553. path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
  1554. cond_resched();
  1555. return 0;
  1556. }
  1557. static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
  1558. struct btrfs_root *root,
  1559. struct btrfs_path *path, int *level,
  1560. struct walk_control *wc)
  1561. {
  1562. u64 root_owner;
  1563. int i;
  1564. int slot;
  1565. int ret;
  1566. for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
  1567. slot = path->slots[i];
  1568. if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
  1569. path->slots[i]++;
  1570. *level = i;
  1571. WARN_ON(*level == 0);
  1572. return 0;
  1573. } else {
  1574. struct extent_buffer *parent;
  1575. if (path->nodes[*level] == root->node)
  1576. parent = path->nodes[*level];
  1577. else
  1578. parent = path->nodes[*level + 1];
  1579. root_owner = btrfs_header_owner(parent);
  1580. wc->process_func(root, path->nodes[*level], wc,
  1581. btrfs_header_generation(path->nodes[*level]));
  1582. if (wc->free) {
  1583. struct extent_buffer *next;
  1584. next = path->nodes[*level];
  1585. btrfs_tree_lock(next);
  1586. clean_tree_block(trans, root, next);
  1587. btrfs_set_lock_blocking(next);
  1588. btrfs_wait_tree_block_writeback(next);
  1589. btrfs_tree_unlock(next);
  1590. WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID);
  1591. ret = btrfs_free_reserved_extent(root,
  1592. path->nodes[*level]->start,
  1593. path->nodes[*level]->len);
  1594. BUG_ON(ret);
  1595. }
  1596. free_extent_buffer(path->nodes[*level]);
  1597. path->nodes[*level] = NULL;
  1598. *level = i + 1;
  1599. }
  1600. }
  1601. return 1;
  1602. }
  1603. /*
  1604. * drop the reference count on the tree rooted at 'snap'. This traverses
  1605. * the tree freeing any blocks that have a ref count of zero after being
  1606. * decremented.
  1607. */
  1608. static int walk_log_tree(struct btrfs_trans_handle *trans,
  1609. struct btrfs_root *log, struct walk_control *wc)
  1610. {
  1611. int ret = 0;
  1612. int wret;
  1613. int level;
  1614. struct btrfs_path *path;
  1615. int i;
  1616. int orig_level;
  1617. path = btrfs_alloc_path();
  1618. if (!path)
  1619. return -ENOMEM;
  1620. level = btrfs_header_level(log->node);
  1621. orig_level = level;
  1622. path->nodes[level] = log->node;
  1623. extent_buffer_get(log->node);
  1624. path->slots[level] = 0;
  1625. while (1) {
  1626. wret = walk_down_log_tree(trans, log, path, &level, wc);
  1627. if (wret > 0)
  1628. break;
  1629. if (wret < 0)
  1630. ret = wret;
  1631. wret = walk_up_log_tree(trans, log, path, &level, wc);
  1632. if (wret > 0)
  1633. break;
  1634. if (wret < 0)
  1635. ret = wret;
  1636. }
  1637. /* was the root node processed? if not, catch it here */
  1638. if (path->nodes[orig_level]) {
  1639. wc->process_func(log, path->nodes[orig_level], wc,
  1640. btrfs_header_generation(path->nodes[orig_level]));
  1641. if (wc->free) {
  1642. struct extent_buffer *next;
  1643. next = path->nodes[orig_level];
  1644. btrfs_tree_lock(next);
  1645. clean_tree_block(trans, log, next);
  1646. btrfs_set_lock_blocking(next);
  1647. btrfs_wait_tree_block_writeback(next);
  1648. btrfs_tree_unlock(next);
  1649. WARN_ON(log->root_key.objectid !=
  1650. BTRFS_TREE_LOG_OBJECTID);
  1651. ret = btrfs_free_reserved_extent(log, next->start,
  1652. next->len);
  1653. BUG_ON(ret);
  1654. }
  1655. }
  1656. for (i = 0; i <= orig_level; i++) {
  1657. if (path->nodes[i]) {
  1658. free_extent_buffer(path->nodes[i]);
  1659. path->nodes[i] = NULL;
  1660. }
  1661. }
  1662. btrfs_free_path(path);
  1663. return ret;
  1664. }
  1665. /*
  1666. * helper function to update the item for a given subvolumes log root
  1667. * in the tree of log roots
  1668. */
  1669. static int update_log_root(struct btrfs_trans_handle *trans,
  1670. struct btrfs_root *log)
  1671. {
  1672. int ret;
  1673. if (log->log_transid == 1) {
  1674. /* insert root item on the first sync */
  1675. ret = btrfs_insert_root(trans, log->fs_info->log_root_tree,
  1676. &log->root_key, &log->root_item);
  1677. } else {
  1678. ret = btrfs_update_root(trans, log->fs_info->log_root_tree,
  1679. &log->root_key, &log->root_item);
  1680. }
  1681. return ret;
  1682. }
  1683. static int wait_log_commit(struct btrfs_trans_handle *trans,
  1684. struct btrfs_root *root, unsigned long transid)
  1685. {
  1686. DEFINE_WAIT(wait);
  1687. int index = transid % 2;
  1688. /*
  1689. * we only allow two pending log transactions at a time,
  1690. * so we know that if ours is more than 2 older than the
  1691. * current transaction, we're done
  1692. */
  1693. do {
  1694. prepare_to_wait(&root->log_commit_wait[index],
  1695. &wait, TASK_UNINTERRUPTIBLE);
  1696. mutex_unlock(&root->log_mutex);
  1697. if (root->fs_info->last_trans_log_full_commit !=
  1698. trans->transid && root->log_transid < transid + 2 &&
  1699. atomic_read(&root->log_commit[index]))
  1700. schedule();
  1701. finish_wait(&root->log_commit_wait[index], &wait);
  1702. mutex_lock(&root->log_mutex);
  1703. } while (root->log_transid < transid + 2 &&
  1704. atomic_read(&root->log_commit[index]));
  1705. return 0;
  1706. }
  1707. static int wait_for_writer(struct btrfs_trans_handle *trans,
  1708. struct btrfs_root *root)
  1709. {
  1710. DEFINE_WAIT(wait);
  1711. while (atomic_read(&root->log_writers)) {
  1712. prepare_to_wait(&root->log_writer_wait,
  1713. &wait, TASK_UNINTERRUPTIBLE);
  1714. mutex_unlock(&root->log_mutex);
  1715. if (root->fs_info->last_trans_log_full_commit !=
  1716. trans->transid && atomic_read(&root->log_writers))
  1717. schedule();
  1718. mutex_lock(&root->log_mutex);
  1719. finish_wait(&root->log_writer_wait, &wait);
  1720. }
  1721. return 0;
  1722. }
  1723. /*
  1724. * btrfs_sync_log does sends a given tree log down to the disk and
  1725. * updates the super blocks to record it. When this call is done,
  1726. * you know that any inodes previously logged are safely on disk only
  1727. * if it returns 0.
  1728. *
  1729. * Any other return value means you need to call btrfs_commit_transaction.
  1730. * Some of the edge cases for fsyncing directories that have had unlinks
  1731. * or renames done in the past mean that sometimes the only safe
  1732. * fsync is to commit the whole FS. When btrfs_sync_log returns -EAGAIN,
  1733. * that has happened.
  1734. */
  1735. int btrfs_sync_log(struct btrfs_trans_handle *trans,
  1736. struct btrfs_root *root)
  1737. {
  1738. int index1;
  1739. int index2;
  1740. int mark;
  1741. int ret;
  1742. struct btrfs_root *log = root->log_root;
  1743. struct btrfs_root *log_root_tree = root->fs_info->log_root_tree;
  1744. unsigned long log_transid = 0;
  1745. mutex_lock(&root->log_mutex);
  1746. index1 = root->log_transid % 2;
  1747. if (atomic_read(&root->log_commit[index1])) {
  1748. wait_log_commit(trans, root, root->log_transid);
  1749. mutex_unlock(&root->log_mutex);
  1750. return 0;
  1751. }
  1752. atomic_set(&root->log_commit[index1], 1);
  1753. /* wait for previous tree log sync to complete */
  1754. if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
  1755. wait_log_commit(trans, root, root->log_transid - 1);
  1756. while (1) {
  1757. unsigned long batch = root->log_batch;
  1758. if (root->log_multiple_pids) {
  1759. mutex_unlock(&root->log_mutex);
  1760. schedule_timeout_uninterruptible(1);
  1761. mutex_lock(&root->log_mutex);
  1762. }
  1763. wait_for_writer(trans, root);
  1764. if (batch == root->log_batch)
  1765. break;
  1766. }
  1767. /* bail out if we need to do a full commit */
  1768. if (root->fs_info->last_trans_log_full_commit == trans->transid) {
  1769. ret = -EAGAIN;
  1770. mutex_unlock(&root->log_mutex);
  1771. goto out;
  1772. }
  1773. log_transid = root->log_transid;
  1774. if (log_transid % 2 == 0)
  1775. mark = EXTENT_DIRTY;
  1776. else
  1777. mark = EXTENT_NEW;
  1778. /* we start IO on all the marked extents here, but we don't actually
  1779. * wait for them until later.
  1780. */
  1781. ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark);
  1782. BUG_ON(ret);
  1783. btrfs_set_root_node(&log->root_item, log->node);
  1784. root->log_batch = 0;
  1785. root->log_transid++;
  1786. log->log_transid = root->log_transid;
  1787. root->log_start_pid = 0;
  1788. smp_mb();
  1789. /*
  1790. * IO has been started, blocks of the log tree have WRITTEN flag set
  1791. * in their headers. new modifications of the log will be written to
  1792. * new positions. so it's safe to allow log writers to go in.
  1793. */
  1794. mutex_unlock(&root->log_mutex);
  1795. mutex_lock(&log_root_tree->log_mutex);
  1796. log_root_tree->log_batch++;
  1797. atomic_inc(&log_root_tree->log_writers);
  1798. mutex_unlock(&log_root_tree->log_mutex);
  1799. ret = update_log_root(trans, log);
  1800. mutex_lock(&log_root_tree->log_mutex);
  1801. if (atomic_dec_and_test(&log_root_tree->log_writers)) {
  1802. smp_mb();
  1803. if (waitqueue_active(&log_root_tree->log_writer_wait))
  1804. wake_up(&log_root_tree->log_writer_wait);
  1805. }
  1806. if (ret) {
  1807. BUG_ON(ret != -ENOSPC);
  1808. root->fs_info->last_trans_log_full_commit = trans->transid;
  1809. btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
  1810. mutex_unlock(&log_root_tree->log_mutex);
  1811. ret = -EAGAIN;
  1812. goto out;
  1813. }
  1814. index2 = log_root_tree->log_transid % 2;
  1815. if (atomic_read(&log_root_tree->log_commit[index2])) {
  1816. btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
  1817. wait_log_commit(trans, log_root_tree,
  1818. log_root_tree->log_transid);
  1819. mutex_unlock(&log_root_tree->log_mutex);
  1820. ret = 0;
  1821. goto out;
  1822. }
  1823. atomic_set(&log_root_tree->log_commit[index2], 1);
  1824. if (atomic_read(&log_root_tree->log_commit[(index2 + 1) % 2])) {
  1825. wait_log_commit(trans, log_root_tree,
  1826. log_root_tree->log_transid - 1);
  1827. }
  1828. wait_for_writer(trans, log_root_tree);
  1829. /*
  1830. * now that we've moved on to the tree of log tree roots,
  1831. * check the full commit flag again
  1832. */
  1833. if (root->fs_info->last_trans_log_full_commit == trans->transid) {
  1834. btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
  1835. mutex_unlock(&log_root_tree->log_mutex);
  1836. ret = -EAGAIN;
  1837. goto out_wake_log_root;
  1838. }
  1839. ret = btrfs_write_and_wait_marked_extents(log_root_tree,
  1840. &log_root_tree->dirty_log_pages,
  1841. EXTENT_DIRTY | EXTENT_NEW);
  1842. BUG_ON(ret);
  1843. btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
  1844. btrfs_set_super_log_root(&root->fs_info->super_for_commit,
  1845. log_root_tree->node->start);
  1846. btrfs_set_super_log_root_level(&root->fs_info->super_for_commit,
  1847. btrfs_header_level(log_root_tree->node));
  1848. log_root_tree->log_batch = 0;
  1849. log_root_tree->log_transid++;
  1850. smp_mb();
  1851. mutex_unlock(&log_root_tree->log_mutex);
  1852. /*
  1853. * nobody else is going to jump in and write the the ctree
  1854. * super here because the log_commit atomic below is protecting
  1855. * us. We must be called with a transaction handle pinning
  1856. * the running transaction open, so a full commit can't hop
  1857. * in and cause problems either.
  1858. */
  1859. write_ctree_super(trans, root->fs_info->tree_root, 1);
  1860. ret = 0;
  1861. mutex_lock(&root->log_mutex);
  1862. if (root->last_log_commit < log_transid)
  1863. root->last_log_commit = log_transid;
  1864. mutex_unlock(&root->log_mutex);
  1865. out_wake_log_root:
  1866. atomic_set(&log_root_tree->log_commit[index2], 0);
  1867. smp_mb();
  1868. if (waitqueue_active(&log_root_tree->log_commit_wait[index2]))
  1869. wake_up(&log_root_tree->log_commit_wait[index2]);
  1870. out:
  1871. atomic_set(&root->log_commit[index1], 0);
  1872. smp_mb();
  1873. if (waitqueue_active(&root->log_commit_wait[index1]))
  1874. wake_up(&root->log_commit_wait[index1]);
  1875. return ret;
  1876. }
  1877. static void free_log_tree(struct btrfs_trans_handle *trans,
  1878. struct btrfs_root *log)
  1879. {
  1880. int ret;
  1881. u64 start;
  1882. u64 end;
  1883. struct walk_control wc = {
  1884. .free = 1,
  1885. .process_func = process_one_buffer
  1886. };
  1887. ret = walk_log_tree(trans, log, &wc);
  1888. BUG_ON(ret);
  1889. while (1) {
  1890. ret = find_first_extent_bit(&log->dirty_log_pages,
  1891. 0, &start, &end, EXTENT_DIRTY | EXTENT_NEW);
  1892. if (ret)
  1893. break;
  1894. clear_extent_bits(&log->dirty_log_pages, start, end,
  1895. EXTENT_DIRTY | EXTENT_NEW, GFP_NOFS);
  1896. }
  1897. free_extent_buffer(log->node);
  1898. kfree(log);
  1899. }
  1900. /*
  1901. * free all the extents used by the tree log. This should be called
  1902. * at commit time of the full transaction
  1903. */
  1904. int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
  1905. {
  1906. if (root->log_root) {
  1907. free_log_tree(trans, root->log_root);
  1908. root->log_root = NULL;
  1909. }
  1910. return 0;
  1911. }
  1912. int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
  1913. struct btrfs_fs_info *fs_info)
  1914. {
  1915. if (fs_info->log_root_tree) {
  1916. free_log_tree(trans, fs_info->log_root_tree);
  1917. fs_info->log_root_tree = NULL;
  1918. }
  1919. return 0;
  1920. }
  1921. /*
  1922. * If both a file and directory are logged, and unlinks or renames are
  1923. * mixed in, we have a few interesting corners:
  1924. *
  1925. * create file X in dir Y
  1926. * link file X to X.link in dir Y
  1927. * fsync file X
  1928. * unlink file X but leave X.link
  1929. * fsync dir Y
  1930. *
  1931. * After a crash we would expect only X.link to exist. But file X
  1932. * didn't get fsync'd again so the log has back refs for X and X.link.
  1933. *
  1934. * We solve this by removing directory entries and inode backrefs from the
  1935. * log when a file that was logged in the current transaction is
  1936. * unlinked. Any later fsync will include the updated log entries, and
  1937. * we'll be able to reconstruct the proper directory items from backrefs.
  1938. *
  1939. * This optimizations allows us to avoid relogging the entire inode
  1940. * or the entire directory.
  1941. */
  1942. int btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans,
  1943. struct btrfs_root *root,
  1944. const char *name, int name_len,
  1945. struct inode *dir, u64 index)
  1946. {
  1947. struct btrfs_root *log;
  1948. struct btrfs_dir_item *di;
  1949. struct btrfs_path *path;
  1950. int ret;
  1951. int err = 0;
  1952. int bytes_del = 0;
  1953. u64 dir_ino = btrfs_ino(dir);
  1954. if (BTRFS_I(dir)->logged_trans < trans->transid)
  1955. return 0;
  1956. ret = join_running_log_trans(root);
  1957. if (ret)
  1958. return 0;
  1959. mutex_lock(&BTRFS_I(dir)->log_mutex);
  1960. log = root->log_root;
  1961. path = btrfs_alloc_path();
  1962. if (!path)
  1963. return -ENOMEM;
  1964. di = btrfs_lookup_dir_item(trans, log, path, dir_ino,
  1965. name, name_len, -1);
  1966. if (IS_ERR(di)) {
  1967. err = PTR_ERR(di);
  1968. goto fail;
  1969. }
  1970. if (di) {
  1971. ret = btrfs_delete_one_dir_name(trans, log, path, di);
  1972. bytes_del += name_len;
  1973. BUG_ON(ret);
  1974. }
  1975. btrfs_release_path(log, path);
  1976. di = btrfs_lookup_dir_index_item(trans, log, path, dir_ino,
  1977. index, name, name_len, -1);
  1978. if (IS_ERR(di)) {
  1979. err = PTR_ERR(di);
  1980. goto fail;
  1981. }
  1982. if (di) {
  1983. ret = btrfs_delete_one_dir_name(trans, log, path, di);
  1984. bytes_del += name_len;
  1985. BUG_ON(ret);
  1986. }
  1987. /* update the directory size in the log to reflect the names
  1988. * we have removed
  1989. */
  1990. if (bytes_del) {
  1991. struct btrfs_key key;
  1992. key.objectid = dir_ino;
  1993. key.offset = 0;
  1994. key.type = BTRFS_INODE_ITEM_KEY;
  1995. btrfs_release_path(log, path);
  1996. ret = btrfs_search_slot(trans, log, &key, path, 0, 1);
  1997. if (ret < 0) {
  1998. err = ret;
  1999. goto fail;
  2000. }
  2001. if (ret == 0) {
  2002. struct btrfs_inode_item *item;
  2003. u64 i_size;
  2004. item = btrfs_item_ptr(path->nodes[0], path->slots[0],
  2005. struct btrfs_inode_item);
  2006. i_size = btrfs_inode_size(path->nodes[0], item);
  2007. if (i_size > bytes_del)
  2008. i_size -= bytes_del;
  2009. else
  2010. i_size = 0;
  2011. btrfs_set_inode_size(path->nodes[0], item, i_size);
  2012. btrfs_mark_buffer_dirty(path->nodes[0]);
  2013. } else
  2014. ret = 0;
  2015. btrfs_release_path(log, path);
  2016. }
  2017. fail:
  2018. btrfs_free_path(path);
  2019. mutex_unlock(&BTRFS_I(dir)->log_mutex);
  2020. if (ret == -ENOSPC) {
  2021. root->fs_info->last_trans_log_full_commit = trans->transid;
  2022. ret = 0;
  2023. }
  2024. btrfs_end_log_trans(root);
  2025. return err;
  2026. }
  2027. /* see comments for btrfs_del_dir_entries_in_log */
  2028. int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans,
  2029. struct btrfs_root *root,
  2030. const char *name, int name_len,
  2031. struct inode *inode, u64 dirid)
  2032. {
  2033. struct btrfs_root *log;
  2034. u64 index;
  2035. int ret;
  2036. if (BTRFS_I(inode)->logged_trans < trans->transid)
  2037. return 0;
  2038. ret = join_running_log_trans(root);
  2039. if (ret)
  2040. return 0;
  2041. log = root->log_root;
  2042. mutex_lock(&BTRFS_I(inode)->log_mutex);
  2043. ret = btrfs_del_inode_ref(trans, log, name, name_len, btrfs_ino(inode),
  2044. dirid, &index);
  2045. mutex_unlock(&BTRFS_I(inode)->log_mutex);
  2046. if (ret == -ENOSPC) {
  2047. root->fs_info->last_trans_log_full_commit = trans->transid;
  2048. ret = 0;
  2049. }
  2050. btrfs_end_log_trans(root);
  2051. return ret;
  2052. }
  2053. /*
  2054. * creates a range item in the log for 'dirid'. first_offset and
  2055. * last_offset tell us which parts of the key space the log should
  2056. * be considered authoritative for.
  2057. */
  2058. static noinline int insert_dir_log_key(struct btrfs_trans_handle *trans,
  2059. struct btrfs_root *log,
  2060. struct btrfs_path *path,
  2061. int key_type, u64 dirid,
  2062. u64 first_offset, u64 last_offset)
  2063. {
  2064. int ret;
  2065. struct btrfs_key key;
  2066. struct btrfs_dir_log_item *item;
  2067. key.objectid = dirid;
  2068. key.offset = first_offset;
  2069. if (key_type == BTRFS_DIR_ITEM_KEY)
  2070. key.type = BTRFS_DIR_LOG_ITEM_KEY;
  2071. else
  2072. key.type = BTRFS_DIR_LOG_INDEX_KEY;
  2073. ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
  2074. if (ret)
  2075. return ret;
  2076. item = btrfs_item_ptr(path->nodes[0], path->slots[0],
  2077. struct btrfs_dir_log_item);
  2078. btrfs_set_dir_log_end(path->nodes[0], item, last_offset);
  2079. btrfs_mark_buffer_dirty(path->nodes[0]);
  2080. btrfs_release_path(log, path);
  2081. return 0;
  2082. }
  2083. /*
  2084. * log all the items included in the current transaction for a given
  2085. * directory. This also creates the range items in the log tree required
  2086. * to replay anything deleted before the fsync
  2087. */
  2088. static noinline int log_dir_items(struct btrfs_trans_handle *trans,
  2089. struct btrfs_root *root, struct inode *inode,
  2090. struct btrfs_path *path,
  2091. struct btrfs_path *dst_path, int key_type,
  2092. u64 min_offset, u64 *last_offset_ret)
  2093. {
  2094. struct btrfs_key min_key;
  2095. struct btrfs_key max_key;
  2096. struct btrfs_root *log = root->log_root;
  2097. struct extent_buffer *src;
  2098. int err = 0;
  2099. int ret;
  2100. int i;
  2101. int nritems;
  2102. u64 first_offset = min_offset;
  2103. u64 last_offset = (u64)-1;
  2104. u64 ino = btrfs_ino(inode);
  2105. log = root->log_root;
  2106. max_key.objectid = ino;
  2107. max_key.offset = (u64)-1;
  2108. max_key.type = key_type;
  2109. min_key.objectid = ino;
  2110. min_key.type = key_type;
  2111. min_key.offset = min_offset;
  2112. path->keep_locks = 1;
  2113. ret = btrfs_search_forward(root, &min_key, &max_key,
  2114. path, 0, trans->transid);
  2115. /*
  2116. * we didn't find anything from this transaction, see if there
  2117. * is anything at all
  2118. */
  2119. if (ret != 0 || min_key.objectid != ino || min_key.type != key_type) {
  2120. min_key.objectid = ino;
  2121. min_key.type = key_type;
  2122. min_key.offset = (u64)-1;
  2123. btrfs_release_path(root, path);
  2124. ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
  2125. if (ret < 0) {
  2126. btrfs_release_path(root, path);
  2127. return ret;
  2128. }
  2129. ret = btrfs_previous_item(root, path, ino, key_type);
  2130. /* if ret == 0 there are items for this type,
  2131. * create a range to tell us the last key of this type.
  2132. * otherwise, there are no items in this directory after
  2133. * *min_offset, and we create a range to indicate that.
  2134. */
  2135. if (ret == 0) {
  2136. struct btrfs_key tmp;
  2137. btrfs_item_key_to_cpu(path->nodes[0], &tmp,
  2138. path->slots[0]);
  2139. if (key_type == tmp.type)
  2140. first_offset = max(min_offset, tmp.offset) + 1;
  2141. }
  2142. goto done;
  2143. }
  2144. /* go backward to find any previous key */
  2145. ret = btrfs_previous_item(root, path, ino, key_type);
  2146. if (ret == 0) {
  2147. struct btrfs_key tmp;
  2148. btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
  2149. if (key_type == tmp.type) {
  2150. first_offset = tmp.offset;
  2151. ret = overwrite_item(trans, log, dst_path,
  2152. path->nodes[0], path->slots[0],
  2153. &tmp);
  2154. if (ret) {
  2155. err = ret;
  2156. goto done;
  2157. }
  2158. }
  2159. }
  2160. btrfs_release_path(root, path);
  2161. /* find the first key from this transaction again */
  2162. ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
  2163. if (ret != 0) {
  2164. WARN_ON(1);
  2165. goto done;
  2166. }
  2167. /*
  2168. * we have a block from this transaction, log every item in it
  2169. * from our directory
  2170. */
  2171. while (1) {
  2172. struct btrfs_key tmp;
  2173. src = path->nodes[0];
  2174. nritems = btrfs_header_nritems(src);
  2175. for (i = path->slots[0]; i < nritems; i++) {
  2176. btrfs_item_key_to_cpu(src, &min_key, i);
  2177. if (min_key.objectid != ino || min_key.type != key_type)
  2178. goto done;
  2179. ret = overwrite_item(trans, log, dst_path, src, i,
  2180. &min_key);
  2181. if (ret) {
  2182. err = ret;
  2183. goto done;
  2184. }
  2185. }
  2186. path->slots[0] = nritems;
  2187. /*
  2188. * look ahead to the next item and see if it is also
  2189. * from this directory and from this transaction
  2190. */
  2191. ret = btrfs_next_leaf(root, path);
  2192. if (ret == 1) {
  2193. last_offset = (u64)-1;
  2194. goto done;
  2195. }
  2196. btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
  2197. if (tmp.objectid != ino || tmp.type != key_type) {
  2198. last_offset = (u64)-1;
  2199. goto done;
  2200. }
  2201. if (btrfs_header_generation(path->nodes[0]) != trans->transid) {
  2202. ret = overwrite_item(trans, log, dst_path,
  2203. path->nodes[0], path->slots[0],
  2204. &tmp);
  2205. if (ret)
  2206. err = ret;
  2207. else
  2208. last_offset = tmp.offset;
  2209. goto done;
  2210. }
  2211. }
  2212. done:
  2213. btrfs_release_path(root, path);
  2214. btrfs_release_path(log, dst_path);
  2215. if (err == 0) {
  2216. *last_offset_ret = last_offset;
  2217. /*
  2218. * insert the log range keys to indicate where the log
  2219. * is valid
  2220. */
  2221. ret = insert_dir_log_key(trans, log, path, key_type,
  2222. ino, first_offset, last_offset);
  2223. if (ret)
  2224. err = ret;
  2225. }
  2226. return err;
  2227. }
  2228. /*
  2229. * logging directories is very similar to logging inodes, We find all the items
  2230. * from the current transaction and write them to the log.
  2231. *
  2232. * The recovery code scans the directory in the subvolume, and if it finds a
  2233. * key in the range logged that is not present in the log tree, then it means
  2234. * that dir entry was unlinked during the transaction.
  2235. *
  2236. * In order for that scan to work, we must include one key smaller than
  2237. * the smallest logged by this transaction and one key larger than the largest
  2238. * key logged by this transaction.
  2239. */
  2240. static noinline int log_directory_changes(struct btrfs_trans_handle *trans,
  2241. struct btrfs_root *root, struct inode *inode,
  2242. struct btrfs_path *path,
  2243. struct btrfs_path *dst_path)
  2244. {
  2245. u64 min_key;
  2246. u64 max_key;
  2247. int ret;
  2248. int key_type = BTRFS_DIR_ITEM_KEY;
  2249. again:
  2250. min_key = 0;
  2251. max_key = 0;
  2252. while (1) {
  2253. ret = log_dir_items(trans, root, inode, path,
  2254. dst_path, key_type, min_key,
  2255. &max_key);
  2256. if (ret)
  2257. return ret;
  2258. if (max_key == (u64)-1)
  2259. break;
  2260. min_key = max_key + 1;
  2261. }
  2262. if (key_type == BTRFS_DIR_ITEM_KEY) {
  2263. key_type = BTRFS_DIR_INDEX_KEY;
  2264. goto again;
  2265. }
  2266. return 0;
  2267. }
  2268. /*
  2269. * a helper function to drop items from the log before we relog an
  2270. * inode. max_key_type indicates the highest item type to remove.
  2271. * This cannot be run for file data extents because it does not
  2272. * free the extents they point to.
  2273. */
  2274. static int drop_objectid_items(struct btrfs_trans_handle *trans,
  2275. struct btrfs_root *log,
  2276. struct btrfs_path *path,
  2277. u64 objectid, int max_key_type)
  2278. {
  2279. int ret;
  2280. struct btrfs_key key;
  2281. struct btrfs_key found_key;
  2282. key.objectid = objectid;
  2283. key.type = max_key_type;
  2284. key.offset = (u64)-1;
  2285. while (1) {
  2286. ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
  2287. BUG_ON(ret == 0);
  2288. if (ret < 0)
  2289. break;
  2290. if (path->slots[0] == 0)
  2291. break;
  2292. path->slots[0]--;
  2293. btrfs_item_key_to_cpu(path->nodes[0], &found_key,
  2294. path->slots[0]);
  2295. if (found_key.objectid != objectid)
  2296. break;
  2297. ret = btrfs_del_item(trans, log, path);
  2298. BUG_ON(ret);
  2299. btrfs_release_path(log, path);
  2300. }
  2301. btrfs_release_path(log, path);
  2302. return ret;
  2303. }
  2304. static noinline int copy_items(struct btrfs_trans_handle *trans,
  2305. struct btrfs_root *log,
  2306. struct btrfs_path *dst_path,
  2307. struct extent_buffer *src,
  2308. int start_slot, int nr, int inode_only)
  2309. {
  2310. unsigned long src_offset;
  2311. unsigned long dst_offset;
  2312. struct btrfs_file_extent_item *extent;
  2313. struct btrfs_inode_item *inode_item;
  2314. int ret;
  2315. struct btrfs_key *ins_keys;
  2316. u32 *ins_sizes;
  2317. char *ins_data;
  2318. int i;
  2319. struct list_head ordered_sums;
  2320. INIT_LIST_HEAD(&ordered_sums);
  2321. ins_data = kmalloc(nr * sizeof(struct btrfs_key) +
  2322. nr * sizeof(u32), GFP_NOFS);
  2323. if (!ins_data)
  2324. return -ENOMEM;
  2325. ins_sizes = (u32 *)ins_data;
  2326. ins_keys = (struct btrfs_key *)(ins_data + nr * sizeof(u32));
  2327. for (i = 0; i < nr; i++) {
  2328. ins_sizes[i] = btrfs_item_size_nr(src, i + start_slot);
  2329. btrfs_item_key_to_cpu(src, ins_keys + i, i + start_slot);
  2330. }
  2331. ret = btrfs_insert_empty_items(trans, log, dst_path,
  2332. ins_keys, ins_sizes, nr);
  2333. if (ret) {
  2334. kfree(ins_data);
  2335. return ret;
  2336. }
  2337. for (i = 0; i < nr; i++, dst_path->slots[0]++) {
  2338. dst_offset = btrfs_item_ptr_offset(dst_path->nodes[0],
  2339. dst_path->slots[0]);
  2340. src_offset = btrfs_item_ptr_offset(src, start_slot + i);
  2341. copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
  2342. src_offset, ins_sizes[i]);
  2343. if (inode_only == LOG_INODE_EXISTS &&
  2344. ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
  2345. inode_item = btrfs_item_ptr(dst_path->nodes[0],
  2346. dst_path->slots[0],
  2347. struct btrfs_inode_item);
  2348. btrfs_set_inode_size(dst_path->nodes[0], inode_item, 0);
  2349. /* set the generation to zero so the recover code
  2350. * can tell the difference between an logging
  2351. * just to say 'this inode exists' and a logging
  2352. * to say 'update this inode with these values'
  2353. */
  2354. btrfs_set_inode_generation(dst_path->nodes[0],
  2355. inode_item, 0);
  2356. }
  2357. /* take a reference on file data extents so that truncates
  2358. * or deletes of this inode don't have to relog the inode
  2359. * again
  2360. */
  2361. if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY) {
  2362. int found_type;
  2363. extent = btrfs_item_ptr(src, start_slot + i,
  2364. struct btrfs_file_extent_item);
  2365. found_type = btrfs_file_extent_type(src, extent);
  2366. if (found_type == BTRFS_FILE_EXTENT_REG ||
  2367. found_type == BTRFS_FILE_EXTENT_PREALLOC) {
  2368. u64 ds, dl, cs, cl;
  2369. ds = btrfs_file_extent_disk_bytenr(src,
  2370. extent);
  2371. /* ds == 0 is a hole */
  2372. if (ds == 0)
  2373. continue;
  2374. dl = btrfs_file_extent_disk_num_bytes(src,
  2375. extent);
  2376. cs = btrfs_file_extent_offset(src, extent);
  2377. cl = btrfs_file_extent_num_bytes(src,
  2378. extent);
  2379. if (btrfs_file_extent_compression(src,
  2380. extent)) {
  2381. cs = 0;
  2382. cl = dl;
  2383. }
  2384. ret = btrfs_lookup_csums_range(
  2385. log->fs_info->csum_root,
  2386. ds + cs, ds + cs + cl - 1,
  2387. &ordered_sums);
  2388. BUG_ON(ret);
  2389. }
  2390. }
  2391. }
  2392. btrfs_mark_buffer_dirty(dst_path->nodes[0]);
  2393. btrfs_release_path(log, dst_path);
  2394. kfree(ins_data);
  2395. /*
  2396. * we have to do this after the loop above to avoid changing the
  2397. * log tree while trying to change the log tree.
  2398. */
  2399. ret = 0;
  2400. while (!list_empty(&ordered_sums)) {
  2401. struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
  2402. struct btrfs_ordered_sum,
  2403. list);
  2404. if (!ret)
  2405. ret = btrfs_csum_file_blocks(trans, log, sums);
  2406. list_del(&sums->list);
  2407. kfree(sums);
  2408. }
  2409. return ret;
  2410. }
  2411. /* log a single inode in the tree log.
  2412. * At least one parent directory for this inode must exist in the tree
  2413. * or be logged already.
  2414. *
  2415. * Any items from this inode changed by the current transaction are copied
  2416. * to the log tree. An extra reference is taken on any extents in this
  2417. * file, allowing us to avoid a whole pile of corner cases around logging
  2418. * blocks that have been removed from the tree.
  2419. *
  2420. * See LOG_INODE_ALL and related defines for a description of what inode_only
  2421. * does.
  2422. *
  2423. * This handles both files and directories.
  2424. */
  2425. static int btrfs_log_inode(struct btrfs_trans_handle *trans,
  2426. struct btrfs_root *root, struct inode *inode,
  2427. int inode_only)
  2428. {
  2429. struct btrfs_path *path;
  2430. struct btrfs_path *dst_path;
  2431. struct btrfs_key min_key;
  2432. struct btrfs_key max_key;
  2433. struct btrfs_root *log = root->log_root;
  2434. struct extent_buffer *src = NULL;
  2435. int err = 0;
  2436. int ret;
  2437. int nritems;
  2438. int ins_start_slot = 0;
  2439. int ins_nr;
  2440. u64 ino = btrfs_ino(inode);
  2441. log = root->log_root;
  2442. path = btrfs_alloc_path();
  2443. if (!path)
  2444. return -ENOMEM;
  2445. dst_path = btrfs_alloc_path();
  2446. if (!dst_path) {
  2447. btrfs_free_path(path);
  2448. return -ENOMEM;
  2449. }
  2450. min_key.objectid = ino;
  2451. min_key.type = BTRFS_INODE_ITEM_KEY;
  2452. min_key.offset = 0;
  2453. max_key.objectid = ino;
  2454. /* today the code can only do partial logging of directories */
  2455. if (!S_ISDIR(inode->i_mode))
  2456. inode_only = LOG_INODE_ALL;
  2457. if (inode_only == LOG_INODE_EXISTS || S_ISDIR(inode->i_mode))
  2458. max_key.type = BTRFS_XATTR_ITEM_KEY;
  2459. else
  2460. max_key.type = (u8)-1;
  2461. max_key.offset = (u64)-1;
  2462. mutex_lock(&BTRFS_I(inode)->log_mutex);
  2463. /*
  2464. * a brute force approach to making sure we get the most uptodate
  2465. * copies of everything.
  2466. */
  2467. if (S_ISDIR(inode->i_mode)) {
  2468. int max_key_type = BTRFS_DIR_LOG_INDEX_KEY;
  2469. if (inode_only == LOG_INODE_EXISTS)
  2470. max_key_type = BTRFS_XATTR_ITEM_KEY;
  2471. ret = drop_objectid_items(trans, log, path, ino, max_key_type);
  2472. } else {
  2473. ret = btrfs_truncate_inode_items(trans, log, inode, 0, 0);
  2474. }
  2475. if (ret) {
  2476. err = ret;
  2477. goto out_unlock;
  2478. }
  2479. path->keep_locks = 1;
  2480. while (1) {
  2481. ins_nr = 0;
  2482. ret = btrfs_search_forward(root, &min_key, &max_key,
  2483. path, 0, trans->transid);
  2484. if (ret != 0)
  2485. break;
  2486. again:
  2487. /* note, ins_nr might be > 0 here, cleanup outside the loop */
  2488. if (min_key.objectid != ino)
  2489. break;
  2490. if (min_key.type > max_key.type)
  2491. break;
  2492. src = path->nodes[0];
  2493. if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) {
  2494. ins_nr++;
  2495. goto next_slot;
  2496. } else if (!ins_nr) {
  2497. ins_start_slot = path->slots[0];
  2498. ins_nr = 1;
  2499. goto next_slot;
  2500. }
  2501. ret = copy_items(trans, log, dst_path, src, ins_start_slot,
  2502. ins_nr, inode_only);
  2503. if (ret) {
  2504. err = ret;
  2505. goto out_unlock;
  2506. }
  2507. ins_nr = 1;
  2508. ins_start_slot = path->slots[0];
  2509. next_slot:
  2510. nritems = btrfs_header_nritems(path->nodes[0]);
  2511. path->slots[0]++;
  2512. if (path->slots[0] < nritems) {
  2513. btrfs_item_key_to_cpu(path->nodes[0], &min_key,
  2514. path->slots[0]);
  2515. goto again;
  2516. }
  2517. if (ins_nr) {
  2518. ret = copy_items(trans, log, dst_path, src,
  2519. ins_start_slot,
  2520. ins_nr, inode_only);
  2521. if (ret) {
  2522. err = ret;
  2523. goto out_unlock;
  2524. }
  2525. ins_nr = 0;
  2526. }
  2527. btrfs_release_path(root, path);
  2528. if (min_key.offset < (u64)-1)
  2529. min_key.offset++;
  2530. else if (min_key.type < (u8)-1)
  2531. min_key.type++;
  2532. else if (min_key.objectid < (u64)-1)
  2533. min_key.objectid++;
  2534. else
  2535. break;
  2536. }
  2537. if (ins_nr) {
  2538. ret = copy_items(trans, log, dst_path, src,
  2539. ins_start_slot,
  2540. ins_nr, inode_only);
  2541. if (ret) {
  2542. err = ret;
  2543. goto out_unlock;
  2544. }
  2545. ins_nr = 0;
  2546. }
  2547. WARN_ON(ins_nr);
  2548. if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
  2549. btrfs_release_path(root, path);
  2550. btrfs_release_path(log, dst_path);
  2551. ret = log_directory_changes(trans, root, inode, path, dst_path);
  2552. if (ret) {
  2553. err = ret;
  2554. goto out_unlock;
  2555. }
  2556. }
  2557. BTRFS_I(inode)->logged_trans = trans->transid;
  2558. out_unlock:
  2559. mutex_unlock(&BTRFS_I(inode)->log_mutex);
  2560. btrfs_free_path(path);
  2561. btrfs_free_path(dst_path);
  2562. return err;
  2563. }
  2564. /*
  2565. * follow the dentry parent pointers up the chain and see if any
  2566. * of the directories in it require a full commit before they can
  2567. * be logged. Returns zero if nothing special needs to be done or 1 if
  2568. * a full commit is required.
  2569. */
  2570. static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
  2571. struct inode *inode,
  2572. struct dentry *parent,
  2573. struct super_block *sb,
  2574. u64 last_committed)
  2575. {
  2576. int ret = 0;
  2577. struct btrfs_root *root;
  2578. struct dentry *old_parent = NULL;
  2579. /*
  2580. * for regular files, if its inode is already on disk, we don't
  2581. * have to worry about the parents at all. This is because
  2582. * we can use the last_unlink_trans field to record renames
  2583. * and other fun in this file.
  2584. */
  2585. if (S_ISREG(inode->i_mode) &&
  2586. BTRFS_I(inode)->generation <= last_committed &&
  2587. BTRFS_I(inode)->last_unlink_trans <= last_committed)
  2588. goto out;
  2589. if (!S_ISDIR(inode->i_mode)) {
  2590. if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
  2591. goto out;
  2592. inode = parent->d_inode;
  2593. }
  2594. while (1) {
  2595. BTRFS_I(inode)->logged_trans = trans->transid;
  2596. smp_mb();
  2597. if (BTRFS_I(inode)->last_unlink_trans > last_committed) {
  2598. root = BTRFS_I(inode)->root;
  2599. /*
  2600. * make sure any commits to the log are forced
  2601. * to be full commits
  2602. */
  2603. root->fs_info->last_trans_log_full_commit =
  2604. trans->transid;
  2605. ret = 1;
  2606. break;
  2607. }
  2608. if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
  2609. break;
  2610. if (IS_ROOT(parent))
  2611. break;
  2612. parent = dget_parent(parent);
  2613. dput(old_parent);
  2614. old_parent = parent;
  2615. inode = parent->d_inode;
  2616. }
  2617. dput(old_parent);
  2618. out:
  2619. return ret;
  2620. }
  2621. static int inode_in_log(struct btrfs_trans_handle *trans,
  2622. struct inode *inode)
  2623. {
  2624. struct btrfs_root *root = BTRFS_I(inode)->root;
  2625. int ret = 0;
  2626. mutex_lock(&root->log_mutex);
  2627. if (BTRFS_I(inode)->logged_trans == trans->transid &&
  2628. BTRFS_I(inode)->last_sub_trans <= root->last_log_commit)
  2629. ret = 1;
  2630. mutex_unlock(&root->log_mutex);
  2631. return ret;
  2632. }
  2633. /*
  2634. * helper function around btrfs_log_inode to make sure newly created
  2635. * parent directories also end up in the log. A minimal inode and backref
  2636. * only logging is done of any parent directories that are older than
  2637. * the last committed transaction
  2638. */
  2639. int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
  2640. struct btrfs_root *root, struct inode *inode,
  2641. struct dentry *parent, int exists_only)
  2642. {
  2643. int inode_only = exists_only ? LOG_INODE_EXISTS : LOG_INODE_ALL;
  2644. struct super_block *sb;
  2645. struct dentry *old_parent = NULL;
  2646. int ret = 0;
  2647. u64 last_committed = root->fs_info->last_trans_committed;
  2648. sb = inode->i_sb;
  2649. if (btrfs_test_opt(root, NOTREELOG)) {
  2650. ret = 1;
  2651. goto end_no_trans;
  2652. }
  2653. if (root->fs_info->last_trans_log_full_commit >
  2654. root->fs_info->last_trans_committed) {
  2655. ret = 1;
  2656. goto end_no_trans;
  2657. }
  2658. if (root != BTRFS_I(inode)->root ||
  2659. btrfs_root_refs(&root->root_item) == 0) {
  2660. ret = 1;
  2661. goto end_no_trans;
  2662. }
  2663. ret = check_parent_dirs_for_sync(trans, inode, parent,
  2664. sb, last_committed);
  2665. if (ret)
  2666. goto end_no_trans;
  2667. if (inode_in_log(trans, inode)) {
  2668. ret = BTRFS_NO_LOG_SYNC;
  2669. goto end_no_trans;
  2670. }
  2671. ret = start_log_trans(trans, root);
  2672. if (ret)
  2673. goto end_trans;
  2674. ret = btrfs_log_inode(trans, root, inode, inode_only);
  2675. if (ret)
  2676. goto end_trans;
  2677. /*
  2678. * for regular files, if its inode is already on disk, we don't
  2679. * have to worry about the parents at all. This is because
  2680. * we can use the last_unlink_trans field to record renames
  2681. * and other fun in this file.
  2682. */
  2683. if (S_ISREG(inode->i_mode) &&
  2684. BTRFS_I(inode)->generation <= last_committed &&
  2685. BTRFS_I(inode)->last_unlink_trans <= last_committed) {
  2686. ret = 0;
  2687. goto end_trans;
  2688. }
  2689. inode_only = LOG_INODE_EXISTS;
  2690. while (1) {
  2691. if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
  2692. break;
  2693. inode = parent->d_inode;
  2694. if (root != BTRFS_I(inode)->root)
  2695. break;
  2696. if (BTRFS_I(inode)->generation >
  2697. root->fs_info->last_trans_committed) {
  2698. ret = btrfs_log_inode(trans, root, inode, inode_only);
  2699. if (ret)
  2700. goto end_trans;
  2701. }
  2702. if (IS_ROOT(parent))
  2703. break;
  2704. parent = dget_parent(parent);
  2705. dput(old_parent);
  2706. old_parent = parent;
  2707. }
  2708. ret = 0;
  2709. end_trans:
  2710. dput(old_parent);
  2711. if (ret < 0) {
  2712. BUG_ON(ret != -ENOSPC);
  2713. root->fs_info->last_trans_log_full_commit = trans->transid;
  2714. ret = 1;
  2715. }
  2716. btrfs_end_log_trans(root);
  2717. end_no_trans:
  2718. return ret;
  2719. }
  2720. /*
  2721. * it is not safe to log dentry if the chunk root has added new
  2722. * chunks. This returns 0 if the dentry was logged, and 1 otherwise.
  2723. * If this returns 1, you must commit the transaction to safely get your
  2724. * data on disk.
  2725. */
  2726. int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
  2727. struct btrfs_root *root, struct dentry *dentry)
  2728. {
  2729. struct dentry *parent = dget_parent(dentry);
  2730. int ret;
  2731. ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent, 0);
  2732. dput(parent);
  2733. return ret;
  2734. }
  2735. /*
  2736. * should be called during mount to recover any replay any log trees
  2737. * from the FS
  2738. */
  2739. int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
  2740. {
  2741. int ret;
  2742. struct btrfs_path *path;
  2743. struct btrfs_trans_handle *trans;
  2744. struct btrfs_key key;
  2745. struct btrfs_key found_key;
  2746. struct btrfs_key tmp_key;
  2747. struct btrfs_root *log;
  2748. struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
  2749. struct walk_control wc = {
  2750. .process_func = process_one_buffer,
  2751. .stage = 0,
  2752. };
  2753. path = btrfs_alloc_path();
  2754. if (!path)
  2755. return -ENOMEM;
  2756. fs_info->log_root_recovering = 1;
  2757. trans = btrfs_start_transaction(fs_info->tree_root, 0);
  2758. BUG_ON(IS_ERR(trans));
  2759. wc.trans = trans;
  2760. wc.pin = 1;
  2761. ret = walk_log_tree(trans, log_root_tree, &wc);
  2762. BUG_ON(ret);
  2763. again:
  2764. key.objectid = BTRFS_TREE_LOG_OBJECTID;
  2765. key.offset = (u64)-1;
  2766. btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
  2767. while (1) {
  2768. ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
  2769. if (ret < 0)
  2770. break;
  2771. if (ret > 0) {
  2772. if (path->slots[0] == 0)
  2773. break;
  2774. path->slots[0]--;
  2775. }
  2776. btrfs_item_key_to_cpu(path->nodes[0], &found_key,
  2777. path->slots[0]);
  2778. btrfs_release_path(log_root_tree, path);
  2779. if (found_key.objectid != BTRFS_TREE_LOG_OBJECTID)
  2780. break;
  2781. log = btrfs_read_fs_root_no_radix(log_root_tree,
  2782. &found_key);
  2783. BUG_ON(IS_ERR(log));
  2784. tmp_key.objectid = found_key.offset;
  2785. tmp_key.type = BTRFS_ROOT_ITEM_KEY;
  2786. tmp_key.offset = (u64)-1;
  2787. wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key);
  2788. BUG_ON(!wc.replay_dest);
  2789. wc.replay_dest->log_root = log;
  2790. btrfs_record_root_in_trans(trans, wc.replay_dest);
  2791. ret = walk_log_tree(trans, log, &wc);
  2792. BUG_ON(ret);
  2793. if (wc.stage == LOG_WALK_REPLAY_ALL) {
  2794. ret = fixup_inode_link_counts(trans, wc.replay_dest,
  2795. path);
  2796. BUG_ON(ret);
  2797. }
  2798. key.offset = found_key.offset - 1;
  2799. wc.replay_dest->log_root = NULL;
  2800. free_extent_buffer(log->node);
  2801. free_extent_buffer(log->commit_root);
  2802. kfree(log);
  2803. if (found_key.offset == 0)
  2804. break;
  2805. }
  2806. btrfs_release_path(log_root_tree, path);
  2807. /* step one is to pin it all, step two is to replay just inodes */
  2808. if (wc.pin) {
  2809. wc.pin = 0;
  2810. wc.process_func = replay_one_buffer;
  2811. wc.stage = LOG_WALK_REPLAY_INODES;
  2812. goto again;
  2813. }
  2814. /* step three is to replay everything */
  2815. if (wc.stage < LOG_WALK_REPLAY_ALL) {
  2816. wc.stage++;
  2817. goto again;
  2818. }
  2819. btrfs_free_path(path);
  2820. free_extent_buffer(log_root_tree->node);
  2821. log_root_tree->log_root = NULL;
  2822. fs_info->log_root_recovering = 0;
  2823. /* step 4: commit the transaction, which also unpins the blocks */
  2824. btrfs_commit_transaction(trans, fs_info->tree_root);
  2825. kfree(log_root_tree);
  2826. return 0;
  2827. }
  2828. /*
  2829. * there are some corner cases where we want to force a full
  2830. * commit instead of allowing a directory to be logged.
  2831. *
  2832. * They revolve around files there were unlinked from the directory, and
  2833. * this function updates the parent directory so that a full commit is
  2834. * properly done if it is fsync'd later after the unlinks are done.
  2835. */
  2836. void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans,
  2837. struct inode *dir, struct inode *inode,
  2838. int for_rename)
  2839. {
  2840. /*
  2841. * when we're logging a file, if it hasn't been renamed
  2842. * or unlinked, and its inode is fully committed on disk,
  2843. * we don't have to worry about walking up the directory chain
  2844. * to log its parents.
  2845. *
  2846. * So, we use the last_unlink_trans field to put this transid
  2847. * into the file. When the file is logged we check it and
  2848. * don't log the parents if the file is fully on disk.
  2849. */
  2850. if (S_ISREG(inode->i_mode))
  2851. BTRFS_I(inode)->last_unlink_trans = trans->transid;
  2852. /*
  2853. * if this directory was already logged any new
  2854. * names for this file/dir will get recorded
  2855. */
  2856. smp_mb();
  2857. if (BTRFS_I(dir)->logged_trans == trans->transid)
  2858. return;
  2859. /*
  2860. * if the inode we're about to unlink was logged,
  2861. * the log will be properly updated for any new names
  2862. */
  2863. if (BTRFS_I(inode)->logged_trans == trans->transid)
  2864. return;
  2865. /*
  2866. * when renaming files across directories, if the directory
  2867. * there we're unlinking from gets fsync'd later on, there's
  2868. * no way to find the destination directory later and fsync it
  2869. * properly. So, we have to be conservative and force commits
  2870. * so the new name gets discovered.
  2871. */
  2872. if (for_rename)
  2873. goto record;
  2874. /* we can safely do the unlink without any special recording */
  2875. return;
  2876. record:
  2877. BTRFS_I(dir)->last_unlink_trans = trans->transid;
  2878. }
  2879. /*
  2880. * Call this after adding a new name for a file and it will properly
  2881. * update the log to reflect the new name.
  2882. *
  2883. * It will return zero if all goes well, and it will return 1 if a
  2884. * full transaction commit is required.
  2885. */
  2886. int btrfs_log_new_name(struct btrfs_trans_handle *trans,
  2887. struct inode *inode, struct inode *old_dir,
  2888. struct dentry *parent)
  2889. {
  2890. struct btrfs_root * root = BTRFS_I(inode)->root;
  2891. /*
  2892. * this will force the logging code to walk the dentry chain
  2893. * up for the file
  2894. */
  2895. if (S_ISREG(inode->i_mode))
  2896. BTRFS_I(inode)->last_unlink_trans = trans->transid;
  2897. /*
  2898. * if this inode hasn't been logged and directory we're renaming it
  2899. * from hasn't been logged, we don't need to log it
  2900. */
  2901. if (BTRFS_I(inode)->logged_trans <=
  2902. root->fs_info->last_trans_committed &&
  2903. (!old_dir || BTRFS_I(old_dir)->logged_trans <=
  2904. root->fs_info->last_trans_committed))
  2905. return 0;
  2906. return btrfs_log_inode_parent(trans, root, inode, parent, 1);
  2907. }