disk-io.c 97 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601
  1. /*
  2. * Copyright (C) 2007 Oracle. All rights reserved.
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU General Public
  6. * License v2 as published by the Free Software Foundation.
  7. *
  8. * This program is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11. * General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public
  14. * License along with this program; if not, write to the
  15. * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16. * Boston, MA 021110-1307, USA.
  17. */
  18. #include <linux/fs.h>
  19. #include <linux/blkdev.h>
  20. #include <linux/scatterlist.h>
  21. #include <linux/swap.h>
  22. #include <linux/radix-tree.h>
  23. #include <linux/writeback.h>
  24. #include <linux/buffer_head.h>
  25. #include <linux/workqueue.h>
  26. #include <linux/kthread.h>
  27. #include <linux/freezer.h>
  28. #include <linux/crc32c.h>
  29. #include <linux/slab.h>
  30. #include <linux/migrate.h>
  31. #include <linux/ratelimit.h>
  32. #include <asm/unaligned.h>
  33. #include "compat.h"
  34. #include "ctree.h"
  35. #include "disk-io.h"
  36. #include "transaction.h"
  37. #include "btrfs_inode.h"
  38. #include "volumes.h"
  39. #include "print-tree.h"
  40. #include "async-thread.h"
  41. #include "locking.h"
  42. #include "tree-log.h"
  43. #include "free-space-cache.h"
  44. #include "inode-map.h"
  45. #include "check-integrity.h"
  46. static struct extent_io_ops btree_extent_io_ops;
  47. static void end_workqueue_fn(struct btrfs_work *work);
  48. static void free_fs_root(struct btrfs_root *root);
  49. static void btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
  50. int read_only);
  51. static int btrfs_destroy_ordered_operations(struct btrfs_root *root);
  52. static int btrfs_destroy_ordered_extents(struct btrfs_root *root);
  53. static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
  54. struct btrfs_root *root);
  55. static int btrfs_destroy_pending_snapshots(struct btrfs_transaction *t);
  56. static int btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
  57. static int btrfs_destroy_marked_extents(struct btrfs_root *root,
  58. struct extent_io_tree *dirty_pages,
  59. int mark);
  60. static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
  61. struct extent_io_tree *pinned_extents);
  62. static int btrfs_cleanup_transaction(struct btrfs_root *root);
  63. /*
  64. * end_io_wq structs are used to do processing in task context when an IO is
  65. * complete. This is used during reads to verify checksums, and it is used
  66. * by writes to insert metadata for new file extents after IO is complete.
  67. */
  68. struct end_io_wq {
  69. struct bio *bio;
  70. bio_end_io_t *end_io;
  71. void *private;
  72. struct btrfs_fs_info *info;
  73. int error;
  74. int metadata;
  75. struct list_head list;
  76. struct btrfs_work work;
  77. };
  78. /*
  79. * async submit bios are used to offload expensive checksumming
  80. * onto the worker threads. They checksum file and metadata bios
  81. * just before they are sent down the IO stack.
  82. */
  83. struct async_submit_bio {
  84. struct inode *inode;
  85. struct bio *bio;
  86. struct list_head list;
  87. extent_submit_bio_hook_t *submit_bio_start;
  88. extent_submit_bio_hook_t *submit_bio_done;
  89. int rw;
  90. int mirror_num;
  91. unsigned long bio_flags;
  92. /*
  93. * bio_offset is optional, can be used if the pages in the bio
  94. * can't tell us where in the file the bio should go
  95. */
  96. u64 bio_offset;
  97. struct btrfs_work work;
  98. };
  99. /*
  100. * Lockdep class keys for extent_buffer->lock's in this root. For a given
  101. * eb, the lockdep key is determined by the btrfs_root it belongs to and
  102. * the level the eb occupies in the tree.
  103. *
  104. * Different roots are used for different purposes and may nest inside each
  105. * other and they require separate keysets. As lockdep keys should be
  106. * static, assign keysets according to the purpose of the root as indicated
  107. * by btrfs_root->objectid. This ensures that all special purpose roots
  108. * have separate keysets.
  109. *
  110. * Lock-nesting across peer nodes is always done with the immediate parent
  111. * node locked thus preventing deadlock. As lockdep doesn't know this, use
  112. * subclass to avoid triggering lockdep warning in such cases.
  113. *
  114. * The key is set by the readpage_end_io_hook after the buffer has passed
  115. * csum validation but before the pages are unlocked. It is also set by
  116. * btrfs_init_new_buffer on freshly allocated blocks.
  117. *
  118. * We also add a check to make sure the highest level of the tree is the
  119. * same as our lockdep setup here. If BTRFS_MAX_LEVEL changes, this code
  120. * needs update as well.
  121. */
  122. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  123. # if BTRFS_MAX_LEVEL != 8
  124. # error
  125. # endif
  126. static struct btrfs_lockdep_keyset {
  127. u64 id; /* root objectid */
  128. const char *name_stem; /* lock name stem */
  129. char names[BTRFS_MAX_LEVEL + 1][20];
  130. struct lock_class_key keys[BTRFS_MAX_LEVEL + 1];
  131. } btrfs_lockdep_keysets[] = {
  132. { .id = BTRFS_ROOT_TREE_OBJECTID, .name_stem = "root" },
  133. { .id = BTRFS_EXTENT_TREE_OBJECTID, .name_stem = "extent" },
  134. { .id = BTRFS_CHUNK_TREE_OBJECTID, .name_stem = "chunk" },
  135. { .id = BTRFS_DEV_TREE_OBJECTID, .name_stem = "dev" },
  136. { .id = BTRFS_FS_TREE_OBJECTID, .name_stem = "fs" },
  137. { .id = BTRFS_CSUM_TREE_OBJECTID, .name_stem = "csum" },
  138. { .id = BTRFS_ORPHAN_OBJECTID, .name_stem = "orphan" },
  139. { .id = BTRFS_TREE_LOG_OBJECTID, .name_stem = "log" },
  140. { .id = BTRFS_TREE_RELOC_OBJECTID, .name_stem = "treloc" },
  141. { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, .name_stem = "dreloc" },
  142. { .id = 0, .name_stem = "tree" },
  143. };
  144. void __init btrfs_init_lockdep(void)
  145. {
  146. int i, j;
  147. /* initialize lockdep class names */
  148. for (i = 0; i < ARRAY_SIZE(btrfs_lockdep_keysets); i++) {
  149. struct btrfs_lockdep_keyset *ks = &btrfs_lockdep_keysets[i];
  150. for (j = 0; j < ARRAY_SIZE(ks->names); j++)
  151. snprintf(ks->names[j], sizeof(ks->names[j]),
  152. "btrfs-%s-%02d", ks->name_stem, j);
  153. }
  154. }
  155. void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb,
  156. int level)
  157. {
  158. struct btrfs_lockdep_keyset *ks;
  159. BUG_ON(level >= ARRAY_SIZE(ks->keys));
  160. /* find the matching keyset, id 0 is the default entry */
  161. for (ks = btrfs_lockdep_keysets; ks->id; ks++)
  162. if (ks->id == objectid)
  163. break;
  164. lockdep_set_class_and_name(&eb->lock,
  165. &ks->keys[level], ks->names[level]);
  166. }
  167. #endif
  168. /*
  169. * extents on the btree inode are pretty simple, there's one extent
  170. * that covers the entire device
  171. */
  172. static struct extent_map *btree_get_extent(struct inode *inode,
  173. struct page *page, size_t pg_offset, u64 start, u64 len,
  174. int create)
  175. {
  176. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  177. struct extent_map *em;
  178. int ret;
  179. read_lock(&em_tree->lock);
  180. em = lookup_extent_mapping(em_tree, start, len);
  181. if (em) {
  182. em->bdev =
  183. BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
  184. read_unlock(&em_tree->lock);
  185. goto out;
  186. }
  187. read_unlock(&em_tree->lock);
  188. em = alloc_extent_map();
  189. if (!em) {
  190. em = ERR_PTR(-ENOMEM);
  191. goto out;
  192. }
  193. em->start = 0;
  194. em->len = (u64)-1;
  195. em->block_len = (u64)-1;
  196. em->block_start = 0;
  197. em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
  198. write_lock(&em_tree->lock);
  199. ret = add_extent_mapping(em_tree, em);
  200. if (ret == -EEXIST) {
  201. u64 failed_start = em->start;
  202. u64 failed_len = em->len;
  203. free_extent_map(em);
  204. em = lookup_extent_mapping(em_tree, start, len);
  205. if (em) {
  206. ret = 0;
  207. } else {
  208. em = lookup_extent_mapping(em_tree, failed_start,
  209. failed_len);
  210. ret = -EIO;
  211. }
  212. } else if (ret) {
  213. free_extent_map(em);
  214. em = NULL;
  215. }
  216. write_unlock(&em_tree->lock);
  217. if (ret)
  218. em = ERR_PTR(ret);
  219. out:
  220. return em;
  221. }
  222. u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
  223. {
  224. return crc32c(seed, data, len);
  225. }
  226. void btrfs_csum_final(u32 crc, char *result)
  227. {
  228. put_unaligned_le32(~crc, result);
  229. }
  230. /*
  231. * compute the csum for a btree block, and either verify it or write it
  232. * into the csum field of the block.
  233. */
  234. static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
  235. int verify)
  236. {
  237. u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
  238. char *result = NULL;
  239. unsigned long len;
  240. unsigned long cur_len;
  241. unsigned long offset = BTRFS_CSUM_SIZE;
  242. char *kaddr;
  243. unsigned long map_start;
  244. unsigned long map_len;
  245. int err;
  246. u32 crc = ~(u32)0;
  247. unsigned long inline_result;
  248. len = buf->len - offset;
  249. while (len > 0) {
  250. err = map_private_extent_buffer(buf, offset, 32,
  251. &kaddr, &map_start, &map_len);
  252. if (err)
  253. return 1;
  254. cur_len = min(len, map_len - (offset - map_start));
  255. crc = btrfs_csum_data(root, kaddr + offset - map_start,
  256. crc, cur_len);
  257. len -= cur_len;
  258. offset += cur_len;
  259. }
  260. if (csum_size > sizeof(inline_result)) {
  261. result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
  262. if (!result)
  263. return 1;
  264. } else {
  265. result = (char *)&inline_result;
  266. }
  267. btrfs_csum_final(crc, result);
  268. if (verify) {
  269. if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
  270. u32 val;
  271. u32 found = 0;
  272. memcpy(&found, result, csum_size);
  273. read_extent_buffer(buf, &val, 0, csum_size);
  274. printk_ratelimited(KERN_INFO "btrfs: %s checksum verify "
  275. "failed on %llu wanted %X found %X "
  276. "level %d\n",
  277. root->fs_info->sb->s_id,
  278. (unsigned long long)buf->start, val, found,
  279. btrfs_header_level(buf));
  280. if (result != (char *)&inline_result)
  281. kfree(result);
  282. return 1;
  283. }
  284. } else {
  285. write_extent_buffer(buf, result, 0, csum_size);
  286. }
  287. if (result != (char *)&inline_result)
  288. kfree(result);
  289. return 0;
  290. }
  291. /*
  292. * we can't consider a given block up to date unless the transid of the
  293. * block matches the transid in the parent node's pointer. This is how we
  294. * detect blocks that either didn't get written at all or got written
  295. * in the wrong place.
  296. */
  297. static int verify_parent_transid(struct extent_io_tree *io_tree,
  298. struct extent_buffer *eb, u64 parent_transid)
  299. {
  300. struct extent_state *cached_state = NULL;
  301. int ret;
  302. if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
  303. return 0;
  304. lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
  305. 0, &cached_state, GFP_NOFS);
  306. if (extent_buffer_uptodate(io_tree, eb, cached_state) &&
  307. btrfs_header_generation(eb) == parent_transid) {
  308. ret = 0;
  309. goto out;
  310. }
  311. printk_ratelimited("parent transid verify failed on %llu wanted %llu "
  312. "found %llu\n",
  313. (unsigned long long)eb->start,
  314. (unsigned long long)parent_transid,
  315. (unsigned long long)btrfs_header_generation(eb));
  316. ret = 1;
  317. clear_extent_buffer_uptodate(io_tree, eb, &cached_state);
  318. out:
  319. unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
  320. &cached_state, GFP_NOFS);
  321. return ret;
  322. }
  323. /*
  324. * helper to read a given tree block, doing retries as required when
  325. * the checksums don't match and we have alternate mirrors to try.
  326. */
  327. static int btree_read_extent_buffer_pages(struct btrfs_root *root,
  328. struct extent_buffer *eb,
  329. u64 start, u64 parent_transid)
  330. {
  331. struct extent_io_tree *io_tree;
  332. int ret;
  333. int num_copies = 0;
  334. int mirror_num = 0;
  335. clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
  336. io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
  337. while (1) {
  338. ret = read_extent_buffer_pages(io_tree, eb, start,
  339. WAIT_COMPLETE,
  340. btree_get_extent, mirror_num);
  341. if (!ret &&
  342. !verify_parent_transid(io_tree, eb, parent_transid))
  343. return ret;
  344. /*
  345. * This buffer's crc is fine, but its contents are corrupted, so
  346. * there is no reason to read the other copies, they won't be
  347. * any less wrong.
  348. */
  349. if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
  350. return ret;
  351. num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
  352. eb->start, eb->len);
  353. if (num_copies == 1)
  354. return ret;
  355. mirror_num++;
  356. if (mirror_num > num_copies)
  357. return ret;
  358. }
  359. return -EIO;
  360. }
  361. /*
  362. * checksum a dirty tree block before IO. This has extra checks to make sure
  363. * we only fill in the checksum field in the first page of a multi-page block
  364. */
  365. static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
  366. {
  367. struct extent_io_tree *tree;
  368. u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
  369. u64 found_start;
  370. unsigned long len;
  371. struct extent_buffer *eb;
  372. int ret;
  373. tree = &BTRFS_I(page->mapping->host)->io_tree;
  374. if (page->private == EXTENT_PAGE_PRIVATE) {
  375. WARN_ON(1);
  376. goto out;
  377. }
  378. if (!page->private) {
  379. WARN_ON(1);
  380. goto out;
  381. }
  382. len = page->private >> 2;
  383. WARN_ON(len == 0);
  384. eb = alloc_extent_buffer(tree, start, len, page);
  385. if (eb == NULL) {
  386. WARN_ON(1);
  387. goto out;
  388. }
  389. ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE,
  390. btrfs_header_generation(eb));
  391. BUG_ON(ret);
  392. WARN_ON(!btrfs_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN));
  393. found_start = btrfs_header_bytenr(eb);
  394. if (found_start != start) {
  395. WARN_ON(1);
  396. goto err;
  397. }
  398. if (eb->first_page != page) {
  399. WARN_ON(1);
  400. goto err;
  401. }
  402. if (!PageUptodate(page)) {
  403. WARN_ON(1);
  404. goto err;
  405. }
  406. csum_tree_block(root, eb, 0);
  407. err:
  408. free_extent_buffer(eb);
  409. out:
  410. return 0;
  411. }
  412. static int check_tree_block_fsid(struct btrfs_root *root,
  413. struct extent_buffer *eb)
  414. {
  415. struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
  416. u8 fsid[BTRFS_UUID_SIZE];
  417. int ret = 1;
  418. read_extent_buffer(eb, fsid, (unsigned long)btrfs_header_fsid(eb),
  419. BTRFS_FSID_SIZE);
  420. while (fs_devices) {
  421. if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
  422. ret = 0;
  423. break;
  424. }
  425. fs_devices = fs_devices->seed;
  426. }
  427. return ret;
  428. }
  429. #define CORRUPT(reason, eb, root, slot) \
  430. printk(KERN_CRIT "btrfs: corrupt leaf, %s: block=%llu," \
  431. "root=%llu, slot=%d\n", reason, \
  432. (unsigned long long)btrfs_header_bytenr(eb), \
  433. (unsigned long long)root->objectid, slot)
  434. static noinline int check_leaf(struct btrfs_root *root,
  435. struct extent_buffer *leaf)
  436. {
  437. struct btrfs_key key;
  438. struct btrfs_key leaf_key;
  439. u32 nritems = btrfs_header_nritems(leaf);
  440. int slot;
  441. if (nritems == 0)
  442. return 0;
  443. /* Check the 0 item */
  444. if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
  445. BTRFS_LEAF_DATA_SIZE(root)) {
  446. CORRUPT("invalid item offset size pair", leaf, root, 0);
  447. return -EIO;
  448. }
  449. /*
  450. * Check to make sure each items keys are in the correct order and their
  451. * offsets make sense. We only have to loop through nritems-1 because
  452. * we check the current slot against the next slot, which verifies the
  453. * next slot's offset+size makes sense and that the current's slot
  454. * offset is correct.
  455. */
  456. for (slot = 0; slot < nritems - 1; slot++) {
  457. btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
  458. btrfs_item_key_to_cpu(leaf, &key, slot + 1);
  459. /* Make sure the keys are in the right order */
  460. if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
  461. CORRUPT("bad key order", leaf, root, slot);
  462. return -EIO;
  463. }
  464. /*
  465. * Make sure the offset and ends are right, remember that the
  466. * item data starts at the end of the leaf and grows towards the
  467. * front.
  468. */
  469. if (btrfs_item_offset_nr(leaf, slot) !=
  470. btrfs_item_end_nr(leaf, slot + 1)) {
  471. CORRUPT("slot offset bad", leaf, root, slot);
  472. return -EIO;
  473. }
  474. /*
  475. * Check to make sure that we don't point outside of the leaf,
  476. * just incase all the items are consistent to eachother, but
  477. * all point outside of the leaf.
  478. */
  479. if (btrfs_item_end_nr(leaf, slot) >
  480. BTRFS_LEAF_DATA_SIZE(root)) {
  481. CORRUPT("slot end outside of leaf", leaf, root, slot);
  482. return -EIO;
  483. }
  484. }
  485. return 0;
  486. }
  487. static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
  488. struct extent_state *state)
  489. {
  490. struct extent_io_tree *tree;
  491. u64 found_start;
  492. int found_level;
  493. unsigned long len;
  494. struct extent_buffer *eb;
  495. struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
  496. int ret = 0;
  497. tree = &BTRFS_I(page->mapping->host)->io_tree;
  498. if (page->private == EXTENT_PAGE_PRIVATE)
  499. goto out;
  500. if (!page->private)
  501. goto out;
  502. len = page->private >> 2;
  503. WARN_ON(len == 0);
  504. eb = alloc_extent_buffer(tree, start, len, page);
  505. if (eb == NULL) {
  506. ret = -EIO;
  507. goto out;
  508. }
  509. found_start = btrfs_header_bytenr(eb);
  510. if (found_start != start) {
  511. printk_ratelimited(KERN_INFO "btrfs bad tree block start "
  512. "%llu %llu\n",
  513. (unsigned long long)found_start,
  514. (unsigned long long)eb->start);
  515. ret = -EIO;
  516. goto err;
  517. }
  518. if (eb->first_page != page) {
  519. printk(KERN_INFO "btrfs bad first page %lu %lu\n",
  520. eb->first_page->index, page->index);
  521. WARN_ON(1);
  522. ret = -EIO;
  523. goto err;
  524. }
  525. if (check_tree_block_fsid(root, eb)) {
  526. printk_ratelimited(KERN_INFO "btrfs bad fsid on block %llu\n",
  527. (unsigned long long)eb->start);
  528. ret = -EIO;
  529. goto err;
  530. }
  531. found_level = btrfs_header_level(eb);
  532. btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
  533. eb, found_level);
  534. ret = csum_tree_block(root, eb, 1);
  535. if (ret) {
  536. ret = -EIO;
  537. goto err;
  538. }
  539. /*
  540. * If this is a leaf block and it is corrupt, set the corrupt bit so
  541. * that we don't try and read the other copies of this block, just
  542. * return -EIO.
  543. */
  544. if (found_level == 0 && check_leaf(root, eb)) {
  545. set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
  546. ret = -EIO;
  547. }
  548. end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
  549. end = eb->start + end - 1;
  550. err:
  551. if (test_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags)) {
  552. clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags);
  553. btree_readahead_hook(root, eb, eb->start, ret);
  554. }
  555. free_extent_buffer(eb);
  556. out:
  557. return ret;
  558. }
  559. static int btree_io_failed_hook(struct bio *failed_bio,
  560. struct page *page, u64 start, u64 end,
  561. int mirror_num, struct extent_state *state)
  562. {
  563. struct extent_io_tree *tree;
  564. unsigned long len;
  565. struct extent_buffer *eb;
  566. struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
  567. tree = &BTRFS_I(page->mapping->host)->io_tree;
  568. if (page->private == EXTENT_PAGE_PRIVATE)
  569. goto out;
  570. if (!page->private)
  571. goto out;
  572. len = page->private >> 2;
  573. WARN_ON(len == 0);
  574. eb = alloc_extent_buffer(tree, start, len, page);
  575. if (eb == NULL)
  576. goto out;
  577. if (test_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags)) {
  578. clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags);
  579. btree_readahead_hook(root, eb, eb->start, -EIO);
  580. }
  581. free_extent_buffer(eb);
  582. out:
  583. return -EIO; /* we fixed nothing */
  584. }
  585. static void end_workqueue_bio(struct bio *bio, int err)
  586. {
  587. struct end_io_wq *end_io_wq = bio->bi_private;
  588. struct btrfs_fs_info *fs_info;
  589. fs_info = end_io_wq->info;
  590. end_io_wq->error = err;
  591. end_io_wq->work.func = end_workqueue_fn;
  592. end_io_wq->work.flags = 0;
  593. if (bio->bi_rw & REQ_WRITE) {
  594. if (end_io_wq->metadata == 1)
  595. btrfs_queue_worker(&fs_info->endio_meta_write_workers,
  596. &end_io_wq->work);
  597. else if (end_io_wq->metadata == 2)
  598. btrfs_queue_worker(&fs_info->endio_freespace_worker,
  599. &end_io_wq->work);
  600. else
  601. btrfs_queue_worker(&fs_info->endio_write_workers,
  602. &end_io_wq->work);
  603. } else {
  604. if (end_io_wq->metadata)
  605. btrfs_queue_worker(&fs_info->endio_meta_workers,
  606. &end_io_wq->work);
  607. else
  608. btrfs_queue_worker(&fs_info->endio_workers,
  609. &end_io_wq->work);
  610. }
  611. }
  612. /*
  613. * For the metadata arg you want
  614. *
  615. * 0 - if data
  616. * 1 - if normal metadta
  617. * 2 - if writing to the free space cache area
  618. */
  619. int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
  620. int metadata)
  621. {
  622. struct end_io_wq *end_io_wq;
  623. end_io_wq = kmalloc(sizeof(*end_io_wq), GFP_NOFS);
  624. if (!end_io_wq)
  625. return -ENOMEM;
  626. end_io_wq->private = bio->bi_private;
  627. end_io_wq->end_io = bio->bi_end_io;
  628. end_io_wq->info = info;
  629. end_io_wq->error = 0;
  630. end_io_wq->bio = bio;
  631. end_io_wq->metadata = metadata;
  632. bio->bi_private = end_io_wq;
  633. bio->bi_end_io = end_workqueue_bio;
  634. return 0;
  635. }
  636. unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
  637. {
  638. unsigned long limit = min_t(unsigned long,
  639. info->workers.max_workers,
  640. info->fs_devices->open_devices);
  641. return 256 * limit;
  642. }
  643. static void run_one_async_start(struct btrfs_work *work)
  644. {
  645. struct async_submit_bio *async;
  646. async = container_of(work, struct async_submit_bio, work);
  647. async->submit_bio_start(async->inode, async->rw, async->bio,
  648. async->mirror_num, async->bio_flags,
  649. async->bio_offset);
  650. }
  651. static void run_one_async_done(struct btrfs_work *work)
  652. {
  653. struct btrfs_fs_info *fs_info;
  654. struct async_submit_bio *async;
  655. int limit;
  656. async = container_of(work, struct async_submit_bio, work);
  657. fs_info = BTRFS_I(async->inode)->root->fs_info;
  658. limit = btrfs_async_submit_limit(fs_info);
  659. limit = limit * 2 / 3;
  660. atomic_dec(&fs_info->nr_async_submits);
  661. if (atomic_read(&fs_info->nr_async_submits) < limit &&
  662. waitqueue_active(&fs_info->async_submit_wait))
  663. wake_up(&fs_info->async_submit_wait);
  664. async->submit_bio_done(async->inode, async->rw, async->bio,
  665. async->mirror_num, async->bio_flags,
  666. async->bio_offset);
  667. }
  668. static void run_one_async_free(struct btrfs_work *work)
  669. {
  670. struct async_submit_bio *async;
  671. async = container_of(work, struct async_submit_bio, work);
  672. kfree(async);
  673. }
  674. int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
  675. int rw, struct bio *bio, int mirror_num,
  676. unsigned long bio_flags,
  677. u64 bio_offset,
  678. extent_submit_bio_hook_t *submit_bio_start,
  679. extent_submit_bio_hook_t *submit_bio_done)
  680. {
  681. struct async_submit_bio *async;
  682. async = kmalloc(sizeof(*async), GFP_NOFS);
  683. if (!async)
  684. return -ENOMEM;
  685. async->inode = inode;
  686. async->rw = rw;
  687. async->bio = bio;
  688. async->mirror_num = mirror_num;
  689. async->submit_bio_start = submit_bio_start;
  690. async->submit_bio_done = submit_bio_done;
  691. async->work.func = run_one_async_start;
  692. async->work.ordered_func = run_one_async_done;
  693. async->work.ordered_free = run_one_async_free;
  694. async->work.flags = 0;
  695. async->bio_flags = bio_flags;
  696. async->bio_offset = bio_offset;
  697. atomic_inc(&fs_info->nr_async_submits);
  698. if (rw & REQ_SYNC)
  699. btrfs_set_work_high_prio(&async->work);
  700. btrfs_queue_worker(&fs_info->workers, &async->work);
  701. while (atomic_read(&fs_info->async_submit_draining) &&
  702. atomic_read(&fs_info->nr_async_submits)) {
  703. wait_event(fs_info->async_submit_wait,
  704. (atomic_read(&fs_info->nr_async_submits) == 0));
  705. }
  706. return 0;
  707. }
  708. static int btree_csum_one_bio(struct bio *bio)
  709. {
  710. struct bio_vec *bvec = bio->bi_io_vec;
  711. int bio_index = 0;
  712. struct btrfs_root *root;
  713. WARN_ON(bio->bi_vcnt <= 0);
  714. while (bio_index < bio->bi_vcnt) {
  715. root = BTRFS_I(bvec->bv_page->mapping->host)->root;
  716. csum_dirty_buffer(root, bvec->bv_page);
  717. bio_index++;
  718. bvec++;
  719. }
  720. return 0;
  721. }
  722. static int __btree_submit_bio_start(struct inode *inode, int rw,
  723. struct bio *bio, int mirror_num,
  724. unsigned long bio_flags,
  725. u64 bio_offset)
  726. {
  727. /*
  728. * when we're called for a write, we're already in the async
  729. * submission context. Just jump into btrfs_map_bio
  730. */
  731. btree_csum_one_bio(bio);
  732. return 0;
  733. }
  734. static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
  735. int mirror_num, unsigned long bio_flags,
  736. u64 bio_offset)
  737. {
  738. /*
  739. * when we're called for a write, we're already in the async
  740. * submission context. Just jump into btrfs_map_bio
  741. */
  742. return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
  743. }
  744. static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
  745. int mirror_num, unsigned long bio_flags,
  746. u64 bio_offset)
  747. {
  748. int ret;
  749. ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
  750. bio, 1);
  751. BUG_ON(ret);
  752. if (!(rw & REQ_WRITE)) {
  753. /*
  754. * called for a read, do the setup so that checksum validation
  755. * can happen in the async kernel threads
  756. */
  757. return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
  758. mirror_num, 0);
  759. }
  760. /*
  761. * kthread helpers are used to submit writes so that checksumming
  762. * can happen in parallel across all CPUs
  763. */
  764. return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
  765. inode, rw, bio, mirror_num, 0,
  766. bio_offset,
  767. __btree_submit_bio_start,
  768. __btree_submit_bio_done);
  769. }
  770. #ifdef CONFIG_MIGRATION
  771. static int btree_migratepage(struct address_space *mapping,
  772. struct page *newpage, struct page *page,
  773. enum migrate_mode mode)
  774. {
  775. /*
  776. * we can't safely write a btree page from here,
  777. * we haven't done the locking hook
  778. */
  779. if (PageDirty(page))
  780. return -EAGAIN;
  781. /*
  782. * Buffers may be managed in a filesystem specific way.
  783. * We must have no buffers or drop them.
  784. */
  785. if (page_has_private(page) &&
  786. !try_to_release_page(page, GFP_KERNEL))
  787. return -EAGAIN;
  788. return migrate_page(mapping, newpage, page, mode);
  789. }
  790. #endif
  791. static int btree_writepage(struct page *page, struct writeback_control *wbc)
  792. {
  793. struct extent_io_tree *tree;
  794. struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
  795. struct extent_buffer *eb;
  796. int was_dirty;
  797. tree = &BTRFS_I(page->mapping->host)->io_tree;
  798. if (!(current->flags & PF_MEMALLOC)) {
  799. return extent_write_full_page(tree, page,
  800. btree_get_extent, wbc);
  801. }
  802. redirty_page_for_writepage(wbc, page);
  803. eb = btrfs_find_tree_block(root, page_offset(page), PAGE_CACHE_SIZE);
  804. WARN_ON(!eb);
  805. was_dirty = test_and_set_bit(EXTENT_BUFFER_DIRTY, &eb->bflags);
  806. if (!was_dirty) {
  807. spin_lock(&root->fs_info->delalloc_lock);
  808. root->fs_info->dirty_metadata_bytes += PAGE_CACHE_SIZE;
  809. spin_unlock(&root->fs_info->delalloc_lock);
  810. }
  811. free_extent_buffer(eb);
  812. unlock_page(page);
  813. return 0;
  814. }
  815. static int btree_writepages(struct address_space *mapping,
  816. struct writeback_control *wbc)
  817. {
  818. struct extent_io_tree *tree;
  819. tree = &BTRFS_I(mapping->host)->io_tree;
  820. if (wbc->sync_mode == WB_SYNC_NONE) {
  821. struct btrfs_root *root = BTRFS_I(mapping->host)->root;
  822. u64 num_dirty;
  823. unsigned long thresh = 32 * 1024 * 1024;
  824. if (wbc->for_kupdate)
  825. return 0;
  826. /* this is a bit racy, but that's ok */
  827. num_dirty = root->fs_info->dirty_metadata_bytes;
  828. if (num_dirty < thresh)
  829. return 0;
  830. }
  831. return extent_writepages(tree, mapping, btree_get_extent, wbc);
  832. }
  833. static int btree_readpage(struct file *file, struct page *page)
  834. {
  835. struct extent_io_tree *tree;
  836. tree = &BTRFS_I(page->mapping->host)->io_tree;
  837. return extent_read_full_page(tree, page, btree_get_extent, 0);
  838. }
  839. static int btree_releasepage(struct page *page, gfp_t gfp_flags)
  840. {
  841. struct extent_io_tree *tree;
  842. struct extent_map_tree *map;
  843. int ret;
  844. if (PageWriteback(page) || PageDirty(page))
  845. return 0;
  846. tree = &BTRFS_I(page->mapping->host)->io_tree;
  847. map = &BTRFS_I(page->mapping->host)->extent_tree;
  848. ret = try_release_extent_state(map, tree, page, gfp_flags);
  849. if (!ret)
  850. return 0;
  851. ret = try_release_extent_buffer(tree, page);
  852. if (ret == 1) {
  853. ClearPagePrivate(page);
  854. set_page_private(page, 0);
  855. page_cache_release(page);
  856. }
  857. return ret;
  858. }
  859. static void btree_invalidatepage(struct page *page, unsigned long offset)
  860. {
  861. struct extent_io_tree *tree;
  862. tree = &BTRFS_I(page->mapping->host)->io_tree;
  863. extent_invalidatepage(tree, page, offset);
  864. btree_releasepage(page, GFP_NOFS);
  865. if (PagePrivate(page)) {
  866. printk(KERN_WARNING "btrfs warning page private not zero "
  867. "on page %llu\n", (unsigned long long)page_offset(page));
  868. ClearPagePrivate(page);
  869. set_page_private(page, 0);
  870. page_cache_release(page);
  871. }
  872. }
  873. static const struct address_space_operations btree_aops = {
  874. .readpage = btree_readpage,
  875. .writepage = btree_writepage,
  876. .writepages = btree_writepages,
  877. .releasepage = btree_releasepage,
  878. .invalidatepage = btree_invalidatepage,
  879. #ifdef CONFIG_MIGRATION
  880. .migratepage = btree_migratepage,
  881. #endif
  882. };
  883. int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
  884. u64 parent_transid)
  885. {
  886. struct extent_buffer *buf = NULL;
  887. struct inode *btree_inode = root->fs_info->btree_inode;
  888. int ret = 0;
  889. buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
  890. if (!buf)
  891. return 0;
  892. read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
  893. buf, 0, WAIT_NONE, btree_get_extent, 0);
  894. free_extent_buffer(buf);
  895. return ret;
  896. }
  897. int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
  898. int mirror_num, struct extent_buffer **eb)
  899. {
  900. struct extent_buffer *buf = NULL;
  901. struct inode *btree_inode = root->fs_info->btree_inode;
  902. struct extent_io_tree *io_tree = &BTRFS_I(btree_inode)->io_tree;
  903. int ret;
  904. buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
  905. if (!buf)
  906. return 0;
  907. set_bit(EXTENT_BUFFER_READAHEAD, &buf->bflags);
  908. ret = read_extent_buffer_pages(io_tree, buf, 0, WAIT_PAGE_LOCK,
  909. btree_get_extent, mirror_num);
  910. if (ret) {
  911. free_extent_buffer(buf);
  912. return ret;
  913. }
  914. if (test_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags)) {
  915. free_extent_buffer(buf);
  916. return -EIO;
  917. } else if (extent_buffer_uptodate(io_tree, buf, NULL)) {
  918. *eb = buf;
  919. } else {
  920. free_extent_buffer(buf);
  921. }
  922. return 0;
  923. }
  924. struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
  925. u64 bytenr, u32 blocksize)
  926. {
  927. struct inode *btree_inode = root->fs_info->btree_inode;
  928. struct extent_buffer *eb;
  929. eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
  930. bytenr, blocksize);
  931. return eb;
  932. }
  933. struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
  934. u64 bytenr, u32 blocksize)
  935. {
  936. struct inode *btree_inode = root->fs_info->btree_inode;
  937. struct extent_buffer *eb;
  938. eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
  939. bytenr, blocksize, NULL);
  940. return eb;
  941. }
  942. int btrfs_write_tree_block(struct extent_buffer *buf)
  943. {
  944. return filemap_fdatawrite_range(buf->first_page->mapping, buf->start,
  945. buf->start + buf->len - 1);
  946. }
  947. int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
  948. {
  949. return filemap_fdatawait_range(buf->first_page->mapping,
  950. buf->start, buf->start + buf->len - 1);
  951. }
  952. struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
  953. u32 blocksize, u64 parent_transid)
  954. {
  955. struct extent_buffer *buf = NULL;
  956. int ret;
  957. buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
  958. if (!buf)
  959. return NULL;
  960. ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
  961. if (ret == 0)
  962. set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
  963. return buf;
  964. }
  965. int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  966. struct extent_buffer *buf)
  967. {
  968. struct inode *btree_inode = root->fs_info->btree_inode;
  969. if (btrfs_header_generation(buf) ==
  970. root->fs_info->running_transaction->transid) {
  971. btrfs_assert_tree_locked(buf);
  972. if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
  973. spin_lock(&root->fs_info->delalloc_lock);
  974. if (root->fs_info->dirty_metadata_bytes >= buf->len)
  975. root->fs_info->dirty_metadata_bytes -= buf->len;
  976. else
  977. WARN_ON(1);
  978. spin_unlock(&root->fs_info->delalloc_lock);
  979. }
  980. /* ugh, clear_extent_buffer_dirty needs to lock the page */
  981. btrfs_set_lock_blocking(buf);
  982. clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
  983. buf);
  984. }
  985. return 0;
  986. }
  987. static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
  988. u32 stripesize, struct btrfs_root *root,
  989. struct btrfs_fs_info *fs_info,
  990. u64 objectid)
  991. {
  992. root->node = NULL;
  993. root->commit_root = NULL;
  994. root->sectorsize = sectorsize;
  995. root->nodesize = nodesize;
  996. root->leafsize = leafsize;
  997. root->stripesize = stripesize;
  998. root->ref_cows = 0;
  999. root->track_dirty = 0;
  1000. root->in_radix = 0;
  1001. root->orphan_item_inserted = 0;
  1002. root->orphan_cleanup_state = 0;
  1003. root->fs_info = fs_info;
  1004. root->objectid = objectid;
  1005. root->last_trans = 0;
  1006. root->highest_objectid = 0;
  1007. root->name = NULL;
  1008. root->inode_tree = RB_ROOT;
  1009. INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
  1010. root->block_rsv = NULL;
  1011. root->orphan_block_rsv = NULL;
  1012. INIT_LIST_HEAD(&root->dirty_list);
  1013. INIT_LIST_HEAD(&root->orphan_list);
  1014. INIT_LIST_HEAD(&root->root_list);
  1015. spin_lock_init(&root->orphan_lock);
  1016. spin_lock_init(&root->inode_lock);
  1017. spin_lock_init(&root->accounting_lock);
  1018. mutex_init(&root->objectid_mutex);
  1019. mutex_init(&root->log_mutex);
  1020. init_waitqueue_head(&root->log_writer_wait);
  1021. init_waitqueue_head(&root->log_commit_wait[0]);
  1022. init_waitqueue_head(&root->log_commit_wait[1]);
  1023. atomic_set(&root->log_commit[0], 0);
  1024. atomic_set(&root->log_commit[1], 0);
  1025. atomic_set(&root->log_writers, 0);
  1026. root->log_batch = 0;
  1027. root->log_transid = 0;
  1028. root->last_log_commit = 0;
  1029. extent_io_tree_init(&root->dirty_log_pages,
  1030. fs_info->btree_inode->i_mapping);
  1031. memset(&root->root_key, 0, sizeof(root->root_key));
  1032. memset(&root->root_item, 0, sizeof(root->root_item));
  1033. memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
  1034. memset(&root->root_kobj, 0, sizeof(root->root_kobj));
  1035. root->defrag_trans_start = fs_info->generation;
  1036. init_completion(&root->kobj_unregister);
  1037. root->defrag_running = 0;
  1038. root->root_key.objectid = objectid;
  1039. root->anon_dev = 0;
  1040. return 0;
  1041. }
  1042. static int find_and_setup_root(struct btrfs_root *tree_root,
  1043. struct btrfs_fs_info *fs_info,
  1044. u64 objectid,
  1045. struct btrfs_root *root)
  1046. {
  1047. int ret;
  1048. u32 blocksize;
  1049. u64 generation;
  1050. __setup_root(tree_root->nodesize, tree_root->leafsize,
  1051. tree_root->sectorsize, tree_root->stripesize,
  1052. root, fs_info, objectid);
  1053. ret = btrfs_find_last_root(tree_root, objectid,
  1054. &root->root_item, &root->root_key);
  1055. if (ret > 0)
  1056. return -ENOENT;
  1057. BUG_ON(ret);
  1058. generation = btrfs_root_generation(&root->root_item);
  1059. blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
  1060. root->commit_root = NULL;
  1061. root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
  1062. blocksize, generation);
  1063. if (!root->node || !btrfs_buffer_uptodate(root->node, generation)) {
  1064. free_extent_buffer(root->node);
  1065. root->node = NULL;
  1066. return -EIO;
  1067. }
  1068. root->commit_root = btrfs_root_node(root);
  1069. return 0;
  1070. }
  1071. static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
  1072. struct btrfs_fs_info *fs_info)
  1073. {
  1074. struct btrfs_root *root;
  1075. struct btrfs_root *tree_root = fs_info->tree_root;
  1076. struct extent_buffer *leaf;
  1077. root = kzalloc(sizeof(*root), GFP_NOFS);
  1078. if (!root)
  1079. return ERR_PTR(-ENOMEM);
  1080. __setup_root(tree_root->nodesize, tree_root->leafsize,
  1081. tree_root->sectorsize, tree_root->stripesize,
  1082. root, fs_info, BTRFS_TREE_LOG_OBJECTID);
  1083. root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
  1084. root->root_key.type = BTRFS_ROOT_ITEM_KEY;
  1085. root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
  1086. /*
  1087. * log trees do not get reference counted because they go away
  1088. * before a real commit is actually done. They do store pointers
  1089. * to file data extents, and those reference counts still get
  1090. * updated (along with back refs to the log tree).
  1091. */
  1092. root->ref_cows = 0;
  1093. leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
  1094. BTRFS_TREE_LOG_OBJECTID, NULL,
  1095. 0, 0, 0, 0);
  1096. if (IS_ERR(leaf)) {
  1097. kfree(root);
  1098. return ERR_CAST(leaf);
  1099. }
  1100. memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
  1101. btrfs_set_header_bytenr(leaf, leaf->start);
  1102. btrfs_set_header_generation(leaf, trans->transid);
  1103. btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
  1104. btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
  1105. root->node = leaf;
  1106. write_extent_buffer(root->node, root->fs_info->fsid,
  1107. (unsigned long)btrfs_header_fsid(root->node),
  1108. BTRFS_FSID_SIZE);
  1109. btrfs_mark_buffer_dirty(root->node);
  1110. btrfs_tree_unlock(root->node);
  1111. return root;
  1112. }
  1113. int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
  1114. struct btrfs_fs_info *fs_info)
  1115. {
  1116. struct btrfs_root *log_root;
  1117. log_root = alloc_log_tree(trans, fs_info);
  1118. if (IS_ERR(log_root))
  1119. return PTR_ERR(log_root);
  1120. WARN_ON(fs_info->log_root_tree);
  1121. fs_info->log_root_tree = log_root;
  1122. return 0;
  1123. }
  1124. int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
  1125. struct btrfs_root *root)
  1126. {
  1127. struct btrfs_root *log_root;
  1128. struct btrfs_inode_item *inode_item;
  1129. log_root = alloc_log_tree(trans, root->fs_info);
  1130. if (IS_ERR(log_root))
  1131. return PTR_ERR(log_root);
  1132. log_root->last_trans = trans->transid;
  1133. log_root->root_key.offset = root->root_key.objectid;
  1134. inode_item = &log_root->root_item.inode;
  1135. inode_item->generation = cpu_to_le64(1);
  1136. inode_item->size = cpu_to_le64(3);
  1137. inode_item->nlink = cpu_to_le32(1);
  1138. inode_item->nbytes = cpu_to_le64(root->leafsize);
  1139. inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
  1140. btrfs_set_root_node(&log_root->root_item, log_root->node);
  1141. WARN_ON(root->log_root);
  1142. root->log_root = log_root;
  1143. root->log_transid = 0;
  1144. root->last_log_commit = 0;
  1145. return 0;
  1146. }
  1147. struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
  1148. struct btrfs_key *location)
  1149. {
  1150. struct btrfs_root *root;
  1151. struct btrfs_fs_info *fs_info = tree_root->fs_info;
  1152. struct btrfs_path *path;
  1153. struct extent_buffer *l;
  1154. u64 generation;
  1155. u32 blocksize;
  1156. int ret = 0;
  1157. root = kzalloc(sizeof(*root), GFP_NOFS);
  1158. if (!root)
  1159. return ERR_PTR(-ENOMEM);
  1160. if (location->offset == (u64)-1) {
  1161. ret = find_and_setup_root(tree_root, fs_info,
  1162. location->objectid, root);
  1163. if (ret) {
  1164. kfree(root);
  1165. return ERR_PTR(ret);
  1166. }
  1167. goto out;
  1168. }
  1169. __setup_root(tree_root->nodesize, tree_root->leafsize,
  1170. tree_root->sectorsize, tree_root->stripesize,
  1171. root, fs_info, location->objectid);
  1172. path = btrfs_alloc_path();
  1173. if (!path) {
  1174. kfree(root);
  1175. return ERR_PTR(-ENOMEM);
  1176. }
  1177. ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
  1178. if (ret == 0) {
  1179. l = path->nodes[0];
  1180. read_extent_buffer(l, &root->root_item,
  1181. btrfs_item_ptr_offset(l, path->slots[0]),
  1182. sizeof(root->root_item));
  1183. memcpy(&root->root_key, location, sizeof(*location));
  1184. }
  1185. btrfs_free_path(path);
  1186. if (ret) {
  1187. kfree(root);
  1188. if (ret > 0)
  1189. ret = -ENOENT;
  1190. return ERR_PTR(ret);
  1191. }
  1192. generation = btrfs_root_generation(&root->root_item);
  1193. blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
  1194. root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
  1195. blocksize, generation);
  1196. root->commit_root = btrfs_root_node(root);
  1197. BUG_ON(!root->node);
  1198. out:
  1199. if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
  1200. root->ref_cows = 1;
  1201. btrfs_check_and_init_root_item(&root->root_item);
  1202. }
  1203. return root;
  1204. }
  1205. struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
  1206. struct btrfs_key *location)
  1207. {
  1208. struct btrfs_root *root;
  1209. int ret;
  1210. if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
  1211. return fs_info->tree_root;
  1212. if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
  1213. return fs_info->extent_root;
  1214. if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
  1215. return fs_info->chunk_root;
  1216. if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
  1217. return fs_info->dev_root;
  1218. if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
  1219. return fs_info->csum_root;
  1220. again:
  1221. spin_lock(&fs_info->fs_roots_radix_lock);
  1222. root = radix_tree_lookup(&fs_info->fs_roots_radix,
  1223. (unsigned long)location->objectid);
  1224. spin_unlock(&fs_info->fs_roots_radix_lock);
  1225. if (root)
  1226. return root;
  1227. root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
  1228. if (IS_ERR(root))
  1229. return root;
  1230. root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
  1231. root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
  1232. GFP_NOFS);
  1233. if (!root->free_ino_pinned || !root->free_ino_ctl) {
  1234. ret = -ENOMEM;
  1235. goto fail;
  1236. }
  1237. btrfs_init_free_ino_ctl(root);
  1238. mutex_init(&root->fs_commit_mutex);
  1239. spin_lock_init(&root->cache_lock);
  1240. init_waitqueue_head(&root->cache_wait);
  1241. ret = get_anon_bdev(&root->anon_dev);
  1242. if (ret)
  1243. goto fail;
  1244. if (btrfs_root_refs(&root->root_item) == 0) {
  1245. ret = -ENOENT;
  1246. goto fail;
  1247. }
  1248. ret = btrfs_find_orphan_item(fs_info->tree_root, location->objectid);
  1249. if (ret < 0)
  1250. goto fail;
  1251. if (ret == 0)
  1252. root->orphan_item_inserted = 1;
  1253. ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
  1254. if (ret)
  1255. goto fail;
  1256. spin_lock(&fs_info->fs_roots_radix_lock);
  1257. ret = radix_tree_insert(&fs_info->fs_roots_radix,
  1258. (unsigned long)root->root_key.objectid,
  1259. root);
  1260. if (ret == 0)
  1261. root->in_radix = 1;
  1262. spin_unlock(&fs_info->fs_roots_radix_lock);
  1263. radix_tree_preload_end();
  1264. if (ret) {
  1265. if (ret == -EEXIST) {
  1266. free_fs_root(root);
  1267. goto again;
  1268. }
  1269. goto fail;
  1270. }
  1271. ret = btrfs_find_dead_roots(fs_info->tree_root,
  1272. root->root_key.objectid);
  1273. WARN_ON(ret);
  1274. return root;
  1275. fail:
  1276. free_fs_root(root);
  1277. return ERR_PTR(ret);
  1278. }
  1279. static int btrfs_congested_fn(void *congested_data, int bdi_bits)
  1280. {
  1281. struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
  1282. int ret = 0;
  1283. struct btrfs_device *device;
  1284. struct backing_dev_info *bdi;
  1285. rcu_read_lock();
  1286. list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
  1287. if (!device->bdev)
  1288. continue;
  1289. bdi = blk_get_backing_dev_info(device->bdev);
  1290. if (bdi && bdi_congested(bdi, bdi_bits)) {
  1291. ret = 1;
  1292. break;
  1293. }
  1294. }
  1295. rcu_read_unlock();
  1296. return ret;
  1297. }
  1298. /*
  1299. * If this fails, caller must call bdi_destroy() to get rid of the
  1300. * bdi again.
  1301. */
  1302. static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
  1303. {
  1304. int err;
  1305. bdi->capabilities = BDI_CAP_MAP_COPY;
  1306. err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
  1307. if (err)
  1308. return err;
  1309. bdi->ra_pages = default_backing_dev_info.ra_pages;
  1310. bdi->congested_fn = btrfs_congested_fn;
  1311. bdi->congested_data = info;
  1312. return 0;
  1313. }
  1314. static int bio_ready_for_csum(struct bio *bio)
  1315. {
  1316. u64 length = 0;
  1317. u64 buf_len = 0;
  1318. u64 start = 0;
  1319. struct page *page;
  1320. struct extent_io_tree *io_tree = NULL;
  1321. struct bio_vec *bvec;
  1322. int i;
  1323. int ret;
  1324. bio_for_each_segment(bvec, bio, i) {
  1325. page = bvec->bv_page;
  1326. if (page->private == EXTENT_PAGE_PRIVATE) {
  1327. length += bvec->bv_len;
  1328. continue;
  1329. }
  1330. if (!page->private) {
  1331. length += bvec->bv_len;
  1332. continue;
  1333. }
  1334. length = bvec->bv_len;
  1335. buf_len = page->private >> 2;
  1336. start = page_offset(page) + bvec->bv_offset;
  1337. io_tree = &BTRFS_I(page->mapping->host)->io_tree;
  1338. }
  1339. /* are we fully contained in this bio? */
  1340. if (buf_len <= length)
  1341. return 1;
  1342. ret = extent_range_uptodate(io_tree, start + length,
  1343. start + buf_len - 1);
  1344. return ret;
  1345. }
  1346. /*
  1347. * called by the kthread helper functions to finally call the bio end_io
  1348. * functions. This is where read checksum verification actually happens
  1349. */
  1350. static void end_workqueue_fn(struct btrfs_work *work)
  1351. {
  1352. struct bio *bio;
  1353. struct end_io_wq *end_io_wq;
  1354. struct btrfs_fs_info *fs_info;
  1355. int error;
  1356. end_io_wq = container_of(work, struct end_io_wq, work);
  1357. bio = end_io_wq->bio;
  1358. fs_info = end_io_wq->info;
  1359. /* metadata bio reads are special because the whole tree block must
  1360. * be checksummed at once. This makes sure the entire block is in
  1361. * ram and up to date before trying to verify things. For
  1362. * blocksize <= pagesize, it is basically a noop
  1363. */
  1364. if (!(bio->bi_rw & REQ_WRITE) && end_io_wq->metadata &&
  1365. !bio_ready_for_csum(bio)) {
  1366. btrfs_queue_worker(&fs_info->endio_meta_workers,
  1367. &end_io_wq->work);
  1368. return;
  1369. }
  1370. error = end_io_wq->error;
  1371. bio->bi_private = end_io_wq->private;
  1372. bio->bi_end_io = end_io_wq->end_io;
  1373. kfree(end_io_wq);
  1374. bio_endio(bio, error);
  1375. }
  1376. static int cleaner_kthread(void *arg)
  1377. {
  1378. struct btrfs_root *root = arg;
  1379. do {
  1380. vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
  1381. if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
  1382. mutex_trylock(&root->fs_info->cleaner_mutex)) {
  1383. btrfs_run_delayed_iputs(root);
  1384. btrfs_clean_old_snapshots(root);
  1385. mutex_unlock(&root->fs_info->cleaner_mutex);
  1386. btrfs_run_defrag_inodes(root->fs_info);
  1387. }
  1388. if (!try_to_freeze()) {
  1389. set_current_state(TASK_INTERRUPTIBLE);
  1390. if (!kthread_should_stop())
  1391. schedule();
  1392. __set_current_state(TASK_RUNNING);
  1393. }
  1394. } while (!kthread_should_stop());
  1395. return 0;
  1396. }
  1397. static int transaction_kthread(void *arg)
  1398. {
  1399. struct btrfs_root *root = arg;
  1400. struct btrfs_trans_handle *trans;
  1401. struct btrfs_transaction *cur;
  1402. u64 transid;
  1403. unsigned long now;
  1404. unsigned long delay;
  1405. int ret;
  1406. do {
  1407. delay = HZ * 30;
  1408. vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
  1409. mutex_lock(&root->fs_info->transaction_kthread_mutex);
  1410. spin_lock(&root->fs_info->trans_lock);
  1411. cur = root->fs_info->running_transaction;
  1412. if (!cur) {
  1413. spin_unlock(&root->fs_info->trans_lock);
  1414. goto sleep;
  1415. }
  1416. now = get_seconds();
  1417. if (!cur->blocked &&
  1418. (now < cur->start_time || now - cur->start_time < 30)) {
  1419. spin_unlock(&root->fs_info->trans_lock);
  1420. delay = HZ * 5;
  1421. goto sleep;
  1422. }
  1423. transid = cur->transid;
  1424. spin_unlock(&root->fs_info->trans_lock);
  1425. trans = btrfs_join_transaction(root);
  1426. BUG_ON(IS_ERR(trans));
  1427. if (transid == trans->transid) {
  1428. ret = btrfs_commit_transaction(trans, root);
  1429. BUG_ON(ret);
  1430. } else {
  1431. btrfs_end_transaction(trans, root);
  1432. }
  1433. sleep:
  1434. wake_up_process(root->fs_info->cleaner_kthread);
  1435. mutex_unlock(&root->fs_info->transaction_kthread_mutex);
  1436. if (!try_to_freeze()) {
  1437. set_current_state(TASK_INTERRUPTIBLE);
  1438. if (!kthread_should_stop() &&
  1439. !btrfs_transaction_blocked(root->fs_info))
  1440. schedule_timeout(delay);
  1441. __set_current_state(TASK_RUNNING);
  1442. }
  1443. } while (!kthread_should_stop());
  1444. return 0;
  1445. }
  1446. /*
  1447. * this will find the highest generation in the array of
  1448. * root backups. The index of the highest array is returned,
  1449. * or -1 if we can't find anything.
  1450. *
  1451. * We check to make sure the array is valid by comparing the
  1452. * generation of the latest root in the array with the generation
  1453. * in the super block. If they don't match we pitch it.
  1454. */
  1455. static int find_newest_super_backup(struct btrfs_fs_info *info, u64 newest_gen)
  1456. {
  1457. u64 cur;
  1458. int newest_index = -1;
  1459. struct btrfs_root_backup *root_backup;
  1460. int i;
  1461. for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
  1462. root_backup = info->super_copy->super_roots + i;
  1463. cur = btrfs_backup_tree_root_gen(root_backup);
  1464. if (cur == newest_gen)
  1465. newest_index = i;
  1466. }
  1467. /* check to see if we actually wrapped around */
  1468. if (newest_index == BTRFS_NUM_BACKUP_ROOTS - 1) {
  1469. root_backup = info->super_copy->super_roots;
  1470. cur = btrfs_backup_tree_root_gen(root_backup);
  1471. if (cur == newest_gen)
  1472. newest_index = 0;
  1473. }
  1474. return newest_index;
  1475. }
  1476. /*
  1477. * find the oldest backup so we know where to store new entries
  1478. * in the backup array. This will set the backup_root_index
  1479. * field in the fs_info struct
  1480. */
  1481. static void find_oldest_super_backup(struct btrfs_fs_info *info,
  1482. u64 newest_gen)
  1483. {
  1484. int newest_index = -1;
  1485. newest_index = find_newest_super_backup(info, newest_gen);
  1486. /* if there was garbage in there, just move along */
  1487. if (newest_index == -1) {
  1488. info->backup_root_index = 0;
  1489. } else {
  1490. info->backup_root_index = (newest_index + 1) % BTRFS_NUM_BACKUP_ROOTS;
  1491. }
  1492. }
  1493. /*
  1494. * copy all the root pointers into the super backup array.
  1495. * this will bump the backup pointer by one when it is
  1496. * done
  1497. */
  1498. static void backup_super_roots(struct btrfs_fs_info *info)
  1499. {
  1500. int next_backup;
  1501. struct btrfs_root_backup *root_backup;
  1502. int last_backup;
  1503. next_backup = info->backup_root_index;
  1504. last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) %
  1505. BTRFS_NUM_BACKUP_ROOTS;
  1506. /*
  1507. * just overwrite the last backup if we're at the same generation
  1508. * this happens only at umount
  1509. */
  1510. root_backup = info->super_for_commit->super_roots + last_backup;
  1511. if (btrfs_backup_tree_root_gen(root_backup) ==
  1512. btrfs_header_generation(info->tree_root->node))
  1513. next_backup = last_backup;
  1514. root_backup = info->super_for_commit->super_roots + next_backup;
  1515. /*
  1516. * make sure all of our padding and empty slots get zero filled
  1517. * regardless of which ones we use today
  1518. */
  1519. memset(root_backup, 0, sizeof(*root_backup));
  1520. info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
  1521. btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
  1522. btrfs_set_backup_tree_root_gen(root_backup,
  1523. btrfs_header_generation(info->tree_root->node));
  1524. btrfs_set_backup_tree_root_level(root_backup,
  1525. btrfs_header_level(info->tree_root->node));
  1526. btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
  1527. btrfs_set_backup_chunk_root_gen(root_backup,
  1528. btrfs_header_generation(info->chunk_root->node));
  1529. btrfs_set_backup_chunk_root_level(root_backup,
  1530. btrfs_header_level(info->chunk_root->node));
  1531. btrfs_set_backup_extent_root(root_backup, info->extent_root->node->start);
  1532. btrfs_set_backup_extent_root_gen(root_backup,
  1533. btrfs_header_generation(info->extent_root->node));
  1534. btrfs_set_backup_extent_root_level(root_backup,
  1535. btrfs_header_level(info->extent_root->node));
  1536. /*
  1537. * we might commit during log recovery, which happens before we set
  1538. * the fs_root. Make sure it is valid before we fill it in.
  1539. */
  1540. if (info->fs_root && info->fs_root->node) {
  1541. btrfs_set_backup_fs_root(root_backup,
  1542. info->fs_root->node->start);
  1543. btrfs_set_backup_fs_root_gen(root_backup,
  1544. btrfs_header_generation(info->fs_root->node));
  1545. btrfs_set_backup_fs_root_level(root_backup,
  1546. btrfs_header_level(info->fs_root->node));
  1547. }
  1548. btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
  1549. btrfs_set_backup_dev_root_gen(root_backup,
  1550. btrfs_header_generation(info->dev_root->node));
  1551. btrfs_set_backup_dev_root_level(root_backup,
  1552. btrfs_header_level(info->dev_root->node));
  1553. btrfs_set_backup_csum_root(root_backup, info->csum_root->node->start);
  1554. btrfs_set_backup_csum_root_gen(root_backup,
  1555. btrfs_header_generation(info->csum_root->node));
  1556. btrfs_set_backup_csum_root_level(root_backup,
  1557. btrfs_header_level(info->csum_root->node));
  1558. btrfs_set_backup_total_bytes(root_backup,
  1559. btrfs_super_total_bytes(info->super_copy));
  1560. btrfs_set_backup_bytes_used(root_backup,
  1561. btrfs_super_bytes_used(info->super_copy));
  1562. btrfs_set_backup_num_devices(root_backup,
  1563. btrfs_super_num_devices(info->super_copy));
  1564. /*
  1565. * if we don't copy this out to the super_copy, it won't get remembered
  1566. * for the next commit
  1567. */
  1568. memcpy(&info->super_copy->super_roots,
  1569. &info->super_for_commit->super_roots,
  1570. sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
  1571. }
  1572. /*
  1573. * this copies info out of the root backup array and back into
  1574. * the in-memory super block. It is meant to help iterate through
  1575. * the array, so you send it the number of backups you've already
  1576. * tried and the last backup index you used.
  1577. *
  1578. * this returns -1 when it has tried all the backups
  1579. */
  1580. static noinline int next_root_backup(struct btrfs_fs_info *info,
  1581. struct btrfs_super_block *super,
  1582. int *num_backups_tried, int *backup_index)
  1583. {
  1584. struct btrfs_root_backup *root_backup;
  1585. int newest = *backup_index;
  1586. if (*num_backups_tried == 0) {
  1587. u64 gen = btrfs_super_generation(super);
  1588. newest = find_newest_super_backup(info, gen);
  1589. if (newest == -1)
  1590. return -1;
  1591. *backup_index = newest;
  1592. *num_backups_tried = 1;
  1593. } else if (*num_backups_tried == BTRFS_NUM_BACKUP_ROOTS) {
  1594. /* we've tried all the backups, all done */
  1595. return -1;
  1596. } else {
  1597. /* jump to the next oldest backup */
  1598. newest = (*backup_index + BTRFS_NUM_BACKUP_ROOTS - 1) %
  1599. BTRFS_NUM_BACKUP_ROOTS;
  1600. *backup_index = newest;
  1601. *num_backups_tried += 1;
  1602. }
  1603. root_backup = super->super_roots + newest;
  1604. btrfs_set_super_generation(super,
  1605. btrfs_backup_tree_root_gen(root_backup));
  1606. btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
  1607. btrfs_set_super_root_level(super,
  1608. btrfs_backup_tree_root_level(root_backup));
  1609. btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));
  1610. /*
  1611. * fixme: the total bytes and num_devices need to match or we should
  1612. * need a fsck
  1613. */
  1614. btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
  1615. btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
  1616. return 0;
  1617. }
  1618. /* helper to cleanup tree roots */
  1619. static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
  1620. {
  1621. free_extent_buffer(info->tree_root->node);
  1622. free_extent_buffer(info->tree_root->commit_root);
  1623. free_extent_buffer(info->dev_root->node);
  1624. free_extent_buffer(info->dev_root->commit_root);
  1625. free_extent_buffer(info->extent_root->node);
  1626. free_extent_buffer(info->extent_root->commit_root);
  1627. free_extent_buffer(info->csum_root->node);
  1628. free_extent_buffer(info->csum_root->commit_root);
  1629. info->tree_root->node = NULL;
  1630. info->tree_root->commit_root = NULL;
  1631. info->dev_root->node = NULL;
  1632. info->dev_root->commit_root = NULL;
  1633. info->extent_root->node = NULL;
  1634. info->extent_root->commit_root = NULL;
  1635. info->csum_root->node = NULL;
  1636. info->csum_root->commit_root = NULL;
  1637. if (chunk_root) {
  1638. free_extent_buffer(info->chunk_root->node);
  1639. free_extent_buffer(info->chunk_root->commit_root);
  1640. info->chunk_root->node = NULL;
  1641. info->chunk_root->commit_root = NULL;
  1642. }
  1643. }
  1644. struct btrfs_root *open_ctree(struct super_block *sb,
  1645. struct btrfs_fs_devices *fs_devices,
  1646. char *options)
  1647. {
  1648. u32 sectorsize;
  1649. u32 nodesize;
  1650. u32 leafsize;
  1651. u32 blocksize;
  1652. u32 stripesize;
  1653. u64 generation;
  1654. u64 features;
  1655. struct btrfs_key location;
  1656. struct buffer_head *bh;
  1657. struct btrfs_super_block *disk_super;
  1658. struct btrfs_root *tree_root = btrfs_sb(sb);
  1659. struct btrfs_fs_info *fs_info = tree_root->fs_info;
  1660. struct btrfs_root *extent_root;
  1661. struct btrfs_root *csum_root;
  1662. struct btrfs_root *chunk_root;
  1663. struct btrfs_root *dev_root;
  1664. struct btrfs_root *log_tree_root;
  1665. int ret;
  1666. int err = -EINVAL;
  1667. int num_backups_tried = 0;
  1668. int backup_index = 0;
  1669. extent_root = fs_info->extent_root =
  1670. kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
  1671. csum_root = fs_info->csum_root =
  1672. kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
  1673. chunk_root = fs_info->chunk_root =
  1674. kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
  1675. dev_root = fs_info->dev_root =
  1676. kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
  1677. if (!extent_root || !csum_root || !chunk_root || !dev_root) {
  1678. err = -ENOMEM;
  1679. goto fail;
  1680. }
  1681. ret = init_srcu_struct(&fs_info->subvol_srcu);
  1682. if (ret) {
  1683. err = ret;
  1684. goto fail;
  1685. }
  1686. ret = setup_bdi(fs_info, &fs_info->bdi);
  1687. if (ret) {
  1688. err = ret;
  1689. goto fail_srcu;
  1690. }
  1691. fs_info->btree_inode = new_inode(sb);
  1692. if (!fs_info->btree_inode) {
  1693. err = -ENOMEM;
  1694. goto fail_bdi;
  1695. }
  1696. mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
  1697. INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
  1698. INIT_LIST_HEAD(&fs_info->trans_list);
  1699. INIT_LIST_HEAD(&fs_info->dead_roots);
  1700. INIT_LIST_HEAD(&fs_info->delayed_iputs);
  1701. INIT_LIST_HEAD(&fs_info->hashers);
  1702. INIT_LIST_HEAD(&fs_info->delalloc_inodes);
  1703. INIT_LIST_HEAD(&fs_info->ordered_operations);
  1704. INIT_LIST_HEAD(&fs_info->caching_block_groups);
  1705. spin_lock_init(&fs_info->delalloc_lock);
  1706. spin_lock_init(&fs_info->trans_lock);
  1707. spin_lock_init(&fs_info->ref_cache_lock);
  1708. spin_lock_init(&fs_info->fs_roots_radix_lock);
  1709. spin_lock_init(&fs_info->delayed_iput_lock);
  1710. spin_lock_init(&fs_info->defrag_inodes_lock);
  1711. spin_lock_init(&fs_info->free_chunk_lock);
  1712. mutex_init(&fs_info->reloc_mutex);
  1713. init_completion(&fs_info->kobj_unregister);
  1714. INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
  1715. INIT_LIST_HEAD(&fs_info->space_info);
  1716. btrfs_mapping_init(&fs_info->mapping_tree);
  1717. btrfs_init_block_rsv(&fs_info->global_block_rsv);
  1718. btrfs_init_block_rsv(&fs_info->delalloc_block_rsv);
  1719. btrfs_init_block_rsv(&fs_info->trans_block_rsv);
  1720. btrfs_init_block_rsv(&fs_info->chunk_block_rsv);
  1721. btrfs_init_block_rsv(&fs_info->empty_block_rsv);
  1722. btrfs_init_block_rsv(&fs_info->delayed_block_rsv);
  1723. atomic_set(&fs_info->nr_async_submits, 0);
  1724. atomic_set(&fs_info->async_delalloc_pages, 0);
  1725. atomic_set(&fs_info->async_submit_draining, 0);
  1726. atomic_set(&fs_info->nr_async_bios, 0);
  1727. atomic_set(&fs_info->defrag_running, 0);
  1728. fs_info->sb = sb;
  1729. fs_info->max_inline = 8192 * 1024;
  1730. fs_info->metadata_ratio = 0;
  1731. fs_info->defrag_inodes = RB_ROOT;
  1732. fs_info->trans_no_join = 0;
  1733. fs_info->free_chunk_space = 0;
  1734. /* readahead state */
  1735. INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
  1736. spin_lock_init(&fs_info->reada_lock);
  1737. fs_info->thread_pool_size = min_t(unsigned long,
  1738. num_online_cpus() + 2, 8);
  1739. INIT_LIST_HEAD(&fs_info->ordered_extents);
  1740. spin_lock_init(&fs_info->ordered_extent_lock);
  1741. fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
  1742. GFP_NOFS);
  1743. if (!fs_info->delayed_root) {
  1744. err = -ENOMEM;
  1745. goto fail_iput;
  1746. }
  1747. btrfs_init_delayed_root(fs_info->delayed_root);
  1748. mutex_init(&fs_info->scrub_lock);
  1749. atomic_set(&fs_info->scrubs_running, 0);
  1750. atomic_set(&fs_info->scrub_pause_req, 0);
  1751. atomic_set(&fs_info->scrubs_paused, 0);
  1752. atomic_set(&fs_info->scrub_cancel_req, 0);
  1753. init_waitqueue_head(&fs_info->scrub_pause_wait);
  1754. init_rwsem(&fs_info->scrub_super_lock);
  1755. fs_info->scrub_workers_refcnt = 0;
  1756. #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
  1757. fs_info->check_integrity_print_mask = 0;
  1758. #endif
  1759. spin_lock_init(&fs_info->balance_lock);
  1760. mutex_init(&fs_info->balance_mutex);
  1761. atomic_set(&fs_info->balance_running, 0);
  1762. atomic_set(&fs_info->balance_pause_req, 0);
  1763. atomic_set(&fs_info->balance_cancel_req, 0);
  1764. fs_info->balance_ctl = NULL;
  1765. init_waitqueue_head(&fs_info->balance_wait_q);
  1766. sb->s_blocksize = 4096;
  1767. sb->s_blocksize_bits = blksize_bits(4096);
  1768. sb->s_bdi = &fs_info->bdi;
  1769. fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
  1770. set_nlink(fs_info->btree_inode, 1);
  1771. /*
  1772. * we set the i_size on the btree inode to the max possible int.
  1773. * the real end of the address space is determined by all of
  1774. * the devices in the system
  1775. */
  1776. fs_info->btree_inode->i_size = OFFSET_MAX;
  1777. fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
  1778. fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;
  1779. RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
  1780. extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
  1781. fs_info->btree_inode->i_mapping);
  1782. extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
  1783. BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
  1784. BTRFS_I(fs_info->btree_inode)->root = tree_root;
  1785. memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
  1786. sizeof(struct btrfs_key));
  1787. BTRFS_I(fs_info->btree_inode)->dummy_inode = 1;
  1788. insert_inode_hash(fs_info->btree_inode);
  1789. spin_lock_init(&fs_info->block_group_cache_lock);
  1790. fs_info->block_group_cache_tree = RB_ROOT;
  1791. extent_io_tree_init(&fs_info->freed_extents[0],
  1792. fs_info->btree_inode->i_mapping);
  1793. extent_io_tree_init(&fs_info->freed_extents[1],
  1794. fs_info->btree_inode->i_mapping);
  1795. fs_info->pinned_extents = &fs_info->freed_extents[0];
  1796. fs_info->do_barriers = 1;
  1797. mutex_init(&fs_info->ordered_operations_mutex);
  1798. mutex_init(&fs_info->tree_log_mutex);
  1799. mutex_init(&fs_info->chunk_mutex);
  1800. mutex_init(&fs_info->transaction_kthread_mutex);
  1801. mutex_init(&fs_info->cleaner_mutex);
  1802. mutex_init(&fs_info->volume_mutex);
  1803. init_rwsem(&fs_info->extent_commit_sem);
  1804. init_rwsem(&fs_info->cleanup_work_sem);
  1805. init_rwsem(&fs_info->subvol_sem);
  1806. btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
  1807. btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
  1808. init_waitqueue_head(&fs_info->transaction_throttle);
  1809. init_waitqueue_head(&fs_info->transaction_wait);
  1810. init_waitqueue_head(&fs_info->transaction_blocked_wait);
  1811. init_waitqueue_head(&fs_info->async_submit_wait);
  1812. __setup_root(4096, 4096, 4096, 4096, tree_root,
  1813. fs_info, BTRFS_ROOT_TREE_OBJECTID);
  1814. bh = btrfs_read_dev_super(fs_devices->latest_bdev);
  1815. if (!bh) {
  1816. err = -EINVAL;
  1817. goto fail_alloc;
  1818. }
  1819. memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
  1820. memcpy(fs_info->super_for_commit, fs_info->super_copy,
  1821. sizeof(*fs_info->super_for_commit));
  1822. brelse(bh);
  1823. memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
  1824. disk_super = fs_info->super_copy;
  1825. if (!btrfs_super_root(disk_super))
  1826. goto fail_alloc;
  1827. /* check FS state, whether FS is broken. */
  1828. fs_info->fs_state |= btrfs_super_flags(disk_super);
  1829. btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
  1830. /*
  1831. * run through our array of backup supers and setup
  1832. * our ring pointer to the oldest one
  1833. */
  1834. generation = btrfs_super_generation(disk_super);
  1835. find_oldest_super_backup(fs_info, generation);
  1836. /*
  1837. * In the long term, we'll store the compression type in the super
  1838. * block, and it'll be used for per file compression control.
  1839. */
  1840. fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
  1841. ret = btrfs_parse_options(tree_root, options);
  1842. if (ret) {
  1843. err = ret;
  1844. goto fail_alloc;
  1845. }
  1846. features = btrfs_super_incompat_flags(disk_super) &
  1847. ~BTRFS_FEATURE_INCOMPAT_SUPP;
  1848. if (features) {
  1849. printk(KERN_ERR "BTRFS: couldn't mount because of "
  1850. "unsupported optional features (%Lx).\n",
  1851. (unsigned long long)features);
  1852. err = -EINVAL;
  1853. goto fail_alloc;
  1854. }
  1855. features = btrfs_super_incompat_flags(disk_super);
  1856. features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
  1857. if (tree_root->fs_info->compress_type & BTRFS_COMPRESS_LZO)
  1858. features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
  1859. btrfs_set_super_incompat_flags(disk_super, features);
  1860. features = btrfs_super_compat_ro_flags(disk_super) &
  1861. ~BTRFS_FEATURE_COMPAT_RO_SUPP;
  1862. if (!(sb->s_flags & MS_RDONLY) && features) {
  1863. printk(KERN_ERR "BTRFS: couldn't mount RDWR because of "
  1864. "unsupported option features (%Lx).\n",
  1865. (unsigned long long)features);
  1866. err = -EINVAL;
  1867. goto fail_alloc;
  1868. }
  1869. btrfs_init_workers(&fs_info->generic_worker,
  1870. "genwork", 1, NULL);
  1871. btrfs_init_workers(&fs_info->workers, "worker",
  1872. fs_info->thread_pool_size,
  1873. &fs_info->generic_worker);
  1874. btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
  1875. fs_info->thread_pool_size,
  1876. &fs_info->generic_worker);
  1877. btrfs_init_workers(&fs_info->submit_workers, "submit",
  1878. min_t(u64, fs_devices->num_devices,
  1879. fs_info->thread_pool_size),
  1880. &fs_info->generic_worker);
  1881. btrfs_init_workers(&fs_info->caching_workers, "cache",
  1882. 2, &fs_info->generic_worker);
  1883. /* a higher idle thresh on the submit workers makes it much more
  1884. * likely that bios will be send down in a sane order to the
  1885. * devices
  1886. */
  1887. fs_info->submit_workers.idle_thresh = 64;
  1888. fs_info->workers.idle_thresh = 16;
  1889. fs_info->workers.ordered = 1;
  1890. fs_info->delalloc_workers.idle_thresh = 2;
  1891. fs_info->delalloc_workers.ordered = 1;
  1892. btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
  1893. &fs_info->generic_worker);
  1894. btrfs_init_workers(&fs_info->endio_workers, "endio",
  1895. fs_info->thread_pool_size,
  1896. &fs_info->generic_worker);
  1897. btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
  1898. fs_info->thread_pool_size,
  1899. &fs_info->generic_worker);
  1900. btrfs_init_workers(&fs_info->endio_meta_write_workers,
  1901. "endio-meta-write", fs_info->thread_pool_size,
  1902. &fs_info->generic_worker);
  1903. btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
  1904. fs_info->thread_pool_size,
  1905. &fs_info->generic_worker);
  1906. btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
  1907. 1, &fs_info->generic_worker);
  1908. btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
  1909. fs_info->thread_pool_size,
  1910. &fs_info->generic_worker);
  1911. btrfs_init_workers(&fs_info->readahead_workers, "readahead",
  1912. fs_info->thread_pool_size,
  1913. &fs_info->generic_worker);
  1914. /*
  1915. * endios are largely parallel and should have a very
  1916. * low idle thresh
  1917. */
  1918. fs_info->endio_workers.idle_thresh = 4;
  1919. fs_info->endio_meta_workers.idle_thresh = 4;
  1920. fs_info->endio_write_workers.idle_thresh = 2;
  1921. fs_info->endio_meta_write_workers.idle_thresh = 2;
  1922. fs_info->readahead_workers.idle_thresh = 2;
  1923. /*
  1924. * btrfs_start_workers can really only fail because of ENOMEM so just
  1925. * return -ENOMEM if any of these fail.
  1926. */
  1927. ret = btrfs_start_workers(&fs_info->workers);
  1928. ret |= btrfs_start_workers(&fs_info->generic_worker);
  1929. ret |= btrfs_start_workers(&fs_info->submit_workers);
  1930. ret |= btrfs_start_workers(&fs_info->delalloc_workers);
  1931. ret |= btrfs_start_workers(&fs_info->fixup_workers);
  1932. ret |= btrfs_start_workers(&fs_info->endio_workers);
  1933. ret |= btrfs_start_workers(&fs_info->endio_meta_workers);
  1934. ret |= btrfs_start_workers(&fs_info->endio_meta_write_workers);
  1935. ret |= btrfs_start_workers(&fs_info->endio_write_workers);
  1936. ret |= btrfs_start_workers(&fs_info->endio_freespace_worker);
  1937. ret |= btrfs_start_workers(&fs_info->delayed_workers);
  1938. ret |= btrfs_start_workers(&fs_info->caching_workers);
  1939. ret |= btrfs_start_workers(&fs_info->readahead_workers);
  1940. if (ret) {
  1941. ret = -ENOMEM;
  1942. goto fail_sb_buffer;
  1943. }
  1944. fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
  1945. fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
  1946. 4 * 1024 * 1024 / PAGE_CACHE_SIZE);
  1947. nodesize = btrfs_super_nodesize(disk_super);
  1948. leafsize = btrfs_super_leafsize(disk_super);
  1949. sectorsize = btrfs_super_sectorsize(disk_super);
  1950. stripesize = btrfs_super_stripesize(disk_super);
  1951. tree_root->nodesize = nodesize;
  1952. tree_root->leafsize = leafsize;
  1953. tree_root->sectorsize = sectorsize;
  1954. tree_root->stripesize = stripesize;
  1955. sb->s_blocksize = sectorsize;
  1956. sb->s_blocksize_bits = blksize_bits(sectorsize);
  1957. if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
  1958. sizeof(disk_super->magic))) {
  1959. printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
  1960. goto fail_sb_buffer;
  1961. }
  1962. mutex_lock(&fs_info->chunk_mutex);
  1963. ret = btrfs_read_sys_array(tree_root);
  1964. mutex_unlock(&fs_info->chunk_mutex);
  1965. if (ret) {
  1966. printk(KERN_WARNING "btrfs: failed to read the system "
  1967. "array on %s\n", sb->s_id);
  1968. goto fail_sb_buffer;
  1969. }
  1970. blocksize = btrfs_level_size(tree_root,
  1971. btrfs_super_chunk_root_level(disk_super));
  1972. generation = btrfs_super_chunk_root_generation(disk_super);
  1973. __setup_root(nodesize, leafsize, sectorsize, stripesize,
  1974. chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
  1975. chunk_root->node = read_tree_block(chunk_root,
  1976. btrfs_super_chunk_root(disk_super),
  1977. blocksize, generation);
  1978. BUG_ON(!chunk_root->node);
  1979. if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
  1980. printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n",
  1981. sb->s_id);
  1982. goto fail_tree_roots;
  1983. }
  1984. btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
  1985. chunk_root->commit_root = btrfs_root_node(chunk_root);
  1986. read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
  1987. (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
  1988. BTRFS_UUID_SIZE);
  1989. ret = btrfs_read_chunk_tree(chunk_root);
  1990. if (ret) {
  1991. printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
  1992. sb->s_id);
  1993. goto fail_tree_roots;
  1994. }
  1995. btrfs_close_extra_devices(fs_devices);
  1996. retry_root_backup:
  1997. blocksize = btrfs_level_size(tree_root,
  1998. btrfs_super_root_level(disk_super));
  1999. generation = btrfs_super_generation(disk_super);
  2000. tree_root->node = read_tree_block(tree_root,
  2001. btrfs_super_root(disk_super),
  2002. blocksize, generation);
  2003. if (!tree_root->node ||
  2004. !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
  2005. printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
  2006. sb->s_id);
  2007. goto recovery_tree_root;
  2008. }
  2009. btrfs_set_root_node(&tree_root->root_item, tree_root->node);
  2010. tree_root->commit_root = btrfs_root_node(tree_root);
  2011. ret = find_and_setup_root(tree_root, fs_info,
  2012. BTRFS_EXTENT_TREE_OBJECTID, extent_root);
  2013. if (ret)
  2014. goto recovery_tree_root;
  2015. extent_root->track_dirty = 1;
  2016. ret = find_and_setup_root(tree_root, fs_info,
  2017. BTRFS_DEV_TREE_OBJECTID, dev_root);
  2018. if (ret)
  2019. goto recovery_tree_root;
  2020. dev_root->track_dirty = 1;
  2021. ret = find_and_setup_root(tree_root, fs_info,
  2022. BTRFS_CSUM_TREE_OBJECTID, csum_root);
  2023. if (ret)
  2024. goto recovery_tree_root;
  2025. csum_root->track_dirty = 1;
  2026. fs_info->generation = generation;
  2027. fs_info->last_trans_committed = generation;
  2028. ret = btrfs_init_space_info(fs_info);
  2029. if (ret) {
  2030. printk(KERN_ERR "Failed to initial space info: %d\n", ret);
  2031. goto fail_block_groups;
  2032. }
  2033. ret = btrfs_read_block_groups(extent_root);
  2034. if (ret) {
  2035. printk(KERN_ERR "Failed to read block groups: %d\n", ret);
  2036. goto fail_block_groups;
  2037. }
  2038. fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
  2039. "btrfs-cleaner");
  2040. if (IS_ERR(fs_info->cleaner_kthread))
  2041. goto fail_block_groups;
  2042. fs_info->transaction_kthread = kthread_run(transaction_kthread,
  2043. tree_root,
  2044. "btrfs-transaction");
  2045. if (IS_ERR(fs_info->transaction_kthread))
  2046. goto fail_cleaner;
  2047. if (!btrfs_test_opt(tree_root, SSD) &&
  2048. !btrfs_test_opt(tree_root, NOSSD) &&
  2049. !fs_info->fs_devices->rotating) {
  2050. printk(KERN_INFO "Btrfs detected SSD devices, enabling SSD "
  2051. "mode\n");
  2052. btrfs_set_opt(fs_info->mount_opt, SSD);
  2053. }
  2054. #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
  2055. if (btrfs_test_opt(tree_root, CHECK_INTEGRITY)) {
  2056. ret = btrfsic_mount(tree_root, fs_devices,
  2057. btrfs_test_opt(tree_root,
  2058. CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
  2059. 1 : 0,
  2060. fs_info->check_integrity_print_mask);
  2061. if (ret)
  2062. printk(KERN_WARNING "btrfs: failed to initialize"
  2063. " integrity check module %s\n", sb->s_id);
  2064. }
  2065. #endif
  2066. /* do not make disk changes in broken FS */
  2067. if (btrfs_super_log_root(disk_super) != 0 &&
  2068. !(fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)) {
  2069. u64 bytenr = btrfs_super_log_root(disk_super);
  2070. if (fs_devices->rw_devices == 0) {
  2071. printk(KERN_WARNING "Btrfs log replay required "
  2072. "on RO media\n");
  2073. err = -EIO;
  2074. goto fail_trans_kthread;
  2075. }
  2076. blocksize =
  2077. btrfs_level_size(tree_root,
  2078. btrfs_super_log_root_level(disk_super));
  2079. log_tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
  2080. if (!log_tree_root) {
  2081. err = -ENOMEM;
  2082. goto fail_trans_kthread;
  2083. }
  2084. __setup_root(nodesize, leafsize, sectorsize, stripesize,
  2085. log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
  2086. log_tree_root->node = read_tree_block(tree_root, bytenr,
  2087. blocksize,
  2088. generation + 1);
  2089. ret = btrfs_recover_log_trees(log_tree_root);
  2090. BUG_ON(ret);
  2091. if (sb->s_flags & MS_RDONLY) {
  2092. ret = btrfs_commit_super(tree_root);
  2093. BUG_ON(ret);
  2094. }
  2095. }
  2096. ret = btrfs_find_orphan_roots(tree_root);
  2097. BUG_ON(ret);
  2098. if (!(sb->s_flags & MS_RDONLY)) {
  2099. ret = btrfs_cleanup_fs_roots(fs_info);
  2100. BUG_ON(ret);
  2101. ret = btrfs_recover_relocation(tree_root);
  2102. if (ret < 0) {
  2103. printk(KERN_WARNING
  2104. "btrfs: failed to recover relocation\n");
  2105. err = -EINVAL;
  2106. goto fail_trans_kthread;
  2107. }
  2108. }
  2109. location.objectid = BTRFS_FS_TREE_OBJECTID;
  2110. location.type = BTRFS_ROOT_ITEM_KEY;
  2111. location.offset = (u64)-1;
  2112. fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
  2113. if (!fs_info->fs_root)
  2114. goto fail_trans_kthread;
  2115. if (IS_ERR(fs_info->fs_root)) {
  2116. err = PTR_ERR(fs_info->fs_root);
  2117. goto fail_trans_kthread;
  2118. }
  2119. if (!(sb->s_flags & MS_RDONLY)) {
  2120. down_read(&fs_info->cleanup_work_sem);
  2121. err = btrfs_orphan_cleanup(fs_info->fs_root);
  2122. if (!err)
  2123. err = btrfs_orphan_cleanup(fs_info->tree_root);
  2124. up_read(&fs_info->cleanup_work_sem);
  2125. if (!err)
  2126. err = btrfs_recover_balance(fs_info->tree_root);
  2127. if (err) {
  2128. close_ctree(tree_root);
  2129. return ERR_PTR(err);
  2130. }
  2131. }
  2132. return tree_root;
  2133. fail_trans_kthread:
  2134. kthread_stop(fs_info->transaction_kthread);
  2135. fail_cleaner:
  2136. kthread_stop(fs_info->cleaner_kthread);
  2137. /*
  2138. * make sure we're done with the btree inode before we stop our
  2139. * kthreads
  2140. */
  2141. filemap_write_and_wait(fs_info->btree_inode->i_mapping);
  2142. invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
  2143. fail_block_groups:
  2144. btrfs_free_block_groups(fs_info);
  2145. fail_tree_roots:
  2146. free_root_pointers(fs_info, 1);
  2147. fail_sb_buffer:
  2148. btrfs_stop_workers(&fs_info->generic_worker);
  2149. btrfs_stop_workers(&fs_info->readahead_workers);
  2150. btrfs_stop_workers(&fs_info->fixup_workers);
  2151. btrfs_stop_workers(&fs_info->delalloc_workers);
  2152. btrfs_stop_workers(&fs_info->workers);
  2153. btrfs_stop_workers(&fs_info->endio_workers);
  2154. btrfs_stop_workers(&fs_info->endio_meta_workers);
  2155. btrfs_stop_workers(&fs_info->endio_meta_write_workers);
  2156. btrfs_stop_workers(&fs_info->endio_write_workers);
  2157. btrfs_stop_workers(&fs_info->endio_freespace_worker);
  2158. btrfs_stop_workers(&fs_info->submit_workers);
  2159. btrfs_stop_workers(&fs_info->delayed_workers);
  2160. btrfs_stop_workers(&fs_info->caching_workers);
  2161. fail_alloc:
  2162. fail_iput:
  2163. btrfs_mapping_tree_free(&fs_info->mapping_tree);
  2164. invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
  2165. iput(fs_info->btree_inode);
  2166. fail_bdi:
  2167. bdi_destroy(&fs_info->bdi);
  2168. fail_srcu:
  2169. cleanup_srcu_struct(&fs_info->subvol_srcu);
  2170. fail:
  2171. btrfs_close_devices(fs_info->fs_devices);
  2172. free_fs_info(fs_info);
  2173. return ERR_PTR(err);
  2174. recovery_tree_root:
  2175. if (!btrfs_test_opt(tree_root, RECOVERY))
  2176. goto fail_tree_roots;
  2177. free_root_pointers(fs_info, 0);
  2178. /* don't use the log in recovery mode, it won't be valid */
  2179. btrfs_set_super_log_root(disk_super, 0);
  2180. /* we can't trust the free space cache either */
  2181. btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
  2182. ret = next_root_backup(fs_info, fs_info->super_copy,
  2183. &num_backups_tried, &backup_index);
  2184. if (ret == -1)
  2185. goto fail_block_groups;
  2186. goto retry_root_backup;
  2187. }
  2188. static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
  2189. {
  2190. char b[BDEVNAME_SIZE];
  2191. if (uptodate) {
  2192. set_buffer_uptodate(bh);
  2193. } else {
  2194. printk_ratelimited(KERN_WARNING "lost page write due to "
  2195. "I/O error on %s\n",
  2196. bdevname(bh->b_bdev, b));
  2197. /* note, we dont' set_buffer_write_io_error because we have
  2198. * our own ways of dealing with the IO errors
  2199. */
  2200. clear_buffer_uptodate(bh);
  2201. }
  2202. unlock_buffer(bh);
  2203. put_bh(bh);
  2204. }
  2205. struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
  2206. {
  2207. struct buffer_head *bh;
  2208. struct buffer_head *latest = NULL;
  2209. struct btrfs_super_block *super;
  2210. int i;
  2211. u64 transid = 0;
  2212. u64 bytenr;
  2213. /* we would like to check all the supers, but that would make
  2214. * a btrfs mount succeed after a mkfs from a different FS.
  2215. * So, we need to add a special mount option to scan for
  2216. * later supers, using BTRFS_SUPER_MIRROR_MAX instead
  2217. */
  2218. for (i = 0; i < 1; i++) {
  2219. bytenr = btrfs_sb_offset(i);
  2220. if (bytenr + 4096 >= i_size_read(bdev->bd_inode))
  2221. break;
  2222. bh = __bread(bdev, bytenr / 4096, 4096);
  2223. if (!bh)
  2224. continue;
  2225. super = (struct btrfs_super_block *)bh->b_data;
  2226. if (btrfs_super_bytenr(super) != bytenr ||
  2227. strncmp((char *)(&super->magic), BTRFS_MAGIC,
  2228. sizeof(super->magic))) {
  2229. brelse(bh);
  2230. continue;
  2231. }
  2232. if (!latest || btrfs_super_generation(super) > transid) {
  2233. brelse(latest);
  2234. latest = bh;
  2235. transid = btrfs_super_generation(super);
  2236. } else {
  2237. brelse(bh);
  2238. }
  2239. }
  2240. return latest;
  2241. }
  2242. /*
  2243. * this should be called twice, once with wait == 0 and
  2244. * once with wait == 1. When wait == 0 is done, all the buffer heads
  2245. * we write are pinned.
  2246. *
  2247. * They are released when wait == 1 is done.
  2248. * max_mirrors must be the same for both runs, and it indicates how
  2249. * many supers on this one device should be written.
  2250. *
  2251. * max_mirrors == 0 means to write them all.
  2252. */
  2253. static int write_dev_supers(struct btrfs_device *device,
  2254. struct btrfs_super_block *sb,
  2255. int do_barriers, int wait, int max_mirrors)
  2256. {
  2257. struct buffer_head *bh;
  2258. int i;
  2259. int ret;
  2260. int errors = 0;
  2261. u32 crc;
  2262. u64 bytenr;
  2263. if (max_mirrors == 0)
  2264. max_mirrors = BTRFS_SUPER_MIRROR_MAX;
  2265. for (i = 0; i < max_mirrors; i++) {
  2266. bytenr = btrfs_sb_offset(i);
  2267. if (bytenr + BTRFS_SUPER_INFO_SIZE >= device->total_bytes)
  2268. break;
  2269. if (wait) {
  2270. bh = __find_get_block(device->bdev, bytenr / 4096,
  2271. BTRFS_SUPER_INFO_SIZE);
  2272. BUG_ON(!bh);
  2273. wait_on_buffer(bh);
  2274. if (!buffer_uptodate(bh))
  2275. errors++;
  2276. /* drop our reference */
  2277. brelse(bh);
  2278. /* drop the reference from the wait == 0 run */
  2279. brelse(bh);
  2280. continue;
  2281. } else {
  2282. btrfs_set_super_bytenr(sb, bytenr);
  2283. crc = ~(u32)0;
  2284. crc = btrfs_csum_data(NULL, (char *)sb +
  2285. BTRFS_CSUM_SIZE, crc,
  2286. BTRFS_SUPER_INFO_SIZE -
  2287. BTRFS_CSUM_SIZE);
  2288. btrfs_csum_final(crc, sb->csum);
  2289. /*
  2290. * one reference for us, and we leave it for the
  2291. * caller
  2292. */
  2293. bh = __getblk(device->bdev, bytenr / 4096,
  2294. BTRFS_SUPER_INFO_SIZE);
  2295. memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);
  2296. /* one reference for submit_bh */
  2297. get_bh(bh);
  2298. set_buffer_uptodate(bh);
  2299. lock_buffer(bh);
  2300. bh->b_end_io = btrfs_end_buffer_write_sync;
  2301. }
  2302. /*
  2303. * we fua the first super. The others we allow
  2304. * to go down lazy.
  2305. */
  2306. ret = btrfsic_submit_bh(WRITE_FUA, bh);
  2307. if (ret)
  2308. errors++;
  2309. }
  2310. return errors < i ? 0 : -1;
  2311. }
  2312. /*
  2313. * endio for the write_dev_flush, this will wake anyone waiting
  2314. * for the barrier when it is done
  2315. */
  2316. static void btrfs_end_empty_barrier(struct bio *bio, int err)
  2317. {
  2318. if (err) {
  2319. if (err == -EOPNOTSUPP)
  2320. set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
  2321. clear_bit(BIO_UPTODATE, &bio->bi_flags);
  2322. }
  2323. if (bio->bi_private)
  2324. complete(bio->bi_private);
  2325. bio_put(bio);
  2326. }
  2327. /*
  2328. * trigger flushes for one the devices. If you pass wait == 0, the flushes are
  2329. * sent down. With wait == 1, it waits for the previous flush.
  2330. *
  2331. * any device where the flush fails with eopnotsupp are flagged as not-barrier
  2332. * capable
  2333. */
  2334. static int write_dev_flush(struct btrfs_device *device, int wait)
  2335. {
  2336. struct bio *bio;
  2337. int ret = 0;
  2338. if (device->nobarriers)
  2339. return 0;
  2340. if (wait) {
  2341. bio = device->flush_bio;
  2342. if (!bio)
  2343. return 0;
  2344. wait_for_completion(&device->flush_wait);
  2345. if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
  2346. printk("btrfs: disabling barriers on dev %s\n",
  2347. device->name);
  2348. device->nobarriers = 1;
  2349. }
  2350. if (!bio_flagged(bio, BIO_UPTODATE)) {
  2351. ret = -EIO;
  2352. }
  2353. /* drop the reference from the wait == 0 run */
  2354. bio_put(bio);
  2355. device->flush_bio = NULL;
  2356. return ret;
  2357. }
  2358. /*
  2359. * one reference for us, and we leave it for the
  2360. * caller
  2361. */
  2362. device->flush_bio = NULL;;
  2363. bio = bio_alloc(GFP_NOFS, 0);
  2364. if (!bio)
  2365. return -ENOMEM;
  2366. bio->bi_end_io = btrfs_end_empty_barrier;
  2367. bio->bi_bdev = device->bdev;
  2368. init_completion(&device->flush_wait);
  2369. bio->bi_private = &device->flush_wait;
  2370. device->flush_bio = bio;
  2371. bio_get(bio);
  2372. btrfsic_submit_bio(WRITE_FLUSH, bio);
  2373. return 0;
  2374. }
  2375. /*
  2376. * send an empty flush down to each device in parallel,
  2377. * then wait for them
  2378. */
  2379. static int barrier_all_devices(struct btrfs_fs_info *info)
  2380. {
  2381. struct list_head *head;
  2382. struct btrfs_device *dev;
  2383. int errors = 0;
  2384. int ret;
  2385. /* send down all the barriers */
  2386. head = &info->fs_devices->devices;
  2387. list_for_each_entry_rcu(dev, head, dev_list) {
  2388. if (!dev->bdev) {
  2389. errors++;
  2390. continue;
  2391. }
  2392. if (!dev->in_fs_metadata || !dev->writeable)
  2393. continue;
  2394. ret = write_dev_flush(dev, 0);
  2395. if (ret)
  2396. errors++;
  2397. }
  2398. /* wait for all the barriers */
  2399. list_for_each_entry_rcu(dev, head, dev_list) {
  2400. if (!dev->bdev) {
  2401. errors++;
  2402. continue;
  2403. }
  2404. if (!dev->in_fs_metadata || !dev->writeable)
  2405. continue;
  2406. ret = write_dev_flush(dev, 1);
  2407. if (ret)
  2408. errors++;
  2409. }
  2410. if (errors)
  2411. return -EIO;
  2412. return 0;
  2413. }
  2414. int write_all_supers(struct btrfs_root *root, int max_mirrors)
  2415. {
  2416. struct list_head *head;
  2417. struct btrfs_device *dev;
  2418. struct btrfs_super_block *sb;
  2419. struct btrfs_dev_item *dev_item;
  2420. int ret;
  2421. int do_barriers;
  2422. int max_errors;
  2423. int total_errors = 0;
  2424. u64 flags;
  2425. max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
  2426. do_barriers = !btrfs_test_opt(root, NOBARRIER);
  2427. backup_super_roots(root->fs_info);
  2428. sb = root->fs_info->super_for_commit;
  2429. dev_item = &sb->dev_item;
  2430. mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
  2431. head = &root->fs_info->fs_devices->devices;
  2432. if (do_barriers)
  2433. barrier_all_devices(root->fs_info);
  2434. list_for_each_entry_rcu(dev, head, dev_list) {
  2435. if (!dev->bdev) {
  2436. total_errors++;
  2437. continue;
  2438. }
  2439. if (!dev->in_fs_metadata || !dev->writeable)
  2440. continue;
  2441. btrfs_set_stack_device_generation(dev_item, 0);
  2442. btrfs_set_stack_device_type(dev_item, dev->type);
  2443. btrfs_set_stack_device_id(dev_item, dev->devid);
  2444. btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
  2445. btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
  2446. btrfs_set_stack_device_io_align(dev_item, dev->io_align);
  2447. btrfs_set_stack_device_io_width(dev_item, dev->io_width);
  2448. btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
  2449. memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
  2450. memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
  2451. flags = btrfs_super_flags(sb);
  2452. btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
  2453. ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
  2454. if (ret)
  2455. total_errors++;
  2456. }
  2457. if (total_errors > max_errors) {
  2458. printk(KERN_ERR "btrfs: %d errors while writing supers\n",
  2459. total_errors);
  2460. BUG();
  2461. }
  2462. total_errors = 0;
  2463. list_for_each_entry_rcu(dev, head, dev_list) {
  2464. if (!dev->bdev)
  2465. continue;
  2466. if (!dev->in_fs_metadata || !dev->writeable)
  2467. continue;
  2468. ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
  2469. if (ret)
  2470. total_errors++;
  2471. }
  2472. mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
  2473. if (total_errors > max_errors) {
  2474. printk(KERN_ERR "btrfs: %d errors while writing supers\n",
  2475. total_errors);
  2476. BUG();
  2477. }
  2478. return 0;
  2479. }
  2480. int write_ctree_super(struct btrfs_trans_handle *trans,
  2481. struct btrfs_root *root, int max_mirrors)
  2482. {
  2483. int ret;
  2484. ret = write_all_supers(root, max_mirrors);
  2485. return ret;
  2486. }
  2487. int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
  2488. {
  2489. spin_lock(&fs_info->fs_roots_radix_lock);
  2490. radix_tree_delete(&fs_info->fs_roots_radix,
  2491. (unsigned long)root->root_key.objectid);
  2492. spin_unlock(&fs_info->fs_roots_radix_lock);
  2493. if (btrfs_root_refs(&root->root_item) == 0)
  2494. synchronize_srcu(&fs_info->subvol_srcu);
  2495. __btrfs_remove_free_space_cache(root->free_ino_pinned);
  2496. __btrfs_remove_free_space_cache(root->free_ino_ctl);
  2497. free_fs_root(root);
  2498. return 0;
  2499. }
  2500. static void free_fs_root(struct btrfs_root *root)
  2501. {
  2502. iput(root->cache_inode);
  2503. WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
  2504. if (root->anon_dev)
  2505. free_anon_bdev(root->anon_dev);
  2506. free_extent_buffer(root->node);
  2507. free_extent_buffer(root->commit_root);
  2508. kfree(root->free_ino_ctl);
  2509. kfree(root->free_ino_pinned);
  2510. kfree(root->name);
  2511. kfree(root);
  2512. }
  2513. static int del_fs_roots(struct btrfs_fs_info *fs_info)
  2514. {
  2515. int ret;
  2516. struct btrfs_root *gang[8];
  2517. int i;
  2518. while (!list_empty(&fs_info->dead_roots)) {
  2519. gang[0] = list_entry(fs_info->dead_roots.next,
  2520. struct btrfs_root, root_list);
  2521. list_del(&gang[0]->root_list);
  2522. if (gang[0]->in_radix) {
  2523. btrfs_free_fs_root(fs_info, gang[0]);
  2524. } else {
  2525. free_extent_buffer(gang[0]->node);
  2526. free_extent_buffer(gang[0]->commit_root);
  2527. kfree(gang[0]);
  2528. }
  2529. }
  2530. while (1) {
  2531. ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
  2532. (void **)gang, 0,
  2533. ARRAY_SIZE(gang));
  2534. if (!ret)
  2535. break;
  2536. for (i = 0; i < ret; i++)
  2537. btrfs_free_fs_root(fs_info, gang[i]);
  2538. }
  2539. return 0;
  2540. }
  2541. int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
  2542. {
  2543. u64 root_objectid = 0;
  2544. struct btrfs_root *gang[8];
  2545. int i;
  2546. int ret;
  2547. while (1) {
  2548. ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
  2549. (void **)gang, root_objectid,
  2550. ARRAY_SIZE(gang));
  2551. if (!ret)
  2552. break;
  2553. root_objectid = gang[ret - 1]->root_key.objectid + 1;
  2554. for (i = 0; i < ret; i++) {
  2555. int err;
  2556. root_objectid = gang[i]->root_key.objectid;
  2557. err = btrfs_orphan_cleanup(gang[i]);
  2558. if (err)
  2559. return err;
  2560. }
  2561. root_objectid++;
  2562. }
  2563. return 0;
  2564. }
  2565. int btrfs_commit_super(struct btrfs_root *root)
  2566. {
  2567. struct btrfs_trans_handle *trans;
  2568. int ret;
  2569. mutex_lock(&root->fs_info->cleaner_mutex);
  2570. btrfs_run_delayed_iputs(root);
  2571. btrfs_clean_old_snapshots(root);
  2572. mutex_unlock(&root->fs_info->cleaner_mutex);
  2573. /* wait until ongoing cleanup work done */
  2574. down_write(&root->fs_info->cleanup_work_sem);
  2575. up_write(&root->fs_info->cleanup_work_sem);
  2576. trans = btrfs_join_transaction(root);
  2577. if (IS_ERR(trans))
  2578. return PTR_ERR(trans);
  2579. ret = btrfs_commit_transaction(trans, root);
  2580. BUG_ON(ret);
  2581. /* run commit again to drop the original snapshot */
  2582. trans = btrfs_join_transaction(root);
  2583. if (IS_ERR(trans))
  2584. return PTR_ERR(trans);
  2585. btrfs_commit_transaction(trans, root);
  2586. ret = btrfs_write_and_wait_transaction(NULL, root);
  2587. BUG_ON(ret);
  2588. ret = write_ctree_super(NULL, root, 0);
  2589. return ret;
  2590. }
  2591. int close_ctree(struct btrfs_root *root)
  2592. {
  2593. struct btrfs_fs_info *fs_info = root->fs_info;
  2594. int ret;
  2595. fs_info->closing = 1;
  2596. smp_mb();
  2597. /* pause restriper - we want to resume on mount */
  2598. btrfs_pause_balance(root->fs_info);
  2599. btrfs_scrub_cancel(root);
  2600. /* wait for any defraggers to finish */
  2601. wait_event(fs_info->transaction_wait,
  2602. (atomic_read(&fs_info->defrag_running) == 0));
  2603. /* clear out the rbtree of defraggable inodes */
  2604. btrfs_run_defrag_inodes(root->fs_info);
  2605. /*
  2606. * Here come 2 situations when btrfs is broken to flip readonly:
  2607. *
  2608. * 1. when btrfs flips readonly somewhere else before
  2609. * btrfs_commit_super, sb->s_flags has MS_RDONLY flag,
  2610. * and btrfs will skip to write sb directly to keep
  2611. * ERROR state on disk.
  2612. *
  2613. * 2. when btrfs flips readonly just in btrfs_commit_super,
  2614. * and in such case, btrfs cannot write sb via btrfs_commit_super,
  2615. * and since fs_state has been set BTRFS_SUPER_FLAG_ERROR flag,
  2616. * btrfs will cleanup all FS resources first and write sb then.
  2617. */
  2618. if (!(fs_info->sb->s_flags & MS_RDONLY)) {
  2619. ret = btrfs_commit_super(root);
  2620. if (ret)
  2621. printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
  2622. }
  2623. if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
  2624. ret = btrfs_error_commit_super(root);
  2625. if (ret)
  2626. printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
  2627. }
  2628. btrfs_put_block_group_cache(fs_info);
  2629. kthread_stop(root->fs_info->transaction_kthread);
  2630. kthread_stop(root->fs_info->cleaner_kthread);
  2631. fs_info->closing = 2;
  2632. smp_mb();
  2633. if (fs_info->delalloc_bytes) {
  2634. printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
  2635. (unsigned long long)fs_info->delalloc_bytes);
  2636. }
  2637. if (fs_info->total_ref_cache_size) {
  2638. printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
  2639. (unsigned long long)fs_info->total_ref_cache_size);
  2640. }
  2641. free_extent_buffer(fs_info->extent_root->node);
  2642. free_extent_buffer(fs_info->extent_root->commit_root);
  2643. free_extent_buffer(fs_info->tree_root->node);
  2644. free_extent_buffer(fs_info->tree_root->commit_root);
  2645. free_extent_buffer(root->fs_info->chunk_root->node);
  2646. free_extent_buffer(root->fs_info->chunk_root->commit_root);
  2647. free_extent_buffer(root->fs_info->dev_root->node);
  2648. free_extent_buffer(root->fs_info->dev_root->commit_root);
  2649. free_extent_buffer(root->fs_info->csum_root->node);
  2650. free_extent_buffer(root->fs_info->csum_root->commit_root);
  2651. btrfs_free_block_groups(root->fs_info);
  2652. del_fs_roots(fs_info);
  2653. iput(fs_info->btree_inode);
  2654. btrfs_stop_workers(&fs_info->generic_worker);
  2655. btrfs_stop_workers(&fs_info->fixup_workers);
  2656. btrfs_stop_workers(&fs_info->delalloc_workers);
  2657. btrfs_stop_workers(&fs_info->workers);
  2658. btrfs_stop_workers(&fs_info->endio_workers);
  2659. btrfs_stop_workers(&fs_info->endio_meta_workers);
  2660. btrfs_stop_workers(&fs_info->endio_meta_write_workers);
  2661. btrfs_stop_workers(&fs_info->endio_write_workers);
  2662. btrfs_stop_workers(&fs_info->endio_freespace_worker);
  2663. btrfs_stop_workers(&fs_info->submit_workers);
  2664. btrfs_stop_workers(&fs_info->delayed_workers);
  2665. btrfs_stop_workers(&fs_info->caching_workers);
  2666. btrfs_stop_workers(&fs_info->readahead_workers);
  2667. #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
  2668. if (btrfs_test_opt(root, CHECK_INTEGRITY))
  2669. btrfsic_unmount(root, fs_info->fs_devices);
  2670. #endif
  2671. btrfs_close_devices(fs_info->fs_devices);
  2672. btrfs_mapping_tree_free(&fs_info->mapping_tree);
  2673. bdi_destroy(&fs_info->bdi);
  2674. cleanup_srcu_struct(&fs_info->subvol_srcu);
  2675. free_fs_info(fs_info);
  2676. return 0;
  2677. }
  2678. int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
  2679. {
  2680. int ret;
  2681. struct inode *btree_inode = buf->first_page->mapping->host;
  2682. ret = extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree, buf,
  2683. NULL);
  2684. if (!ret)
  2685. return ret;
  2686. ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
  2687. parent_transid);
  2688. return !ret;
  2689. }
  2690. int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
  2691. {
  2692. struct inode *btree_inode = buf->first_page->mapping->host;
  2693. return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
  2694. buf);
  2695. }
  2696. void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
  2697. {
  2698. struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
  2699. u64 transid = btrfs_header_generation(buf);
  2700. struct inode *btree_inode = root->fs_info->btree_inode;
  2701. int was_dirty;
  2702. btrfs_assert_tree_locked(buf);
  2703. if (transid != root->fs_info->generation) {
  2704. printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
  2705. "found %llu running %llu\n",
  2706. (unsigned long long)buf->start,
  2707. (unsigned long long)transid,
  2708. (unsigned long long)root->fs_info->generation);
  2709. WARN_ON(1);
  2710. }
  2711. was_dirty = set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
  2712. buf);
  2713. if (!was_dirty) {
  2714. spin_lock(&root->fs_info->delalloc_lock);
  2715. root->fs_info->dirty_metadata_bytes += buf->len;
  2716. spin_unlock(&root->fs_info->delalloc_lock);
  2717. }
  2718. }
  2719. void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
  2720. {
  2721. /*
  2722. * looks as though older kernels can get into trouble with
  2723. * this code, they end up stuck in balance_dirty_pages forever
  2724. */
  2725. u64 num_dirty;
  2726. unsigned long thresh = 32 * 1024 * 1024;
  2727. if (current->flags & PF_MEMALLOC)
  2728. return;
  2729. btrfs_balance_delayed_items(root);
  2730. num_dirty = root->fs_info->dirty_metadata_bytes;
  2731. if (num_dirty > thresh) {
  2732. balance_dirty_pages_ratelimited_nr(
  2733. root->fs_info->btree_inode->i_mapping, 1);
  2734. }
  2735. return;
  2736. }
  2737. void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
  2738. {
  2739. /*
  2740. * looks as though older kernels can get into trouble with
  2741. * this code, they end up stuck in balance_dirty_pages forever
  2742. */
  2743. u64 num_dirty;
  2744. unsigned long thresh = 32 * 1024 * 1024;
  2745. if (current->flags & PF_MEMALLOC)
  2746. return;
  2747. num_dirty = root->fs_info->dirty_metadata_bytes;
  2748. if (num_dirty > thresh) {
  2749. balance_dirty_pages_ratelimited_nr(
  2750. root->fs_info->btree_inode->i_mapping, 1);
  2751. }
  2752. return;
  2753. }
  2754. int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
  2755. {
  2756. struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
  2757. int ret;
  2758. ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
  2759. if (ret == 0)
  2760. set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
  2761. return ret;
  2762. }
  2763. static int btree_lock_page_hook(struct page *page, void *data,
  2764. void (*flush_fn)(void *))
  2765. {
  2766. struct inode *inode = page->mapping->host;
  2767. struct btrfs_root *root = BTRFS_I(inode)->root;
  2768. struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
  2769. struct extent_buffer *eb;
  2770. unsigned long len;
  2771. u64 bytenr = page_offset(page);
  2772. if (page->private == EXTENT_PAGE_PRIVATE)
  2773. goto out;
  2774. len = page->private >> 2;
  2775. eb = find_extent_buffer(io_tree, bytenr, len);
  2776. if (!eb)
  2777. goto out;
  2778. if (!btrfs_try_tree_write_lock(eb)) {
  2779. flush_fn(data);
  2780. btrfs_tree_lock(eb);
  2781. }
  2782. btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
  2783. if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {
  2784. spin_lock(&root->fs_info->delalloc_lock);
  2785. if (root->fs_info->dirty_metadata_bytes >= eb->len)
  2786. root->fs_info->dirty_metadata_bytes -= eb->len;
  2787. else
  2788. WARN_ON(1);
  2789. spin_unlock(&root->fs_info->delalloc_lock);
  2790. }
  2791. btrfs_tree_unlock(eb);
  2792. free_extent_buffer(eb);
  2793. out:
  2794. if (!trylock_page(page)) {
  2795. flush_fn(data);
  2796. lock_page(page);
  2797. }
  2798. return 0;
  2799. }
  2800. static void btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
  2801. int read_only)
  2802. {
  2803. if (read_only)
  2804. return;
  2805. if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
  2806. printk(KERN_WARNING "warning: mount fs with errors, "
  2807. "running btrfsck is recommended\n");
  2808. }
  2809. int btrfs_error_commit_super(struct btrfs_root *root)
  2810. {
  2811. int ret;
  2812. mutex_lock(&root->fs_info->cleaner_mutex);
  2813. btrfs_run_delayed_iputs(root);
  2814. mutex_unlock(&root->fs_info->cleaner_mutex);
  2815. down_write(&root->fs_info->cleanup_work_sem);
  2816. up_write(&root->fs_info->cleanup_work_sem);
  2817. /* cleanup FS via transaction */
  2818. btrfs_cleanup_transaction(root);
  2819. ret = write_ctree_super(NULL, root, 0);
  2820. return ret;
  2821. }
  2822. static int btrfs_destroy_ordered_operations(struct btrfs_root *root)
  2823. {
  2824. struct btrfs_inode *btrfs_inode;
  2825. struct list_head splice;
  2826. INIT_LIST_HEAD(&splice);
  2827. mutex_lock(&root->fs_info->ordered_operations_mutex);
  2828. spin_lock(&root->fs_info->ordered_extent_lock);
  2829. list_splice_init(&root->fs_info->ordered_operations, &splice);
  2830. while (!list_empty(&splice)) {
  2831. btrfs_inode = list_entry(splice.next, struct btrfs_inode,
  2832. ordered_operations);
  2833. list_del_init(&btrfs_inode->ordered_operations);
  2834. btrfs_invalidate_inodes(btrfs_inode->root);
  2835. }
  2836. spin_unlock(&root->fs_info->ordered_extent_lock);
  2837. mutex_unlock(&root->fs_info->ordered_operations_mutex);
  2838. return 0;
  2839. }
  2840. static int btrfs_destroy_ordered_extents(struct btrfs_root *root)
  2841. {
  2842. struct list_head splice;
  2843. struct btrfs_ordered_extent *ordered;
  2844. struct inode *inode;
  2845. INIT_LIST_HEAD(&splice);
  2846. spin_lock(&root->fs_info->ordered_extent_lock);
  2847. list_splice_init(&root->fs_info->ordered_extents, &splice);
  2848. while (!list_empty(&splice)) {
  2849. ordered = list_entry(splice.next, struct btrfs_ordered_extent,
  2850. root_extent_list);
  2851. list_del_init(&ordered->root_extent_list);
  2852. atomic_inc(&ordered->refs);
  2853. /* the inode may be getting freed (in sys_unlink path). */
  2854. inode = igrab(ordered->inode);
  2855. spin_unlock(&root->fs_info->ordered_extent_lock);
  2856. if (inode)
  2857. iput(inode);
  2858. atomic_set(&ordered->refs, 1);
  2859. btrfs_put_ordered_extent(ordered);
  2860. spin_lock(&root->fs_info->ordered_extent_lock);
  2861. }
  2862. spin_unlock(&root->fs_info->ordered_extent_lock);
  2863. return 0;
  2864. }
  2865. static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
  2866. struct btrfs_root *root)
  2867. {
  2868. struct rb_node *node;
  2869. struct btrfs_delayed_ref_root *delayed_refs;
  2870. struct btrfs_delayed_ref_node *ref;
  2871. int ret = 0;
  2872. delayed_refs = &trans->delayed_refs;
  2873. spin_lock(&delayed_refs->lock);
  2874. if (delayed_refs->num_entries == 0) {
  2875. spin_unlock(&delayed_refs->lock);
  2876. printk(KERN_INFO "delayed_refs has NO entry\n");
  2877. return ret;
  2878. }
  2879. node = rb_first(&delayed_refs->root);
  2880. while (node) {
  2881. ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
  2882. node = rb_next(node);
  2883. ref->in_tree = 0;
  2884. rb_erase(&ref->rb_node, &delayed_refs->root);
  2885. delayed_refs->num_entries--;
  2886. atomic_set(&ref->refs, 1);
  2887. if (btrfs_delayed_ref_is_head(ref)) {
  2888. struct btrfs_delayed_ref_head *head;
  2889. head = btrfs_delayed_node_to_head(ref);
  2890. mutex_lock(&head->mutex);
  2891. kfree(head->extent_op);
  2892. delayed_refs->num_heads--;
  2893. if (list_empty(&head->cluster))
  2894. delayed_refs->num_heads_ready--;
  2895. list_del_init(&head->cluster);
  2896. mutex_unlock(&head->mutex);
  2897. }
  2898. spin_unlock(&delayed_refs->lock);
  2899. btrfs_put_delayed_ref(ref);
  2900. cond_resched();
  2901. spin_lock(&delayed_refs->lock);
  2902. }
  2903. spin_unlock(&delayed_refs->lock);
  2904. return ret;
  2905. }
  2906. static int btrfs_destroy_pending_snapshots(struct btrfs_transaction *t)
  2907. {
  2908. struct btrfs_pending_snapshot *snapshot;
  2909. struct list_head splice;
  2910. INIT_LIST_HEAD(&splice);
  2911. list_splice_init(&t->pending_snapshots, &splice);
  2912. while (!list_empty(&splice)) {
  2913. snapshot = list_entry(splice.next,
  2914. struct btrfs_pending_snapshot,
  2915. list);
  2916. list_del_init(&snapshot->list);
  2917. kfree(snapshot);
  2918. }
  2919. return 0;
  2920. }
  2921. static int btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
  2922. {
  2923. struct btrfs_inode *btrfs_inode;
  2924. struct list_head splice;
  2925. INIT_LIST_HEAD(&splice);
  2926. spin_lock(&root->fs_info->delalloc_lock);
  2927. list_splice_init(&root->fs_info->delalloc_inodes, &splice);
  2928. while (!list_empty(&splice)) {
  2929. btrfs_inode = list_entry(splice.next, struct btrfs_inode,
  2930. delalloc_inodes);
  2931. list_del_init(&btrfs_inode->delalloc_inodes);
  2932. btrfs_invalidate_inodes(btrfs_inode->root);
  2933. }
  2934. spin_unlock(&root->fs_info->delalloc_lock);
  2935. return 0;
  2936. }
  2937. static int btrfs_destroy_marked_extents(struct btrfs_root *root,
  2938. struct extent_io_tree *dirty_pages,
  2939. int mark)
  2940. {
  2941. int ret;
  2942. struct page *page;
  2943. struct inode *btree_inode = root->fs_info->btree_inode;
  2944. struct extent_buffer *eb;
  2945. u64 start = 0;
  2946. u64 end;
  2947. u64 offset;
  2948. unsigned long index;
  2949. while (1) {
  2950. ret = find_first_extent_bit(dirty_pages, start, &start, &end,
  2951. mark);
  2952. if (ret)
  2953. break;
  2954. clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
  2955. while (start <= end) {
  2956. index = start >> PAGE_CACHE_SHIFT;
  2957. start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
  2958. page = find_get_page(btree_inode->i_mapping, index);
  2959. if (!page)
  2960. continue;
  2961. offset = page_offset(page);
  2962. spin_lock(&dirty_pages->buffer_lock);
  2963. eb = radix_tree_lookup(
  2964. &(&BTRFS_I(page->mapping->host)->io_tree)->buffer,
  2965. offset >> PAGE_CACHE_SHIFT);
  2966. spin_unlock(&dirty_pages->buffer_lock);
  2967. if (eb) {
  2968. ret = test_and_clear_bit(EXTENT_BUFFER_DIRTY,
  2969. &eb->bflags);
  2970. atomic_set(&eb->refs, 1);
  2971. }
  2972. if (PageWriteback(page))
  2973. end_page_writeback(page);
  2974. lock_page(page);
  2975. if (PageDirty(page)) {
  2976. clear_page_dirty_for_io(page);
  2977. spin_lock_irq(&page->mapping->tree_lock);
  2978. radix_tree_tag_clear(&page->mapping->page_tree,
  2979. page_index(page),
  2980. PAGECACHE_TAG_DIRTY);
  2981. spin_unlock_irq(&page->mapping->tree_lock);
  2982. }
  2983. page->mapping->a_ops->invalidatepage(page, 0);
  2984. unlock_page(page);
  2985. }
  2986. }
  2987. return ret;
  2988. }
  2989. static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
  2990. struct extent_io_tree *pinned_extents)
  2991. {
  2992. struct extent_io_tree *unpin;
  2993. u64 start;
  2994. u64 end;
  2995. int ret;
  2996. unpin = pinned_extents;
  2997. while (1) {
  2998. ret = find_first_extent_bit(unpin, 0, &start, &end,
  2999. EXTENT_DIRTY);
  3000. if (ret)
  3001. break;
  3002. /* opt_discard */
  3003. if (btrfs_test_opt(root, DISCARD))
  3004. ret = btrfs_error_discard_extent(root, start,
  3005. end + 1 - start,
  3006. NULL);
  3007. clear_extent_dirty(unpin, start, end, GFP_NOFS);
  3008. btrfs_error_unpin_extent_range(root, start, end);
  3009. cond_resched();
  3010. }
  3011. return 0;
  3012. }
  3013. static int btrfs_cleanup_transaction(struct btrfs_root *root)
  3014. {
  3015. struct btrfs_transaction *t;
  3016. LIST_HEAD(list);
  3017. WARN_ON(1);
  3018. mutex_lock(&root->fs_info->transaction_kthread_mutex);
  3019. spin_lock(&root->fs_info->trans_lock);
  3020. list_splice_init(&root->fs_info->trans_list, &list);
  3021. root->fs_info->trans_no_join = 1;
  3022. spin_unlock(&root->fs_info->trans_lock);
  3023. while (!list_empty(&list)) {
  3024. t = list_entry(list.next, struct btrfs_transaction, list);
  3025. if (!t)
  3026. break;
  3027. btrfs_destroy_ordered_operations(root);
  3028. btrfs_destroy_ordered_extents(root);
  3029. btrfs_destroy_delayed_refs(t, root);
  3030. btrfs_block_rsv_release(root,
  3031. &root->fs_info->trans_block_rsv,
  3032. t->dirty_pages.dirty_bytes);
  3033. /* FIXME: cleanup wait for commit */
  3034. t->in_commit = 1;
  3035. t->blocked = 1;
  3036. if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
  3037. wake_up(&root->fs_info->transaction_blocked_wait);
  3038. t->blocked = 0;
  3039. if (waitqueue_active(&root->fs_info->transaction_wait))
  3040. wake_up(&root->fs_info->transaction_wait);
  3041. t->commit_done = 1;
  3042. if (waitqueue_active(&t->commit_wait))
  3043. wake_up(&t->commit_wait);
  3044. btrfs_destroy_pending_snapshots(t);
  3045. btrfs_destroy_delalloc_inodes(root);
  3046. spin_lock(&root->fs_info->trans_lock);
  3047. root->fs_info->running_transaction = NULL;
  3048. spin_unlock(&root->fs_info->trans_lock);
  3049. btrfs_destroy_marked_extents(root, &t->dirty_pages,
  3050. EXTENT_DIRTY);
  3051. btrfs_destroy_pinned_extent(root,
  3052. root->fs_info->pinned_extents);
  3053. atomic_set(&t->use_count, 0);
  3054. list_del_init(&t->list);
  3055. memset(t, 0, sizeof(*t));
  3056. kmem_cache_free(btrfs_transaction_cachep, t);
  3057. }
  3058. spin_lock(&root->fs_info->trans_lock);
  3059. root->fs_info->trans_no_join = 0;
  3060. spin_unlock(&root->fs_info->trans_lock);
  3061. mutex_unlock(&root->fs_info->transaction_kthread_mutex);
  3062. return 0;
  3063. }
  3064. static struct extent_io_ops btree_extent_io_ops = {
  3065. .write_cache_pages_lock_hook = btree_lock_page_hook,
  3066. .readpage_end_io_hook = btree_readpage_end_io_hook,
  3067. .readpage_io_failed_hook = btree_io_failed_hook,
  3068. .submit_bio_hook = btree_submit_bio_hook,
  3069. /* note we're sharing with inode.c for the merge bio hook */
  3070. .merge_bio_hook = btrfs_merge_bio_hook,
  3071. };