journal.c 123 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281
  1. /*
  2. ** Write ahead logging implementation copyright Chris Mason 2000
  3. **
  4. ** The background commits make this code very interelated, and
  5. ** overly complex. I need to rethink things a bit....The major players:
  6. **
  7. ** journal_begin -- call with the number of blocks you expect to log.
  8. ** If the current transaction is too
  9. ** old, it will block until the current transaction is
  10. ** finished, and then start a new one.
  11. ** Usually, your transaction will get joined in with
  12. ** previous ones for speed.
  13. **
  14. ** journal_join -- same as journal_begin, but won't block on the current
  15. ** transaction regardless of age. Don't ever call
  16. ** this. Ever. There are only two places it should be
  17. ** called from, and they are both inside this file.
  18. **
  19. ** journal_mark_dirty -- adds blocks into this transaction. clears any flags
  20. ** that might make them get sent to disk
  21. ** and then marks them BH_JDirty. Puts the buffer head
  22. ** into the current transaction hash.
  23. **
  24. ** journal_end -- if the current transaction is batchable, it does nothing
  25. ** otherwise, it could do an async/synchronous commit, or
  26. ** a full flush of all log and real blocks in the
  27. ** transaction.
  28. **
  29. ** flush_old_commits -- if the current transaction is too old, it is ended and
  30. ** commit blocks are sent to disk. Forces commit blocks
  31. ** to disk for all backgrounded commits that have been
  32. ** around too long.
  33. ** -- Note, if you call this as an immediate flush from
  34. ** from within kupdate, it will ignore the immediate flag
  35. */
  36. #include <asm/uaccess.h>
  37. #include <asm/system.h>
  38. #include <linux/time.h>
  39. #include <asm/semaphore.h>
  40. #include <linux/vmalloc.h>
  41. #include <linux/reiserfs_fs.h>
  42. #include <linux/kernel.h>
  43. #include <linux/errno.h>
  44. #include <linux/fcntl.h>
  45. #include <linux/stat.h>
  46. #include <linux/string.h>
  47. #include <linux/smp_lock.h>
  48. #include <linux/buffer_head.h>
  49. #include <linux/workqueue.h>
  50. #include <linux/writeback.h>
  51. #include <linux/blkdev.h>
  52. #include <linux/backing-dev.h>
  53. /* gets a struct reiserfs_journal_list * from a list head */
  54. #define JOURNAL_LIST_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \
  55. j_list))
  56. #define JOURNAL_WORK_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \
  57. j_working_list))
  58. /* the number of mounted filesystems. This is used to decide when to
  59. ** start and kill the commit workqueue
  60. */
  61. static int reiserfs_mounted_fs_count;
  62. static struct workqueue_struct *commit_wq;
  63. #define JOURNAL_TRANS_HALF 1018 /* must be correct to keep the desc and commit
  64. structs at 4k */
  65. #define BUFNR 64 /*read ahead */
  66. /* cnode stat bits. Move these into reiserfs_fs.h */
  67. #define BLOCK_FREED 2 /* this block was freed, and can't be written. */
  68. #define BLOCK_FREED_HOLDER 3 /* this block was freed during this transaction, and can't be written */
  69. #define BLOCK_NEEDS_FLUSH 4 /* used in flush_journal_list */
  70. #define BLOCK_DIRTIED 5
  71. /* journal list state bits */
  72. #define LIST_TOUCHED 1
  73. #define LIST_DIRTY 2
  74. #define LIST_COMMIT_PENDING 4 /* someone will commit this list */
  75. /* flags for do_journal_end */
  76. #define FLUSH_ALL 1 /* flush commit and real blocks */
  77. #define COMMIT_NOW 2 /* end and commit this transaction */
  78. #define WAIT 4 /* wait for the log blocks to hit the disk */
  79. static int do_journal_end(struct reiserfs_transaction_handle *,
  80. struct super_block *, unsigned long nblocks,
  81. int flags);
  82. static int flush_journal_list(struct super_block *s,
  83. struct reiserfs_journal_list *jl, int flushall);
  84. static int flush_commit_list(struct super_block *s,
  85. struct reiserfs_journal_list *jl, int flushall);
  86. static int can_dirty(struct reiserfs_journal_cnode *cn);
  87. static int journal_join(struct reiserfs_transaction_handle *th,
  88. struct super_block *p_s_sb, unsigned long nblocks);
  89. static int release_journal_dev(struct super_block *super,
  90. struct reiserfs_journal *journal);
  91. static int dirty_one_transaction(struct super_block *s,
  92. struct reiserfs_journal_list *jl);
  93. static void flush_async_commits(struct work_struct *work);
  94. static void queue_log_writer(struct super_block *s);
  95. /* values for join in do_journal_begin_r */
  96. enum {
  97. JBEGIN_REG = 0, /* regular journal begin */
  98. JBEGIN_JOIN = 1, /* join the running transaction if at all possible */
  99. JBEGIN_ABORT = 2, /* called from cleanup code, ignores aborted flag */
  100. };
  101. static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
  102. struct super_block *p_s_sb,
  103. unsigned long nblocks, int join);
  104. static void init_journal_hash(struct super_block *p_s_sb)
  105. {
  106. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  107. memset(journal->j_hash_table, 0,
  108. JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *));
  109. }
  110. /*
  111. ** clears BH_Dirty and sticks the buffer on the clean list. Called because I can't allow refile_buffer to
  112. ** make schedule happen after I've freed a block. Look at remove_from_transaction and journal_mark_freed for
  113. ** more details.
  114. */
  115. static int reiserfs_clean_and_file_buffer(struct buffer_head *bh)
  116. {
  117. if (bh) {
  118. clear_buffer_dirty(bh);
  119. clear_buffer_journal_test(bh);
  120. }
  121. return 0;
  122. }
  123. static void disable_barrier(struct super_block *s)
  124. {
  125. REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_BARRIER_FLUSH);
  126. printk("reiserfs: disabling flush barriers on %s\n",
  127. reiserfs_bdevname(s));
  128. }
  129. static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block
  130. *p_s_sb)
  131. {
  132. struct reiserfs_bitmap_node *bn;
  133. static int id;
  134. bn = kmalloc(sizeof(struct reiserfs_bitmap_node), GFP_NOFS);
  135. if (!bn) {
  136. return NULL;
  137. }
  138. bn->data = kzalloc(p_s_sb->s_blocksize, GFP_NOFS);
  139. if (!bn->data) {
  140. kfree(bn);
  141. return NULL;
  142. }
  143. bn->id = id++;
  144. INIT_LIST_HEAD(&bn->list);
  145. return bn;
  146. }
  147. static struct reiserfs_bitmap_node *get_bitmap_node(struct super_block *p_s_sb)
  148. {
  149. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  150. struct reiserfs_bitmap_node *bn = NULL;
  151. struct list_head *entry = journal->j_bitmap_nodes.next;
  152. journal->j_used_bitmap_nodes++;
  153. repeat:
  154. if (entry != &journal->j_bitmap_nodes) {
  155. bn = list_entry(entry, struct reiserfs_bitmap_node, list);
  156. list_del(entry);
  157. memset(bn->data, 0, p_s_sb->s_blocksize);
  158. journal->j_free_bitmap_nodes--;
  159. return bn;
  160. }
  161. bn = allocate_bitmap_node(p_s_sb);
  162. if (!bn) {
  163. yield();
  164. goto repeat;
  165. }
  166. return bn;
  167. }
  168. static inline void free_bitmap_node(struct super_block *p_s_sb,
  169. struct reiserfs_bitmap_node *bn)
  170. {
  171. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  172. journal->j_used_bitmap_nodes--;
  173. if (journal->j_free_bitmap_nodes > REISERFS_MAX_BITMAP_NODES) {
  174. kfree(bn->data);
  175. kfree(bn);
  176. } else {
  177. list_add(&bn->list, &journal->j_bitmap_nodes);
  178. journal->j_free_bitmap_nodes++;
  179. }
  180. }
  181. static void allocate_bitmap_nodes(struct super_block *p_s_sb)
  182. {
  183. int i;
  184. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  185. struct reiserfs_bitmap_node *bn = NULL;
  186. for (i = 0; i < REISERFS_MIN_BITMAP_NODES; i++) {
  187. bn = allocate_bitmap_node(p_s_sb);
  188. if (bn) {
  189. list_add(&bn->list, &journal->j_bitmap_nodes);
  190. journal->j_free_bitmap_nodes++;
  191. } else {
  192. break; // this is ok, we'll try again when more are needed
  193. }
  194. }
  195. }
  196. static int set_bit_in_list_bitmap(struct super_block *p_s_sb, int block,
  197. struct reiserfs_list_bitmap *jb)
  198. {
  199. int bmap_nr = block / (p_s_sb->s_blocksize << 3);
  200. int bit_nr = block % (p_s_sb->s_blocksize << 3);
  201. if (!jb->bitmaps[bmap_nr]) {
  202. jb->bitmaps[bmap_nr] = get_bitmap_node(p_s_sb);
  203. }
  204. set_bit(bit_nr, (unsigned long *)jb->bitmaps[bmap_nr]->data);
  205. return 0;
  206. }
  207. static void cleanup_bitmap_list(struct super_block *p_s_sb,
  208. struct reiserfs_list_bitmap *jb)
  209. {
  210. int i;
  211. if (jb->bitmaps == NULL)
  212. return;
  213. for (i = 0; i < SB_BMAP_NR(p_s_sb); i++) {
  214. if (jb->bitmaps[i]) {
  215. free_bitmap_node(p_s_sb, jb->bitmaps[i]);
  216. jb->bitmaps[i] = NULL;
  217. }
  218. }
  219. }
  220. /*
  221. ** only call this on FS unmount.
  222. */
  223. static int free_list_bitmaps(struct super_block *p_s_sb,
  224. struct reiserfs_list_bitmap *jb_array)
  225. {
  226. int i;
  227. struct reiserfs_list_bitmap *jb;
  228. for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
  229. jb = jb_array + i;
  230. jb->journal_list = NULL;
  231. cleanup_bitmap_list(p_s_sb, jb);
  232. vfree(jb->bitmaps);
  233. jb->bitmaps = NULL;
  234. }
  235. return 0;
  236. }
  237. static int free_bitmap_nodes(struct super_block *p_s_sb)
  238. {
  239. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  240. struct list_head *next = journal->j_bitmap_nodes.next;
  241. struct reiserfs_bitmap_node *bn;
  242. while (next != &journal->j_bitmap_nodes) {
  243. bn = list_entry(next, struct reiserfs_bitmap_node, list);
  244. list_del(next);
  245. kfree(bn->data);
  246. kfree(bn);
  247. next = journal->j_bitmap_nodes.next;
  248. journal->j_free_bitmap_nodes--;
  249. }
  250. return 0;
  251. }
  252. /*
  253. ** get memory for JOURNAL_NUM_BITMAPS worth of bitmaps.
  254. ** jb_array is the array to be filled in.
  255. */
  256. int reiserfs_allocate_list_bitmaps(struct super_block *p_s_sb,
  257. struct reiserfs_list_bitmap *jb_array,
  258. int bmap_nr)
  259. {
  260. int i;
  261. int failed = 0;
  262. struct reiserfs_list_bitmap *jb;
  263. int mem = bmap_nr * sizeof(struct reiserfs_bitmap_node *);
  264. for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
  265. jb = jb_array + i;
  266. jb->journal_list = NULL;
  267. jb->bitmaps = vmalloc(mem);
  268. if (!jb->bitmaps) {
  269. reiserfs_warning(p_s_sb,
  270. "clm-2000, unable to allocate bitmaps for journal lists");
  271. failed = 1;
  272. break;
  273. }
  274. memset(jb->bitmaps, 0, mem);
  275. }
  276. if (failed) {
  277. free_list_bitmaps(p_s_sb, jb_array);
  278. return -1;
  279. }
  280. return 0;
  281. }
  282. /*
  283. ** find an available list bitmap. If you can't find one, flush a commit list
  284. ** and try again
  285. */
  286. static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *p_s_sb,
  287. struct reiserfs_journal_list
  288. *jl)
  289. {
  290. int i, j;
  291. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  292. struct reiserfs_list_bitmap *jb = NULL;
  293. for (j = 0; j < (JOURNAL_NUM_BITMAPS * 3); j++) {
  294. i = journal->j_list_bitmap_index;
  295. journal->j_list_bitmap_index = (i + 1) % JOURNAL_NUM_BITMAPS;
  296. jb = journal->j_list_bitmap + i;
  297. if (journal->j_list_bitmap[i].journal_list) {
  298. flush_commit_list(p_s_sb,
  299. journal->j_list_bitmap[i].
  300. journal_list, 1);
  301. if (!journal->j_list_bitmap[i].journal_list) {
  302. break;
  303. }
  304. } else {
  305. break;
  306. }
  307. }
  308. if (jb->journal_list) { /* double check to make sure if flushed correctly */
  309. return NULL;
  310. }
  311. jb->journal_list = jl;
  312. return jb;
  313. }
  314. /*
  315. ** allocates a new chunk of X nodes, and links them all together as a list.
  316. ** Uses the cnode->next and cnode->prev pointers
  317. ** returns NULL on failure
  318. */
  319. static struct reiserfs_journal_cnode *allocate_cnodes(int num_cnodes)
  320. {
  321. struct reiserfs_journal_cnode *head;
  322. int i;
  323. if (num_cnodes <= 0) {
  324. return NULL;
  325. }
  326. head = vmalloc(num_cnodes * sizeof(struct reiserfs_journal_cnode));
  327. if (!head) {
  328. return NULL;
  329. }
  330. memset(head, 0, num_cnodes * sizeof(struct reiserfs_journal_cnode));
  331. head[0].prev = NULL;
  332. head[0].next = head + 1;
  333. for (i = 1; i < num_cnodes; i++) {
  334. head[i].prev = head + (i - 1);
  335. head[i].next = head + (i + 1); /* if last one, overwrite it after the if */
  336. }
  337. head[num_cnodes - 1].next = NULL;
  338. return head;
  339. }
  340. /*
  341. ** pulls a cnode off the free list, or returns NULL on failure
  342. */
  343. static struct reiserfs_journal_cnode *get_cnode(struct super_block *p_s_sb)
  344. {
  345. struct reiserfs_journal_cnode *cn;
  346. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  347. reiserfs_check_lock_depth(p_s_sb, "get_cnode");
  348. if (journal->j_cnode_free <= 0) {
  349. return NULL;
  350. }
  351. journal->j_cnode_used++;
  352. journal->j_cnode_free--;
  353. cn = journal->j_cnode_free_list;
  354. if (!cn) {
  355. return cn;
  356. }
  357. if (cn->next) {
  358. cn->next->prev = NULL;
  359. }
  360. journal->j_cnode_free_list = cn->next;
  361. memset(cn, 0, sizeof(struct reiserfs_journal_cnode));
  362. return cn;
  363. }
  364. /*
  365. ** returns a cnode to the free list
  366. */
  367. static void free_cnode(struct super_block *p_s_sb,
  368. struct reiserfs_journal_cnode *cn)
  369. {
  370. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  371. reiserfs_check_lock_depth(p_s_sb, "free_cnode");
  372. journal->j_cnode_used--;
  373. journal->j_cnode_free++;
  374. /* memset(cn, 0, sizeof(struct reiserfs_journal_cnode)) ; */
  375. cn->next = journal->j_cnode_free_list;
  376. if (journal->j_cnode_free_list) {
  377. journal->j_cnode_free_list->prev = cn;
  378. }
  379. cn->prev = NULL; /* not needed with the memset, but I might kill the memset, and forget to do this */
  380. journal->j_cnode_free_list = cn;
  381. }
  382. static void clear_prepared_bits(struct buffer_head *bh)
  383. {
  384. clear_buffer_journal_prepared(bh);
  385. clear_buffer_journal_restore_dirty(bh);
  386. }
  387. /* utility function to force a BUG if it is called without the big
  388. ** kernel lock held. caller is the string printed just before calling BUG()
  389. */
  390. void reiserfs_check_lock_depth(struct super_block *sb, char *caller)
  391. {
  392. #ifdef CONFIG_SMP
  393. if (current->lock_depth < 0) {
  394. reiserfs_panic(sb, "%s called without kernel lock held",
  395. caller);
  396. }
  397. #else
  398. ;
  399. #endif
  400. }
  401. /* return a cnode with same dev, block number and size in table, or null if not found */
  402. static inline struct reiserfs_journal_cnode *get_journal_hash_dev(struct
  403. super_block
  404. *sb,
  405. struct
  406. reiserfs_journal_cnode
  407. **table,
  408. long bl)
  409. {
  410. struct reiserfs_journal_cnode *cn;
  411. cn = journal_hash(table, sb, bl);
  412. while (cn) {
  413. if (cn->blocknr == bl && cn->sb == sb)
  414. return cn;
  415. cn = cn->hnext;
  416. }
  417. return (struct reiserfs_journal_cnode *)0;
  418. }
  419. /*
  420. ** this actually means 'can this block be reallocated yet?'. If you set search_all, a block can only be allocated
  421. ** if it is not in the current transaction, was not freed by the current transaction, and has no chance of ever
  422. ** being overwritten by a replay after crashing.
  423. **
  424. ** If you don't set search_all, a block can only be allocated if it is not in the current transaction. Since deleting
  425. ** a block removes it from the current transaction, this case should never happen. If you don't set search_all, make
  426. ** sure you never write the block without logging it.
  427. **
  428. ** next_zero_bit is a suggestion about the next block to try for find_forward.
  429. ** when bl is rejected because it is set in a journal list bitmap, we search
  430. ** for the next zero bit in the bitmap that rejected bl. Then, we return that
  431. ** through next_zero_bit for find_forward to try.
  432. **
  433. ** Just because we return something in next_zero_bit does not mean we won't
  434. ** reject it on the next call to reiserfs_in_journal
  435. **
  436. */
  437. int reiserfs_in_journal(struct super_block *p_s_sb,
  438. int bmap_nr, int bit_nr, int search_all,
  439. b_blocknr_t * next_zero_bit)
  440. {
  441. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  442. struct reiserfs_journal_cnode *cn;
  443. struct reiserfs_list_bitmap *jb;
  444. int i;
  445. unsigned long bl;
  446. *next_zero_bit = 0; /* always start this at zero. */
  447. PROC_INFO_INC(p_s_sb, journal.in_journal);
  448. /* If we aren't doing a search_all, this is a metablock, and it will be logged before use.
  449. ** if we crash before the transaction that freed it commits, this transaction won't
  450. ** have committed either, and the block will never be written
  451. */
  452. if (search_all) {
  453. for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
  454. PROC_INFO_INC(p_s_sb, journal.in_journal_bitmap);
  455. jb = journal->j_list_bitmap + i;
  456. if (jb->journal_list && jb->bitmaps[bmap_nr] &&
  457. test_bit(bit_nr,
  458. (unsigned long *)jb->bitmaps[bmap_nr]->
  459. data)) {
  460. *next_zero_bit =
  461. find_next_zero_bit((unsigned long *)
  462. (jb->bitmaps[bmap_nr]->
  463. data),
  464. p_s_sb->s_blocksize << 3,
  465. bit_nr + 1);
  466. return 1;
  467. }
  468. }
  469. }
  470. bl = bmap_nr * (p_s_sb->s_blocksize << 3) + bit_nr;
  471. /* is it in any old transactions? */
  472. if (search_all
  473. && (cn =
  474. get_journal_hash_dev(p_s_sb, journal->j_list_hash_table, bl))) {
  475. return 1;
  476. }
  477. /* is it in the current transaction. This should never happen */
  478. if ((cn = get_journal_hash_dev(p_s_sb, journal->j_hash_table, bl))) {
  479. BUG();
  480. return 1;
  481. }
  482. PROC_INFO_INC(p_s_sb, journal.in_journal_reusable);
  483. /* safe for reuse */
  484. return 0;
  485. }
  486. /* insert cn into table
  487. */
  488. static inline void insert_journal_hash(struct reiserfs_journal_cnode **table,
  489. struct reiserfs_journal_cnode *cn)
  490. {
  491. struct reiserfs_journal_cnode *cn_orig;
  492. cn_orig = journal_hash(table, cn->sb, cn->blocknr);
  493. cn->hnext = cn_orig;
  494. cn->hprev = NULL;
  495. if (cn_orig) {
  496. cn_orig->hprev = cn;
  497. }
  498. journal_hash(table, cn->sb, cn->blocknr) = cn;
  499. }
  500. /* lock the current transaction */
  501. static inline void lock_journal(struct super_block *p_s_sb)
  502. {
  503. PROC_INFO_INC(p_s_sb, journal.lock_journal);
  504. down(&SB_JOURNAL(p_s_sb)->j_lock);
  505. }
  506. /* unlock the current transaction */
  507. static inline void unlock_journal(struct super_block *p_s_sb)
  508. {
  509. up(&SB_JOURNAL(p_s_sb)->j_lock);
  510. }
  511. static inline void get_journal_list(struct reiserfs_journal_list *jl)
  512. {
  513. jl->j_refcount++;
  514. }
  515. static inline void put_journal_list(struct super_block *s,
  516. struct reiserfs_journal_list *jl)
  517. {
  518. if (jl->j_refcount < 1) {
  519. reiserfs_panic(s, "trans id %lu, refcount at %d",
  520. jl->j_trans_id, jl->j_refcount);
  521. }
  522. if (--jl->j_refcount == 0)
  523. kfree(jl);
  524. }
  525. /*
  526. ** this used to be much more involved, and I'm keeping it just in case things get ugly again.
  527. ** it gets called by flush_commit_list, and cleans up any data stored about blocks freed during a
  528. ** transaction.
  529. */
  530. static void cleanup_freed_for_journal_list(struct super_block *p_s_sb,
  531. struct reiserfs_journal_list *jl)
  532. {
  533. struct reiserfs_list_bitmap *jb = jl->j_list_bitmap;
  534. if (jb) {
  535. cleanup_bitmap_list(p_s_sb, jb);
  536. }
  537. jl->j_list_bitmap->journal_list = NULL;
  538. jl->j_list_bitmap = NULL;
  539. }
  540. static int journal_list_still_alive(struct super_block *s,
  541. unsigned long trans_id)
  542. {
  543. struct reiserfs_journal *journal = SB_JOURNAL(s);
  544. struct list_head *entry = &journal->j_journal_list;
  545. struct reiserfs_journal_list *jl;
  546. if (!list_empty(entry)) {
  547. jl = JOURNAL_LIST_ENTRY(entry->next);
  548. if (jl->j_trans_id <= trans_id) {
  549. return 1;
  550. }
  551. }
  552. return 0;
  553. }
  554. static void reiserfs_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
  555. {
  556. char b[BDEVNAME_SIZE];
  557. if (buffer_journaled(bh)) {
  558. reiserfs_warning(NULL,
  559. "clm-2084: pinned buffer %lu:%s sent to disk",
  560. bh->b_blocknr, bdevname(bh->b_bdev, b));
  561. }
  562. if (uptodate)
  563. set_buffer_uptodate(bh);
  564. else
  565. clear_buffer_uptodate(bh);
  566. unlock_buffer(bh);
  567. put_bh(bh);
  568. }
  569. static void reiserfs_end_ordered_io(struct buffer_head *bh, int uptodate)
  570. {
  571. if (uptodate)
  572. set_buffer_uptodate(bh);
  573. else
  574. clear_buffer_uptodate(bh);
  575. unlock_buffer(bh);
  576. put_bh(bh);
  577. }
  578. static void submit_logged_buffer(struct buffer_head *bh)
  579. {
  580. get_bh(bh);
  581. bh->b_end_io = reiserfs_end_buffer_io_sync;
  582. clear_buffer_journal_new(bh);
  583. clear_buffer_dirty(bh);
  584. if (!test_clear_buffer_journal_test(bh))
  585. BUG();
  586. if (!buffer_uptodate(bh))
  587. BUG();
  588. submit_bh(WRITE, bh);
  589. }
  590. static void submit_ordered_buffer(struct buffer_head *bh)
  591. {
  592. get_bh(bh);
  593. bh->b_end_io = reiserfs_end_ordered_io;
  594. clear_buffer_dirty(bh);
  595. if (!buffer_uptodate(bh))
  596. BUG();
  597. submit_bh(WRITE, bh);
  598. }
  599. static int submit_barrier_buffer(struct buffer_head *bh)
  600. {
  601. get_bh(bh);
  602. bh->b_end_io = reiserfs_end_ordered_io;
  603. clear_buffer_dirty(bh);
  604. if (!buffer_uptodate(bh))
  605. BUG();
  606. return submit_bh(WRITE_BARRIER, bh);
  607. }
  608. static void check_barrier_completion(struct super_block *s,
  609. struct buffer_head *bh)
  610. {
  611. if (buffer_eopnotsupp(bh)) {
  612. clear_buffer_eopnotsupp(bh);
  613. disable_barrier(s);
  614. set_buffer_uptodate(bh);
  615. set_buffer_dirty(bh);
  616. sync_dirty_buffer(bh);
  617. }
  618. }
  619. #define CHUNK_SIZE 32
  620. struct buffer_chunk {
  621. struct buffer_head *bh[CHUNK_SIZE];
  622. int nr;
  623. };
  624. static void write_chunk(struct buffer_chunk *chunk)
  625. {
  626. int i;
  627. get_fs_excl();
  628. for (i = 0; i < chunk->nr; i++) {
  629. submit_logged_buffer(chunk->bh[i]);
  630. }
  631. chunk->nr = 0;
  632. put_fs_excl();
  633. }
  634. static void write_ordered_chunk(struct buffer_chunk *chunk)
  635. {
  636. int i;
  637. get_fs_excl();
  638. for (i = 0; i < chunk->nr; i++) {
  639. submit_ordered_buffer(chunk->bh[i]);
  640. }
  641. chunk->nr = 0;
  642. put_fs_excl();
  643. }
  644. static int add_to_chunk(struct buffer_chunk *chunk, struct buffer_head *bh,
  645. spinlock_t * lock, void (fn) (struct buffer_chunk *))
  646. {
  647. int ret = 0;
  648. BUG_ON(chunk->nr >= CHUNK_SIZE);
  649. chunk->bh[chunk->nr++] = bh;
  650. if (chunk->nr >= CHUNK_SIZE) {
  651. ret = 1;
  652. if (lock)
  653. spin_unlock(lock);
  654. fn(chunk);
  655. if (lock)
  656. spin_lock(lock);
  657. }
  658. return ret;
  659. }
  660. static atomic_t nr_reiserfs_jh = ATOMIC_INIT(0);
  661. static struct reiserfs_jh *alloc_jh(void)
  662. {
  663. struct reiserfs_jh *jh;
  664. while (1) {
  665. jh = kmalloc(sizeof(*jh), GFP_NOFS);
  666. if (jh) {
  667. atomic_inc(&nr_reiserfs_jh);
  668. return jh;
  669. }
  670. yield();
  671. }
  672. }
  673. /*
  674. * we want to free the jh when the buffer has been written
  675. * and waited on
  676. */
  677. void reiserfs_free_jh(struct buffer_head *bh)
  678. {
  679. struct reiserfs_jh *jh;
  680. jh = bh->b_private;
  681. if (jh) {
  682. bh->b_private = NULL;
  683. jh->bh = NULL;
  684. list_del_init(&jh->list);
  685. kfree(jh);
  686. if (atomic_read(&nr_reiserfs_jh) <= 0)
  687. BUG();
  688. atomic_dec(&nr_reiserfs_jh);
  689. put_bh(bh);
  690. }
  691. }
  692. static inline int __add_jh(struct reiserfs_journal *j, struct buffer_head *bh,
  693. int tail)
  694. {
  695. struct reiserfs_jh *jh;
  696. if (bh->b_private) {
  697. spin_lock(&j->j_dirty_buffers_lock);
  698. if (!bh->b_private) {
  699. spin_unlock(&j->j_dirty_buffers_lock);
  700. goto no_jh;
  701. }
  702. jh = bh->b_private;
  703. list_del_init(&jh->list);
  704. } else {
  705. no_jh:
  706. get_bh(bh);
  707. jh = alloc_jh();
  708. spin_lock(&j->j_dirty_buffers_lock);
  709. /* buffer must be locked for __add_jh, should be able to have
  710. * two adds at the same time
  711. */
  712. BUG_ON(bh->b_private);
  713. jh->bh = bh;
  714. bh->b_private = jh;
  715. }
  716. jh->jl = j->j_current_jl;
  717. if (tail)
  718. list_add_tail(&jh->list, &jh->jl->j_tail_bh_list);
  719. else {
  720. list_add_tail(&jh->list, &jh->jl->j_bh_list);
  721. }
  722. spin_unlock(&j->j_dirty_buffers_lock);
  723. return 0;
  724. }
  725. int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh)
  726. {
  727. return __add_jh(SB_JOURNAL(inode->i_sb), bh, 1);
  728. }
  729. int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh)
  730. {
  731. return __add_jh(SB_JOURNAL(inode->i_sb), bh, 0);
  732. }
  733. #define JH_ENTRY(l) list_entry((l), struct reiserfs_jh, list)
  734. static int write_ordered_buffers(spinlock_t * lock,
  735. struct reiserfs_journal *j,
  736. struct reiserfs_journal_list *jl,
  737. struct list_head *list)
  738. {
  739. struct buffer_head *bh;
  740. struct reiserfs_jh *jh;
  741. int ret = j->j_errno;
  742. struct buffer_chunk chunk;
  743. struct list_head tmp;
  744. INIT_LIST_HEAD(&tmp);
  745. chunk.nr = 0;
  746. spin_lock(lock);
  747. while (!list_empty(list)) {
  748. jh = JH_ENTRY(list->next);
  749. bh = jh->bh;
  750. get_bh(bh);
  751. if (test_set_buffer_locked(bh)) {
  752. if (!buffer_dirty(bh)) {
  753. list_move(&jh->list, &tmp);
  754. goto loop_next;
  755. }
  756. spin_unlock(lock);
  757. if (chunk.nr)
  758. write_ordered_chunk(&chunk);
  759. wait_on_buffer(bh);
  760. cond_resched();
  761. spin_lock(lock);
  762. goto loop_next;
  763. }
  764. /* in theory, dirty non-uptodate buffers should never get here,
  765. * but the upper layer io error paths still have a few quirks.
  766. * Handle them here as gracefully as we can
  767. */
  768. if (!buffer_uptodate(bh) && buffer_dirty(bh)) {
  769. clear_buffer_dirty(bh);
  770. ret = -EIO;
  771. }
  772. if (buffer_dirty(bh)) {
  773. list_move(&jh->list, &tmp);
  774. add_to_chunk(&chunk, bh, lock, write_ordered_chunk);
  775. } else {
  776. reiserfs_free_jh(bh);
  777. unlock_buffer(bh);
  778. }
  779. loop_next:
  780. put_bh(bh);
  781. cond_resched_lock(lock);
  782. }
  783. if (chunk.nr) {
  784. spin_unlock(lock);
  785. write_ordered_chunk(&chunk);
  786. spin_lock(lock);
  787. }
  788. while (!list_empty(&tmp)) {
  789. jh = JH_ENTRY(tmp.prev);
  790. bh = jh->bh;
  791. get_bh(bh);
  792. reiserfs_free_jh(bh);
  793. if (buffer_locked(bh)) {
  794. spin_unlock(lock);
  795. wait_on_buffer(bh);
  796. spin_lock(lock);
  797. }
  798. if (!buffer_uptodate(bh)) {
  799. ret = -EIO;
  800. }
  801. /* ugly interaction with invalidatepage here.
  802. * reiserfs_invalidate_page will pin any buffer that has a valid
  803. * journal head from an older transaction. If someone else sets
  804. * our buffer dirty after we write it in the first loop, and
  805. * then someone truncates the page away, nobody will ever write
  806. * the buffer. We're safe if we write the page one last time
  807. * after freeing the journal header.
  808. */
  809. if (buffer_dirty(bh) && unlikely(bh->b_page->mapping == NULL)) {
  810. spin_unlock(lock);
  811. ll_rw_block(WRITE, 1, &bh);
  812. spin_lock(lock);
  813. }
  814. put_bh(bh);
  815. cond_resched_lock(lock);
  816. }
  817. spin_unlock(lock);
  818. return ret;
  819. }
  820. static int flush_older_commits(struct super_block *s,
  821. struct reiserfs_journal_list *jl)
  822. {
  823. struct reiserfs_journal *journal = SB_JOURNAL(s);
  824. struct reiserfs_journal_list *other_jl;
  825. struct reiserfs_journal_list *first_jl;
  826. struct list_head *entry;
  827. unsigned long trans_id = jl->j_trans_id;
  828. unsigned long other_trans_id;
  829. unsigned long first_trans_id;
  830. find_first:
  831. /*
  832. * first we walk backwards to find the oldest uncommitted transation
  833. */
  834. first_jl = jl;
  835. entry = jl->j_list.prev;
  836. while (1) {
  837. other_jl = JOURNAL_LIST_ENTRY(entry);
  838. if (entry == &journal->j_journal_list ||
  839. atomic_read(&other_jl->j_older_commits_done))
  840. break;
  841. first_jl = other_jl;
  842. entry = other_jl->j_list.prev;
  843. }
  844. /* if we didn't find any older uncommitted transactions, return now */
  845. if (first_jl == jl) {
  846. return 0;
  847. }
  848. first_trans_id = first_jl->j_trans_id;
  849. entry = &first_jl->j_list;
  850. while (1) {
  851. other_jl = JOURNAL_LIST_ENTRY(entry);
  852. other_trans_id = other_jl->j_trans_id;
  853. if (other_trans_id < trans_id) {
  854. if (atomic_read(&other_jl->j_commit_left) != 0) {
  855. flush_commit_list(s, other_jl, 0);
  856. /* list we were called with is gone, return */
  857. if (!journal_list_still_alive(s, trans_id))
  858. return 1;
  859. /* the one we just flushed is gone, this means all
  860. * older lists are also gone, so first_jl is no longer
  861. * valid either. Go back to the beginning.
  862. */
  863. if (!journal_list_still_alive
  864. (s, other_trans_id)) {
  865. goto find_first;
  866. }
  867. }
  868. entry = entry->next;
  869. if (entry == &journal->j_journal_list)
  870. return 0;
  871. } else {
  872. return 0;
  873. }
  874. }
  875. return 0;
  876. }
  877. int reiserfs_async_progress_wait(struct super_block *s)
  878. {
  879. DEFINE_WAIT(wait);
  880. struct reiserfs_journal *j = SB_JOURNAL(s);
  881. if (atomic_read(&j->j_async_throttle))
  882. congestion_wait(WRITE, HZ / 10);
  883. return 0;
  884. }
  885. /*
  886. ** if this journal list still has commit blocks unflushed, send them to disk.
  887. **
  888. ** log areas must be flushed in order (transaction 2 can't commit before transaction 1)
  889. ** Before the commit block can by written, every other log block must be safely on disk
  890. **
  891. */
  892. static int flush_commit_list(struct super_block *s,
  893. struct reiserfs_journal_list *jl, int flushall)
  894. {
  895. int i;
  896. int bn;
  897. struct buffer_head *tbh = NULL;
  898. unsigned long trans_id = jl->j_trans_id;
  899. struct reiserfs_journal *journal = SB_JOURNAL(s);
  900. int barrier = 0;
  901. int retval = 0;
  902. int write_len;
  903. reiserfs_check_lock_depth(s, "flush_commit_list");
  904. if (atomic_read(&jl->j_older_commits_done)) {
  905. return 0;
  906. }
  907. get_fs_excl();
  908. /* before we can put our commit blocks on disk, we have to make sure everyone older than
  909. ** us is on disk too
  910. */
  911. BUG_ON(jl->j_len <= 0);
  912. BUG_ON(trans_id == journal->j_trans_id);
  913. get_journal_list(jl);
  914. if (flushall) {
  915. if (flush_older_commits(s, jl) == 1) {
  916. /* list disappeared during flush_older_commits. return */
  917. goto put_jl;
  918. }
  919. }
  920. /* make sure nobody is trying to flush this one at the same time */
  921. down(&jl->j_commit_lock);
  922. if (!journal_list_still_alive(s, trans_id)) {
  923. up(&jl->j_commit_lock);
  924. goto put_jl;
  925. }
  926. BUG_ON(jl->j_trans_id == 0);
  927. /* this commit is done, exit */
  928. if (atomic_read(&(jl->j_commit_left)) <= 0) {
  929. if (flushall) {
  930. atomic_set(&(jl->j_older_commits_done), 1);
  931. }
  932. up(&jl->j_commit_lock);
  933. goto put_jl;
  934. }
  935. if (!list_empty(&jl->j_bh_list)) {
  936. int ret;
  937. unlock_kernel();
  938. ret = write_ordered_buffers(&journal->j_dirty_buffers_lock,
  939. journal, jl, &jl->j_bh_list);
  940. if (ret < 0 && retval == 0)
  941. retval = ret;
  942. lock_kernel();
  943. }
  944. BUG_ON(!list_empty(&jl->j_bh_list));
  945. /*
  946. * for the description block and all the log blocks, submit any buffers
  947. * that haven't already reached the disk. Try to write at least 256
  948. * log blocks. later on, we will only wait on blocks that correspond
  949. * to this transaction, but while we're unplugging we might as well
  950. * get a chunk of data on there.
  951. */
  952. atomic_inc(&journal->j_async_throttle);
  953. write_len = jl->j_len + 1;
  954. if (write_len < 256)
  955. write_len = 256;
  956. for (i = 0 ; i < write_len ; i++) {
  957. bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) + (jl->j_start + i) %
  958. SB_ONDISK_JOURNAL_SIZE(s);
  959. tbh = journal_find_get_block(s, bn);
  960. if (tbh) {
  961. if (buffer_dirty(tbh))
  962. ll_rw_block(WRITE, 1, &tbh) ;
  963. put_bh(tbh) ;
  964. }
  965. }
  966. atomic_dec(&journal->j_async_throttle);
  967. /* We're skipping the commit if there's an error */
  968. if (retval || reiserfs_is_journal_aborted(journal))
  969. barrier = 0;
  970. /* wait on everything written so far before writing the commit
  971. * if we are in barrier mode, send the commit down now
  972. */
  973. barrier = reiserfs_barrier_flush(s);
  974. if (barrier) {
  975. int ret;
  976. lock_buffer(jl->j_commit_bh);
  977. ret = submit_barrier_buffer(jl->j_commit_bh);
  978. if (ret == -EOPNOTSUPP) {
  979. set_buffer_uptodate(jl->j_commit_bh);
  980. disable_barrier(s);
  981. barrier = 0;
  982. }
  983. }
  984. for (i = 0; i < (jl->j_len + 1); i++) {
  985. bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) +
  986. (jl->j_start + i) % SB_ONDISK_JOURNAL_SIZE(s);
  987. tbh = journal_find_get_block(s, bn);
  988. wait_on_buffer(tbh);
  989. // since we're using ll_rw_blk above, it might have skipped over
  990. // a locked buffer. Double check here
  991. //
  992. if (buffer_dirty(tbh)) /* redundant, sync_dirty_buffer() checks */
  993. sync_dirty_buffer(tbh);
  994. if (unlikely(!buffer_uptodate(tbh))) {
  995. #ifdef CONFIG_REISERFS_CHECK
  996. reiserfs_warning(s, "journal-601, buffer write failed");
  997. #endif
  998. retval = -EIO;
  999. }
  1000. put_bh(tbh); /* once for journal_find_get_block */
  1001. put_bh(tbh); /* once due to original getblk in do_journal_end */
  1002. atomic_dec(&(jl->j_commit_left));
  1003. }
  1004. BUG_ON(atomic_read(&(jl->j_commit_left)) != 1);
  1005. if (!barrier) {
  1006. /* If there was a write error in the journal - we can't commit
  1007. * this transaction - it will be invalid and, if successful,
  1008. * will just end up propogating the write error out to
  1009. * the file system. */
  1010. if (likely(!retval && !reiserfs_is_journal_aborted (journal))) {
  1011. if (buffer_dirty(jl->j_commit_bh))
  1012. BUG();
  1013. mark_buffer_dirty(jl->j_commit_bh) ;
  1014. sync_dirty_buffer(jl->j_commit_bh) ;
  1015. }
  1016. } else
  1017. wait_on_buffer(jl->j_commit_bh);
  1018. check_barrier_completion(s, jl->j_commit_bh);
  1019. /* If there was a write error in the journal - we can't commit this
  1020. * transaction - it will be invalid and, if successful, will just end
  1021. * up propogating the write error out to the filesystem. */
  1022. if (unlikely(!buffer_uptodate(jl->j_commit_bh))) {
  1023. #ifdef CONFIG_REISERFS_CHECK
  1024. reiserfs_warning(s, "journal-615: buffer write failed");
  1025. #endif
  1026. retval = -EIO;
  1027. }
  1028. bforget(jl->j_commit_bh);
  1029. if (journal->j_last_commit_id != 0 &&
  1030. (jl->j_trans_id - journal->j_last_commit_id) != 1) {
  1031. reiserfs_warning(s, "clm-2200: last commit %lu, current %lu",
  1032. journal->j_last_commit_id, jl->j_trans_id);
  1033. }
  1034. journal->j_last_commit_id = jl->j_trans_id;
  1035. /* now, every commit block is on the disk. It is safe to allow blocks freed during this transaction to be reallocated */
  1036. cleanup_freed_for_journal_list(s, jl);
  1037. retval = retval ? retval : journal->j_errno;
  1038. /* mark the metadata dirty */
  1039. if (!retval)
  1040. dirty_one_transaction(s, jl);
  1041. atomic_dec(&(jl->j_commit_left));
  1042. if (flushall) {
  1043. atomic_set(&(jl->j_older_commits_done), 1);
  1044. }
  1045. up(&jl->j_commit_lock);
  1046. put_jl:
  1047. put_journal_list(s, jl);
  1048. if (retval)
  1049. reiserfs_abort(s, retval, "Journal write error in %s",
  1050. __FUNCTION__);
  1051. put_fs_excl();
  1052. return retval;
  1053. }
  1054. /*
  1055. ** flush_journal_list frequently needs to find a newer transaction for a given block. This does that, or
  1056. ** returns NULL if it can't find anything
  1057. */
  1058. static struct reiserfs_journal_list *find_newer_jl_for_cn(struct
  1059. reiserfs_journal_cnode
  1060. *cn)
  1061. {
  1062. struct super_block *sb = cn->sb;
  1063. b_blocknr_t blocknr = cn->blocknr;
  1064. cn = cn->hprev;
  1065. while (cn) {
  1066. if (cn->sb == sb && cn->blocknr == blocknr && cn->jlist) {
  1067. return cn->jlist;
  1068. }
  1069. cn = cn->hprev;
  1070. }
  1071. return NULL;
  1072. }
  1073. static int newer_jl_done(struct reiserfs_journal_cnode *cn)
  1074. {
  1075. struct super_block *sb = cn->sb;
  1076. b_blocknr_t blocknr = cn->blocknr;
  1077. cn = cn->hprev;
  1078. while (cn) {
  1079. if (cn->sb == sb && cn->blocknr == blocknr && cn->jlist &&
  1080. atomic_read(&cn->jlist->j_commit_left) != 0)
  1081. return 0;
  1082. cn = cn->hprev;
  1083. }
  1084. return 1;
  1085. }
  1086. static void remove_journal_hash(struct super_block *,
  1087. struct reiserfs_journal_cnode **,
  1088. struct reiserfs_journal_list *, unsigned long,
  1089. int);
  1090. /*
  1091. ** once all the real blocks have been flushed, it is safe to remove them from the
  1092. ** journal list for this transaction. Aside from freeing the cnode, this also allows the
  1093. ** block to be reallocated for data blocks if it had been deleted.
  1094. */
  1095. static void remove_all_from_journal_list(struct super_block *p_s_sb,
  1096. struct reiserfs_journal_list *jl,
  1097. int debug)
  1098. {
  1099. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  1100. struct reiserfs_journal_cnode *cn, *last;
  1101. cn = jl->j_realblock;
  1102. /* which is better, to lock once around the whole loop, or
  1103. ** to lock for each call to remove_journal_hash?
  1104. */
  1105. while (cn) {
  1106. if (cn->blocknr != 0) {
  1107. if (debug) {
  1108. reiserfs_warning(p_s_sb,
  1109. "block %u, bh is %d, state %ld",
  1110. cn->blocknr, cn->bh ? 1 : 0,
  1111. cn->state);
  1112. }
  1113. cn->state = 0;
  1114. remove_journal_hash(p_s_sb, journal->j_list_hash_table,
  1115. jl, cn->blocknr, 1);
  1116. }
  1117. last = cn;
  1118. cn = cn->next;
  1119. free_cnode(p_s_sb, last);
  1120. }
  1121. jl->j_realblock = NULL;
  1122. }
  1123. /*
  1124. ** if this timestamp is greater than the timestamp we wrote last to the header block, write it to the header block.
  1125. ** once this is done, I can safely say the log area for this transaction won't ever be replayed, and I can start
  1126. ** releasing blocks in this transaction for reuse as data blocks.
  1127. ** called by flush_journal_list, before it calls remove_all_from_journal_list
  1128. **
  1129. */
  1130. static int _update_journal_header_block(struct super_block *p_s_sb,
  1131. unsigned long offset,
  1132. unsigned long trans_id)
  1133. {
  1134. struct reiserfs_journal_header *jh;
  1135. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  1136. if (reiserfs_is_journal_aborted(journal))
  1137. return -EIO;
  1138. if (trans_id >= journal->j_last_flush_trans_id) {
  1139. if (buffer_locked((journal->j_header_bh))) {
  1140. wait_on_buffer((journal->j_header_bh));
  1141. if (unlikely(!buffer_uptodate(journal->j_header_bh))) {
  1142. #ifdef CONFIG_REISERFS_CHECK
  1143. reiserfs_warning(p_s_sb,
  1144. "journal-699: buffer write failed");
  1145. #endif
  1146. return -EIO;
  1147. }
  1148. }
  1149. journal->j_last_flush_trans_id = trans_id;
  1150. journal->j_first_unflushed_offset = offset;
  1151. jh = (struct reiserfs_journal_header *)(journal->j_header_bh->
  1152. b_data);
  1153. jh->j_last_flush_trans_id = cpu_to_le32(trans_id);
  1154. jh->j_first_unflushed_offset = cpu_to_le32(offset);
  1155. jh->j_mount_id = cpu_to_le32(journal->j_mount_id);
  1156. if (reiserfs_barrier_flush(p_s_sb)) {
  1157. int ret;
  1158. lock_buffer(journal->j_header_bh);
  1159. ret = submit_barrier_buffer(journal->j_header_bh);
  1160. if (ret == -EOPNOTSUPP) {
  1161. set_buffer_uptodate(journal->j_header_bh);
  1162. disable_barrier(p_s_sb);
  1163. goto sync;
  1164. }
  1165. wait_on_buffer(journal->j_header_bh);
  1166. check_barrier_completion(p_s_sb, journal->j_header_bh);
  1167. } else {
  1168. sync:
  1169. set_buffer_dirty(journal->j_header_bh);
  1170. sync_dirty_buffer(journal->j_header_bh);
  1171. }
  1172. if (!buffer_uptodate(journal->j_header_bh)) {
  1173. reiserfs_warning(p_s_sb,
  1174. "journal-837: IO error during journal replay");
  1175. return -EIO;
  1176. }
  1177. }
  1178. return 0;
  1179. }
  1180. static int update_journal_header_block(struct super_block *p_s_sb,
  1181. unsigned long offset,
  1182. unsigned long trans_id)
  1183. {
  1184. return _update_journal_header_block(p_s_sb, offset, trans_id);
  1185. }
  1186. /*
  1187. ** flush any and all journal lists older than you are
  1188. ** can only be called from flush_journal_list
  1189. */
  1190. static int flush_older_journal_lists(struct super_block *p_s_sb,
  1191. struct reiserfs_journal_list *jl)
  1192. {
  1193. struct list_head *entry;
  1194. struct reiserfs_journal_list *other_jl;
  1195. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  1196. unsigned long trans_id = jl->j_trans_id;
  1197. /* we know we are the only ones flushing things, no extra race
  1198. * protection is required.
  1199. */
  1200. restart:
  1201. entry = journal->j_journal_list.next;
  1202. /* Did we wrap? */
  1203. if (entry == &journal->j_journal_list)
  1204. return 0;
  1205. other_jl = JOURNAL_LIST_ENTRY(entry);
  1206. if (other_jl->j_trans_id < trans_id) {
  1207. BUG_ON(other_jl->j_refcount <= 0);
  1208. /* do not flush all */
  1209. flush_journal_list(p_s_sb, other_jl, 0);
  1210. /* other_jl is now deleted from the list */
  1211. goto restart;
  1212. }
  1213. return 0;
  1214. }
  1215. static void del_from_work_list(struct super_block *s,
  1216. struct reiserfs_journal_list *jl)
  1217. {
  1218. struct reiserfs_journal *journal = SB_JOURNAL(s);
  1219. if (!list_empty(&jl->j_working_list)) {
  1220. list_del_init(&jl->j_working_list);
  1221. journal->j_num_work_lists--;
  1222. }
  1223. }
  1224. /* flush a journal list, both commit and real blocks
  1225. **
  1226. ** always set flushall to 1, unless you are calling from inside
  1227. ** flush_journal_list
  1228. **
  1229. ** IMPORTANT. This can only be called while there are no journal writers,
  1230. ** and the journal is locked. That means it can only be called from
  1231. ** do_journal_end, or by journal_release
  1232. */
  1233. static int flush_journal_list(struct super_block *s,
  1234. struct reiserfs_journal_list *jl, int flushall)
  1235. {
  1236. struct reiserfs_journal_list *pjl;
  1237. struct reiserfs_journal_cnode *cn, *last;
  1238. int count;
  1239. int was_jwait = 0;
  1240. int was_dirty = 0;
  1241. struct buffer_head *saved_bh;
  1242. unsigned long j_len_saved = jl->j_len;
  1243. struct reiserfs_journal *journal = SB_JOURNAL(s);
  1244. int err = 0;
  1245. BUG_ON(j_len_saved <= 0);
  1246. if (atomic_read(&journal->j_wcount) != 0) {
  1247. reiserfs_warning(s,
  1248. "clm-2048: flush_journal_list called with wcount %d",
  1249. atomic_read(&journal->j_wcount));
  1250. }
  1251. BUG_ON(jl->j_trans_id == 0);
  1252. /* if flushall == 0, the lock is already held */
  1253. if (flushall) {
  1254. down(&journal->j_flush_sem);
  1255. } else if (!down_trylock(&journal->j_flush_sem)) {
  1256. BUG();
  1257. }
  1258. count = 0;
  1259. if (j_len_saved > journal->j_trans_max) {
  1260. reiserfs_panic(s,
  1261. "journal-715: flush_journal_list, length is %lu, trans id %lu\n",
  1262. j_len_saved, jl->j_trans_id);
  1263. return 0;
  1264. }
  1265. get_fs_excl();
  1266. /* if all the work is already done, get out of here */
  1267. if (atomic_read(&(jl->j_nonzerolen)) <= 0 &&
  1268. atomic_read(&(jl->j_commit_left)) <= 0) {
  1269. goto flush_older_and_return;
  1270. }
  1271. /* start by putting the commit list on disk. This will also flush
  1272. ** the commit lists of any olders transactions
  1273. */
  1274. flush_commit_list(s, jl, 1);
  1275. if (!(jl->j_state & LIST_DIRTY)
  1276. && !reiserfs_is_journal_aborted(journal))
  1277. BUG();
  1278. /* are we done now? */
  1279. if (atomic_read(&(jl->j_nonzerolen)) <= 0 &&
  1280. atomic_read(&(jl->j_commit_left)) <= 0) {
  1281. goto flush_older_and_return;
  1282. }
  1283. /* loop through each cnode, see if we need to write it,
  1284. ** or wait on a more recent transaction, or just ignore it
  1285. */
  1286. if (atomic_read(&(journal->j_wcount)) != 0) {
  1287. reiserfs_panic(s,
  1288. "journal-844: panic journal list is flushing, wcount is not 0\n");
  1289. }
  1290. cn = jl->j_realblock;
  1291. while (cn) {
  1292. was_jwait = 0;
  1293. was_dirty = 0;
  1294. saved_bh = NULL;
  1295. /* blocknr of 0 is no longer in the hash, ignore it */
  1296. if (cn->blocknr == 0) {
  1297. goto free_cnode;
  1298. }
  1299. /* This transaction failed commit. Don't write out to the disk */
  1300. if (!(jl->j_state & LIST_DIRTY))
  1301. goto free_cnode;
  1302. pjl = find_newer_jl_for_cn(cn);
  1303. /* the order is important here. We check pjl to make sure we
  1304. ** don't clear BH_JDirty_wait if we aren't the one writing this
  1305. ** block to disk
  1306. */
  1307. if (!pjl && cn->bh) {
  1308. saved_bh = cn->bh;
  1309. /* we do this to make sure nobody releases the buffer while
  1310. ** we are working with it
  1311. */
  1312. get_bh(saved_bh);
  1313. if (buffer_journal_dirty(saved_bh)) {
  1314. BUG_ON(!can_dirty(cn));
  1315. was_jwait = 1;
  1316. was_dirty = 1;
  1317. } else if (can_dirty(cn)) {
  1318. /* everything with !pjl && jwait should be writable */
  1319. BUG();
  1320. }
  1321. }
  1322. /* if someone has this block in a newer transaction, just make
  1323. ** sure they are committed, and don't try writing it to disk
  1324. */
  1325. if (pjl) {
  1326. if (atomic_read(&pjl->j_commit_left))
  1327. flush_commit_list(s, pjl, 1);
  1328. goto free_cnode;
  1329. }
  1330. /* bh == NULL when the block got to disk on its own, OR,
  1331. ** the block got freed in a future transaction
  1332. */
  1333. if (saved_bh == NULL) {
  1334. goto free_cnode;
  1335. }
  1336. /* this should never happen. kupdate_one_transaction has this list
  1337. ** locked while it works, so we should never see a buffer here that
  1338. ** is not marked JDirty_wait
  1339. */
  1340. if ((!was_jwait) && !buffer_locked(saved_bh)) {
  1341. reiserfs_warning(s,
  1342. "journal-813: BAD! buffer %llu %cdirty %cjwait, "
  1343. "not in a newer tranasction",
  1344. (unsigned long long)saved_bh->
  1345. b_blocknr, was_dirty ? ' ' : '!',
  1346. was_jwait ? ' ' : '!');
  1347. }
  1348. if (was_dirty) {
  1349. /* we inc again because saved_bh gets decremented at free_cnode */
  1350. get_bh(saved_bh);
  1351. set_bit(BLOCK_NEEDS_FLUSH, &cn->state);
  1352. lock_buffer(saved_bh);
  1353. BUG_ON(cn->blocknr != saved_bh->b_blocknr);
  1354. if (buffer_dirty(saved_bh))
  1355. submit_logged_buffer(saved_bh);
  1356. else
  1357. unlock_buffer(saved_bh);
  1358. count++;
  1359. } else {
  1360. reiserfs_warning(s,
  1361. "clm-2082: Unable to flush buffer %llu in %s",
  1362. (unsigned long long)saved_bh->
  1363. b_blocknr, __FUNCTION__);
  1364. }
  1365. free_cnode:
  1366. last = cn;
  1367. cn = cn->next;
  1368. if (saved_bh) {
  1369. /* we incremented this to keep others from taking the buffer head away */
  1370. put_bh(saved_bh);
  1371. if (atomic_read(&(saved_bh->b_count)) < 0) {
  1372. reiserfs_warning(s,
  1373. "journal-945: saved_bh->b_count < 0");
  1374. }
  1375. }
  1376. }
  1377. if (count > 0) {
  1378. cn = jl->j_realblock;
  1379. while (cn) {
  1380. if (test_bit(BLOCK_NEEDS_FLUSH, &cn->state)) {
  1381. if (!cn->bh) {
  1382. reiserfs_panic(s,
  1383. "journal-1011: cn->bh is NULL\n");
  1384. }
  1385. wait_on_buffer(cn->bh);
  1386. if (!cn->bh) {
  1387. reiserfs_panic(s,
  1388. "journal-1012: cn->bh is NULL\n");
  1389. }
  1390. if (unlikely(!buffer_uptodate(cn->bh))) {
  1391. #ifdef CONFIG_REISERFS_CHECK
  1392. reiserfs_warning(s,
  1393. "journal-949: buffer write failed\n");
  1394. #endif
  1395. err = -EIO;
  1396. }
  1397. /* note, we must clear the JDirty_wait bit after the up to date
  1398. ** check, otherwise we race against our flushpage routine
  1399. */
  1400. BUG_ON(!test_clear_buffer_journal_dirty
  1401. (cn->bh));
  1402. /* undo the inc from journal_mark_dirty */
  1403. put_bh(cn->bh);
  1404. brelse(cn->bh);
  1405. }
  1406. cn = cn->next;
  1407. }
  1408. }
  1409. if (err)
  1410. reiserfs_abort(s, -EIO,
  1411. "Write error while pushing transaction to disk in %s",
  1412. __FUNCTION__);
  1413. flush_older_and_return:
  1414. /* before we can update the journal header block, we _must_ flush all
  1415. ** real blocks from all older transactions to disk. This is because
  1416. ** once the header block is updated, this transaction will not be
  1417. ** replayed after a crash
  1418. */
  1419. if (flushall) {
  1420. flush_older_journal_lists(s, jl);
  1421. }
  1422. err = journal->j_errno;
  1423. /* before we can remove everything from the hash tables for this
  1424. ** transaction, we must make sure it can never be replayed
  1425. **
  1426. ** since we are only called from do_journal_end, we know for sure there
  1427. ** are no allocations going on while we are flushing journal lists. So,
  1428. ** we only need to update the journal header block for the last list
  1429. ** being flushed
  1430. */
  1431. if (!err && flushall) {
  1432. err =
  1433. update_journal_header_block(s,
  1434. (jl->j_start + jl->j_len +
  1435. 2) % SB_ONDISK_JOURNAL_SIZE(s),
  1436. jl->j_trans_id);
  1437. if (err)
  1438. reiserfs_abort(s, -EIO,
  1439. "Write error while updating journal header in %s",
  1440. __FUNCTION__);
  1441. }
  1442. remove_all_from_journal_list(s, jl, 0);
  1443. list_del_init(&jl->j_list);
  1444. journal->j_num_lists--;
  1445. del_from_work_list(s, jl);
  1446. if (journal->j_last_flush_id != 0 &&
  1447. (jl->j_trans_id - journal->j_last_flush_id) != 1) {
  1448. reiserfs_warning(s, "clm-2201: last flush %lu, current %lu",
  1449. journal->j_last_flush_id, jl->j_trans_id);
  1450. }
  1451. journal->j_last_flush_id = jl->j_trans_id;
  1452. /* not strictly required since we are freeing the list, but it should
  1453. * help find code using dead lists later on
  1454. */
  1455. jl->j_len = 0;
  1456. atomic_set(&(jl->j_nonzerolen), 0);
  1457. jl->j_start = 0;
  1458. jl->j_realblock = NULL;
  1459. jl->j_commit_bh = NULL;
  1460. jl->j_trans_id = 0;
  1461. jl->j_state = 0;
  1462. put_journal_list(s, jl);
  1463. if (flushall)
  1464. up(&journal->j_flush_sem);
  1465. put_fs_excl();
  1466. return err;
  1467. }
  1468. static int test_transaction(struct super_block *s,
  1469. struct reiserfs_journal_list *jl)
  1470. {
  1471. struct reiserfs_journal_cnode *cn;
  1472. if (jl->j_len == 0 || atomic_read(&jl->j_nonzerolen) == 0)
  1473. return 1;
  1474. cn = jl->j_realblock;
  1475. while (cn) {
  1476. /* if the blocknr == 0, this has been cleared from the hash,
  1477. ** skip it
  1478. */
  1479. if (cn->blocknr == 0) {
  1480. goto next;
  1481. }
  1482. if (cn->bh && !newer_jl_done(cn))
  1483. return 0;
  1484. next:
  1485. cn = cn->next;
  1486. cond_resched();
  1487. }
  1488. return 0;
  1489. }
  1490. static int write_one_transaction(struct super_block *s,
  1491. struct reiserfs_journal_list *jl,
  1492. struct buffer_chunk *chunk)
  1493. {
  1494. struct reiserfs_journal_cnode *cn;
  1495. int ret = 0;
  1496. jl->j_state |= LIST_TOUCHED;
  1497. del_from_work_list(s, jl);
  1498. if (jl->j_len == 0 || atomic_read(&jl->j_nonzerolen) == 0) {
  1499. return 0;
  1500. }
  1501. cn = jl->j_realblock;
  1502. while (cn) {
  1503. /* if the blocknr == 0, this has been cleared from the hash,
  1504. ** skip it
  1505. */
  1506. if (cn->blocknr == 0) {
  1507. goto next;
  1508. }
  1509. if (cn->bh && can_dirty(cn) && buffer_dirty(cn->bh)) {
  1510. struct buffer_head *tmp_bh;
  1511. /* we can race against journal_mark_freed when we try
  1512. * to lock_buffer(cn->bh), so we have to inc the buffer
  1513. * count, and recheck things after locking
  1514. */
  1515. tmp_bh = cn->bh;
  1516. get_bh(tmp_bh);
  1517. lock_buffer(tmp_bh);
  1518. if (cn->bh && can_dirty(cn) && buffer_dirty(tmp_bh)) {
  1519. if (!buffer_journal_dirty(tmp_bh) ||
  1520. buffer_journal_prepared(tmp_bh))
  1521. BUG();
  1522. add_to_chunk(chunk, tmp_bh, NULL, write_chunk);
  1523. ret++;
  1524. } else {
  1525. /* note, cn->bh might be null now */
  1526. unlock_buffer(tmp_bh);
  1527. }
  1528. put_bh(tmp_bh);
  1529. }
  1530. next:
  1531. cn = cn->next;
  1532. cond_resched();
  1533. }
  1534. return ret;
  1535. }
  1536. /* used by flush_commit_list */
  1537. static int dirty_one_transaction(struct super_block *s,
  1538. struct reiserfs_journal_list *jl)
  1539. {
  1540. struct reiserfs_journal_cnode *cn;
  1541. struct reiserfs_journal_list *pjl;
  1542. int ret = 0;
  1543. jl->j_state |= LIST_DIRTY;
  1544. cn = jl->j_realblock;
  1545. while (cn) {
  1546. /* look for a more recent transaction that logged this
  1547. ** buffer. Only the most recent transaction with a buffer in
  1548. ** it is allowed to send that buffer to disk
  1549. */
  1550. pjl = find_newer_jl_for_cn(cn);
  1551. if (!pjl && cn->blocknr && cn->bh
  1552. && buffer_journal_dirty(cn->bh)) {
  1553. BUG_ON(!can_dirty(cn));
  1554. /* if the buffer is prepared, it will either be logged
  1555. * or restored. If restored, we need to make sure
  1556. * it actually gets marked dirty
  1557. */
  1558. clear_buffer_journal_new(cn->bh);
  1559. if (buffer_journal_prepared(cn->bh)) {
  1560. set_buffer_journal_restore_dirty(cn->bh);
  1561. } else {
  1562. set_buffer_journal_test(cn->bh);
  1563. mark_buffer_dirty(cn->bh);
  1564. }
  1565. }
  1566. cn = cn->next;
  1567. }
  1568. return ret;
  1569. }
  1570. static int kupdate_transactions(struct super_block *s,
  1571. struct reiserfs_journal_list *jl,
  1572. struct reiserfs_journal_list **next_jl,
  1573. unsigned long *next_trans_id,
  1574. int num_blocks, int num_trans)
  1575. {
  1576. int ret = 0;
  1577. int written = 0;
  1578. int transactions_flushed = 0;
  1579. unsigned long orig_trans_id = jl->j_trans_id;
  1580. struct buffer_chunk chunk;
  1581. struct list_head *entry;
  1582. struct reiserfs_journal *journal = SB_JOURNAL(s);
  1583. chunk.nr = 0;
  1584. down(&journal->j_flush_sem);
  1585. if (!journal_list_still_alive(s, orig_trans_id)) {
  1586. goto done;
  1587. }
  1588. /* we've got j_flush_sem held, nobody is going to delete any
  1589. * of these lists out from underneath us
  1590. */
  1591. while ((num_trans && transactions_flushed < num_trans) ||
  1592. (!num_trans && written < num_blocks)) {
  1593. if (jl->j_len == 0 || (jl->j_state & LIST_TOUCHED) ||
  1594. atomic_read(&jl->j_commit_left)
  1595. || !(jl->j_state & LIST_DIRTY)) {
  1596. del_from_work_list(s, jl);
  1597. break;
  1598. }
  1599. ret = write_one_transaction(s, jl, &chunk);
  1600. if (ret < 0)
  1601. goto done;
  1602. transactions_flushed++;
  1603. written += ret;
  1604. entry = jl->j_list.next;
  1605. /* did we wrap? */
  1606. if (entry == &journal->j_journal_list) {
  1607. break;
  1608. }
  1609. jl = JOURNAL_LIST_ENTRY(entry);
  1610. /* don't bother with older transactions */
  1611. if (jl->j_trans_id <= orig_trans_id)
  1612. break;
  1613. }
  1614. if (chunk.nr) {
  1615. write_chunk(&chunk);
  1616. }
  1617. done:
  1618. up(&journal->j_flush_sem);
  1619. return ret;
  1620. }
  1621. /* for o_sync and fsync heavy applications, they tend to use
  1622. ** all the journa list slots with tiny transactions. These
  1623. ** trigger lots and lots of calls to update the header block, which
  1624. ** adds seeks and slows things down.
  1625. **
  1626. ** This function tries to clear out a large chunk of the journal lists
  1627. ** at once, which makes everything faster since only the newest journal
  1628. ** list updates the header block
  1629. */
  1630. static int flush_used_journal_lists(struct super_block *s,
  1631. struct reiserfs_journal_list *jl)
  1632. {
  1633. unsigned long len = 0;
  1634. unsigned long cur_len;
  1635. int ret;
  1636. int i;
  1637. int limit = 256;
  1638. struct reiserfs_journal_list *tjl;
  1639. struct reiserfs_journal_list *flush_jl;
  1640. unsigned long trans_id;
  1641. struct reiserfs_journal *journal = SB_JOURNAL(s);
  1642. flush_jl = tjl = jl;
  1643. /* in data logging mode, try harder to flush a lot of blocks */
  1644. if (reiserfs_data_log(s))
  1645. limit = 1024;
  1646. /* flush for 256 transactions or limit blocks, whichever comes first */
  1647. for (i = 0; i < 256 && len < limit; i++) {
  1648. if (atomic_read(&tjl->j_commit_left) ||
  1649. tjl->j_trans_id < jl->j_trans_id) {
  1650. break;
  1651. }
  1652. cur_len = atomic_read(&tjl->j_nonzerolen);
  1653. if (cur_len > 0) {
  1654. tjl->j_state &= ~LIST_TOUCHED;
  1655. }
  1656. len += cur_len;
  1657. flush_jl = tjl;
  1658. if (tjl->j_list.next == &journal->j_journal_list)
  1659. break;
  1660. tjl = JOURNAL_LIST_ENTRY(tjl->j_list.next);
  1661. }
  1662. /* try to find a group of blocks we can flush across all the
  1663. ** transactions, but only bother if we've actually spanned
  1664. ** across multiple lists
  1665. */
  1666. if (flush_jl != jl) {
  1667. ret = kupdate_transactions(s, jl, &tjl, &trans_id, len, i);
  1668. }
  1669. flush_journal_list(s, flush_jl, 1);
  1670. return 0;
  1671. }
  1672. /*
  1673. ** removes any nodes in table with name block and dev as bh.
  1674. ** only touchs the hnext and hprev pointers.
  1675. */
  1676. void remove_journal_hash(struct super_block *sb,
  1677. struct reiserfs_journal_cnode **table,
  1678. struct reiserfs_journal_list *jl,
  1679. unsigned long block, int remove_freed)
  1680. {
  1681. struct reiserfs_journal_cnode *cur;
  1682. struct reiserfs_journal_cnode **head;
  1683. head = &(journal_hash(table, sb, block));
  1684. if (!head) {
  1685. return;
  1686. }
  1687. cur = *head;
  1688. while (cur) {
  1689. if (cur->blocknr == block && cur->sb == sb
  1690. && (jl == NULL || jl == cur->jlist)
  1691. && (!test_bit(BLOCK_FREED, &cur->state) || remove_freed)) {
  1692. if (cur->hnext) {
  1693. cur->hnext->hprev = cur->hprev;
  1694. }
  1695. if (cur->hprev) {
  1696. cur->hprev->hnext = cur->hnext;
  1697. } else {
  1698. *head = cur->hnext;
  1699. }
  1700. cur->blocknr = 0;
  1701. cur->sb = NULL;
  1702. cur->state = 0;
  1703. if (cur->bh && cur->jlist) /* anybody who clears the cur->bh will also dec the nonzerolen */
  1704. atomic_dec(&(cur->jlist->j_nonzerolen));
  1705. cur->bh = NULL;
  1706. cur->jlist = NULL;
  1707. }
  1708. cur = cur->hnext;
  1709. }
  1710. }
  1711. static void free_journal_ram(struct super_block *p_s_sb)
  1712. {
  1713. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  1714. kfree(journal->j_current_jl);
  1715. journal->j_num_lists--;
  1716. vfree(journal->j_cnode_free_orig);
  1717. free_list_bitmaps(p_s_sb, journal->j_list_bitmap);
  1718. free_bitmap_nodes(p_s_sb); /* must be after free_list_bitmaps */
  1719. if (journal->j_header_bh) {
  1720. brelse(journal->j_header_bh);
  1721. }
  1722. /* j_header_bh is on the journal dev, make sure not to release the journal
  1723. * dev until we brelse j_header_bh
  1724. */
  1725. release_journal_dev(p_s_sb, journal);
  1726. vfree(journal);
  1727. }
  1728. /*
  1729. ** call on unmount. Only set error to 1 if you haven't made your way out
  1730. ** of read_super() yet. Any other caller must keep error at 0.
  1731. */
  1732. static int do_journal_release(struct reiserfs_transaction_handle *th,
  1733. struct super_block *p_s_sb, int error)
  1734. {
  1735. struct reiserfs_transaction_handle myth;
  1736. int flushed = 0;
  1737. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  1738. /* we only want to flush out transactions if we were called with error == 0
  1739. */
  1740. if (!error && !(p_s_sb->s_flags & MS_RDONLY)) {
  1741. /* end the current trans */
  1742. BUG_ON(!th->t_trans_id);
  1743. do_journal_end(th, p_s_sb, 10, FLUSH_ALL);
  1744. /* make sure something gets logged to force our way into the flush code */
  1745. if (!journal_join(&myth, p_s_sb, 1)) {
  1746. reiserfs_prepare_for_journal(p_s_sb,
  1747. SB_BUFFER_WITH_SB(p_s_sb),
  1748. 1);
  1749. journal_mark_dirty(&myth, p_s_sb,
  1750. SB_BUFFER_WITH_SB(p_s_sb));
  1751. do_journal_end(&myth, p_s_sb, 1, FLUSH_ALL);
  1752. flushed = 1;
  1753. }
  1754. }
  1755. /* this also catches errors during the do_journal_end above */
  1756. if (!error && reiserfs_is_journal_aborted(journal)) {
  1757. memset(&myth, 0, sizeof(myth));
  1758. if (!journal_join_abort(&myth, p_s_sb, 1)) {
  1759. reiserfs_prepare_for_journal(p_s_sb,
  1760. SB_BUFFER_WITH_SB(p_s_sb),
  1761. 1);
  1762. journal_mark_dirty(&myth, p_s_sb,
  1763. SB_BUFFER_WITH_SB(p_s_sb));
  1764. do_journal_end(&myth, p_s_sb, 1, FLUSH_ALL);
  1765. }
  1766. }
  1767. reiserfs_mounted_fs_count--;
  1768. /* wait for all commits to finish */
  1769. cancel_delayed_work(&SB_JOURNAL(p_s_sb)->j_work);
  1770. flush_workqueue(commit_wq);
  1771. if (!reiserfs_mounted_fs_count) {
  1772. destroy_workqueue(commit_wq);
  1773. commit_wq = NULL;
  1774. }
  1775. free_journal_ram(p_s_sb);
  1776. return 0;
  1777. }
  1778. /*
  1779. ** call on unmount. flush all journal trans, release all alloc'd ram
  1780. */
  1781. int journal_release(struct reiserfs_transaction_handle *th,
  1782. struct super_block *p_s_sb)
  1783. {
  1784. return do_journal_release(th, p_s_sb, 0);
  1785. }
  1786. /*
  1787. ** only call from an error condition inside reiserfs_read_super!
  1788. */
  1789. int journal_release_error(struct reiserfs_transaction_handle *th,
  1790. struct super_block *p_s_sb)
  1791. {
  1792. return do_journal_release(th, p_s_sb, 1);
  1793. }
  1794. /* compares description block with commit block. returns 1 if they differ, 0 if they are the same */
  1795. static int journal_compare_desc_commit(struct super_block *p_s_sb,
  1796. struct reiserfs_journal_desc *desc,
  1797. struct reiserfs_journal_commit *commit)
  1798. {
  1799. if (get_commit_trans_id(commit) != get_desc_trans_id(desc) ||
  1800. get_commit_trans_len(commit) != get_desc_trans_len(desc) ||
  1801. get_commit_trans_len(commit) > SB_JOURNAL(p_s_sb)->j_trans_max ||
  1802. get_commit_trans_len(commit) <= 0) {
  1803. return 1;
  1804. }
  1805. return 0;
  1806. }
  1807. /* returns 0 if it did not find a description block
  1808. ** returns -1 if it found a corrupt commit block
  1809. ** returns 1 if both desc and commit were valid
  1810. */
  1811. static int journal_transaction_is_valid(struct super_block *p_s_sb,
  1812. struct buffer_head *d_bh,
  1813. unsigned long *oldest_invalid_trans_id,
  1814. unsigned long *newest_mount_id)
  1815. {
  1816. struct reiserfs_journal_desc *desc;
  1817. struct reiserfs_journal_commit *commit;
  1818. struct buffer_head *c_bh;
  1819. unsigned long offset;
  1820. if (!d_bh)
  1821. return 0;
  1822. desc = (struct reiserfs_journal_desc *)d_bh->b_data;
  1823. if (get_desc_trans_len(desc) > 0
  1824. && !memcmp(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8)) {
  1825. if (oldest_invalid_trans_id && *oldest_invalid_trans_id
  1826. && get_desc_trans_id(desc) > *oldest_invalid_trans_id) {
  1827. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  1828. "journal-986: transaction "
  1829. "is valid returning because trans_id %d is greater than "
  1830. "oldest_invalid %lu",
  1831. get_desc_trans_id(desc),
  1832. *oldest_invalid_trans_id);
  1833. return 0;
  1834. }
  1835. if (newest_mount_id
  1836. && *newest_mount_id > get_desc_mount_id(desc)) {
  1837. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  1838. "journal-1087: transaction "
  1839. "is valid returning because mount_id %d is less than "
  1840. "newest_mount_id %lu",
  1841. get_desc_mount_id(desc),
  1842. *newest_mount_id);
  1843. return -1;
  1844. }
  1845. if (get_desc_trans_len(desc) > SB_JOURNAL(p_s_sb)->j_trans_max) {
  1846. reiserfs_warning(p_s_sb,
  1847. "journal-2018: Bad transaction length %d encountered, ignoring transaction",
  1848. get_desc_trans_len(desc));
  1849. return -1;
  1850. }
  1851. offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb);
  1852. /* ok, we have a journal description block, lets see if the transaction was valid */
  1853. c_bh =
  1854. journal_bread(p_s_sb,
  1855. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  1856. ((offset + get_desc_trans_len(desc) +
  1857. 1) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)));
  1858. if (!c_bh)
  1859. return 0;
  1860. commit = (struct reiserfs_journal_commit *)c_bh->b_data;
  1861. if (journal_compare_desc_commit(p_s_sb, desc, commit)) {
  1862. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  1863. "journal_transaction_is_valid, commit offset %ld had bad "
  1864. "time %d or length %d",
  1865. c_bh->b_blocknr -
  1866. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb),
  1867. get_commit_trans_id(commit),
  1868. get_commit_trans_len(commit));
  1869. brelse(c_bh);
  1870. if (oldest_invalid_trans_id) {
  1871. *oldest_invalid_trans_id =
  1872. get_desc_trans_id(desc);
  1873. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  1874. "journal-1004: "
  1875. "transaction_is_valid setting oldest invalid trans_id "
  1876. "to %d",
  1877. get_desc_trans_id(desc));
  1878. }
  1879. return -1;
  1880. }
  1881. brelse(c_bh);
  1882. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  1883. "journal-1006: found valid "
  1884. "transaction start offset %llu, len %d id %d",
  1885. d_bh->b_blocknr -
  1886. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb),
  1887. get_desc_trans_len(desc),
  1888. get_desc_trans_id(desc));
  1889. return 1;
  1890. } else {
  1891. return 0;
  1892. }
  1893. }
  1894. static void brelse_array(struct buffer_head **heads, int num)
  1895. {
  1896. int i;
  1897. for (i = 0; i < num; i++) {
  1898. brelse(heads[i]);
  1899. }
  1900. }
  1901. /*
  1902. ** given the start, and values for the oldest acceptable transactions,
  1903. ** this either reads in a replays a transaction, or returns because the transaction
  1904. ** is invalid, or too old.
  1905. */
  1906. static int journal_read_transaction(struct super_block *p_s_sb,
  1907. unsigned long cur_dblock,
  1908. unsigned long oldest_start,
  1909. unsigned long oldest_trans_id,
  1910. unsigned long newest_mount_id)
  1911. {
  1912. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  1913. struct reiserfs_journal_desc *desc;
  1914. struct reiserfs_journal_commit *commit;
  1915. unsigned long trans_id = 0;
  1916. struct buffer_head *c_bh;
  1917. struct buffer_head *d_bh;
  1918. struct buffer_head **log_blocks = NULL;
  1919. struct buffer_head **real_blocks = NULL;
  1920. unsigned long trans_offset;
  1921. int i;
  1922. int trans_half;
  1923. d_bh = journal_bread(p_s_sb, cur_dblock);
  1924. if (!d_bh)
  1925. return 1;
  1926. desc = (struct reiserfs_journal_desc *)d_bh->b_data;
  1927. trans_offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb);
  1928. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1037: "
  1929. "journal_read_transaction, offset %llu, len %d mount_id %d",
  1930. d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb),
  1931. get_desc_trans_len(desc), get_desc_mount_id(desc));
  1932. if (get_desc_trans_id(desc) < oldest_trans_id) {
  1933. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1039: "
  1934. "journal_read_trans skipping because %lu is too old",
  1935. cur_dblock -
  1936. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb));
  1937. brelse(d_bh);
  1938. return 1;
  1939. }
  1940. if (get_desc_mount_id(desc) != newest_mount_id) {
  1941. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1146: "
  1942. "journal_read_trans skipping because %d is != "
  1943. "newest_mount_id %lu", get_desc_mount_id(desc),
  1944. newest_mount_id);
  1945. brelse(d_bh);
  1946. return 1;
  1947. }
  1948. c_bh = journal_bread(p_s_sb, SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  1949. ((trans_offset + get_desc_trans_len(desc) + 1) %
  1950. SB_ONDISK_JOURNAL_SIZE(p_s_sb)));
  1951. if (!c_bh) {
  1952. brelse(d_bh);
  1953. return 1;
  1954. }
  1955. commit = (struct reiserfs_journal_commit *)c_bh->b_data;
  1956. if (journal_compare_desc_commit(p_s_sb, desc, commit)) {
  1957. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  1958. "journal_read_transaction, "
  1959. "commit offset %llu had bad time %d or length %d",
  1960. c_bh->b_blocknr -
  1961. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb),
  1962. get_commit_trans_id(commit),
  1963. get_commit_trans_len(commit));
  1964. brelse(c_bh);
  1965. brelse(d_bh);
  1966. return 1;
  1967. }
  1968. trans_id = get_desc_trans_id(desc);
  1969. /* now we know we've got a good transaction, and it was inside the valid time ranges */
  1970. log_blocks = kmalloc(get_desc_trans_len(desc) *
  1971. sizeof(struct buffer_head *), GFP_NOFS);
  1972. real_blocks = kmalloc(get_desc_trans_len(desc) *
  1973. sizeof(struct buffer_head *), GFP_NOFS);
  1974. if (!log_blocks || !real_blocks) {
  1975. brelse(c_bh);
  1976. brelse(d_bh);
  1977. kfree(log_blocks);
  1978. kfree(real_blocks);
  1979. reiserfs_warning(p_s_sb,
  1980. "journal-1169: kmalloc failed, unable to mount FS");
  1981. return -1;
  1982. }
  1983. /* get all the buffer heads */
  1984. trans_half = journal_trans_half(p_s_sb->s_blocksize);
  1985. for (i = 0; i < get_desc_trans_len(desc); i++) {
  1986. log_blocks[i] =
  1987. journal_getblk(p_s_sb,
  1988. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  1989. (trans_offset + 1 +
  1990. i) % SB_ONDISK_JOURNAL_SIZE(p_s_sb));
  1991. if (i < trans_half) {
  1992. real_blocks[i] =
  1993. sb_getblk(p_s_sb,
  1994. le32_to_cpu(desc->j_realblock[i]));
  1995. } else {
  1996. real_blocks[i] =
  1997. sb_getblk(p_s_sb,
  1998. le32_to_cpu(commit->
  1999. j_realblock[i - trans_half]));
  2000. }
  2001. if (real_blocks[i]->b_blocknr > SB_BLOCK_COUNT(p_s_sb)) {
  2002. reiserfs_warning(p_s_sb,
  2003. "journal-1207: REPLAY FAILURE fsck required! Block to replay is outside of filesystem");
  2004. goto abort_replay;
  2005. }
  2006. /* make sure we don't try to replay onto log or reserved area */
  2007. if (is_block_in_log_or_reserved_area
  2008. (p_s_sb, real_blocks[i]->b_blocknr)) {
  2009. reiserfs_warning(p_s_sb,
  2010. "journal-1204: REPLAY FAILURE fsck required! Trying to replay onto a log block");
  2011. abort_replay:
  2012. brelse_array(log_blocks, i);
  2013. brelse_array(real_blocks, i);
  2014. brelse(c_bh);
  2015. brelse(d_bh);
  2016. kfree(log_blocks);
  2017. kfree(real_blocks);
  2018. return -1;
  2019. }
  2020. }
  2021. /* read in the log blocks, memcpy to the corresponding real block */
  2022. ll_rw_block(READ, get_desc_trans_len(desc), log_blocks);
  2023. for (i = 0; i < get_desc_trans_len(desc); i++) {
  2024. wait_on_buffer(log_blocks[i]);
  2025. if (!buffer_uptodate(log_blocks[i])) {
  2026. reiserfs_warning(p_s_sb,
  2027. "journal-1212: REPLAY FAILURE fsck required! buffer write failed");
  2028. brelse_array(log_blocks + i,
  2029. get_desc_trans_len(desc) - i);
  2030. brelse_array(real_blocks, get_desc_trans_len(desc));
  2031. brelse(c_bh);
  2032. brelse(d_bh);
  2033. kfree(log_blocks);
  2034. kfree(real_blocks);
  2035. return -1;
  2036. }
  2037. memcpy(real_blocks[i]->b_data, log_blocks[i]->b_data,
  2038. real_blocks[i]->b_size);
  2039. set_buffer_uptodate(real_blocks[i]);
  2040. brelse(log_blocks[i]);
  2041. }
  2042. /* flush out the real blocks */
  2043. for (i = 0; i < get_desc_trans_len(desc); i++) {
  2044. set_buffer_dirty(real_blocks[i]);
  2045. ll_rw_block(SWRITE, 1, real_blocks + i);
  2046. }
  2047. for (i = 0; i < get_desc_trans_len(desc); i++) {
  2048. wait_on_buffer(real_blocks[i]);
  2049. if (!buffer_uptodate(real_blocks[i])) {
  2050. reiserfs_warning(p_s_sb,
  2051. "journal-1226: REPLAY FAILURE, fsck required! buffer write failed");
  2052. brelse_array(real_blocks + i,
  2053. get_desc_trans_len(desc) - i);
  2054. brelse(c_bh);
  2055. brelse(d_bh);
  2056. kfree(log_blocks);
  2057. kfree(real_blocks);
  2058. return -1;
  2059. }
  2060. brelse(real_blocks[i]);
  2061. }
  2062. cur_dblock =
  2063. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  2064. ((trans_offset + get_desc_trans_len(desc) +
  2065. 2) % SB_ONDISK_JOURNAL_SIZE(p_s_sb));
  2066. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  2067. "journal-1095: setting journal " "start to offset %ld",
  2068. cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb));
  2069. /* init starting values for the first transaction, in case this is the last transaction to be replayed. */
  2070. journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb);
  2071. journal->j_last_flush_trans_id = trans_id;
  2072. journal->j_trans_id = trans_id + 1;
  2073. /* check for trans_id overflow */
  2074. if (journal->j_trans_id == 0)
  2075. journal->j_trans_id = 10;
  2076. brelse(c_bh);
  2077. brelse(d_bh);
  2078. kfree(log_blocks);
  2079. kfree(real_blocks);
  2080. return 0;
  2081. }
  2082. /* This function reads blocks starting from block and to max_block of bufsize
  2083. size (but no more than BUFNR blocks at a time). This proved to improve
  2084. mounting speed on self-rebuilding raid5 arrays at least.
  2085. Right now it is only used from journal code. But later we might use it
  2086. from other places.
  2087. Note: Do not use journal_getblk/sb_getblk functions here! */
  2088. static struct buffer_head *reiserfs_breada(struct block_device *dev, int block,
  2089. int bufsize, unsigned int max_block)
  2090. {
  2091. struct buffer_head *bhlist[BUFNR];
  2092. unsigned int blocks = BUFNR;
  2093. struct buffer_head *bh;
  2094. int i, j;
  2095. bh = __getblk(dev, block, bufsize);
  2096. if (buffer_uptodate(bh))
  2097. return (bh);
  2098. if (block + BUFNR > max_block) {
  2099. blocks = max_block - block;
  2100. }
  2101. bhlist[0] = bh;
  2102. j = 1;
  2103. for (i = 1; i < blocks; i++) {
  2104. bh = __getblk(dev, block + i, bufsize);
  2105. if (buffer_uptodate(bh)) {
  2106. brelse(bh);
  2107. break;
  2108. } else
  2109. bhlist[j++] = bh;
  2110. }
  2111. ll_rw_block(READ, j, bhlist);
  2112. for (i = 1; i < j; i++)
  2113. brelse(bhlist[i]);
  2114. bh = bhlist[0];
  2115. wait_on_buffer(bh);
  2116. if (buffer_uptodate(bh))
  2117. return bh;
  2118. brelse(bh);
  2119. return NULL;
  2120. }
  2121. /*
  2122. ** read and replay the log
  2123. ** on a clean unmount, the journal header's next unflushed pointer will be to an invalid
  2124. ** transaction. This tests that before finding all the transactions in the log, which makes normal mount times fast.
  2125. **
  2126. ** After a crash, this starts with the next unflushed transaction, and replays until it finds one too old, or invalid.
  2127. **
  2128. ** On exit, it sets things up so the first transaction will work correctly.
  2129. */
  2130. static int journal_read(struct super_block *p_s_sb)
  2131. {
  2132. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  2133. struct reiserfs_journal_desc *desc;
  2134. unsigned long oldest_trans_id = 0;
  2135. unsigned long oldest_invalid_trans_id = 0;
  2136. time_t start;
  2137. unsigned long oldest_start = 0;
  2138. unsigned long cur_dblock = 0;
  2139. unsigned long newest_mount_id = 9;
  2140. struct buffer_head *d_bh;
  2141. struct reiserfs_journal_header *jh;
  2142. int valid_journal_header = 0;
  2143. int replay_count = 0;
  2144. int continue_replay = 1;
  2145. int ret;
  2146. char b[BDEVNAME_SIZE];
  2147. cur_dblock = SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb);
  2148. reiserfs_info(p_s_sb, "checking transaction log (%s)\n",
  2149. bdevname(journal->j_dev_bd, b));
  2150. start = get_seconds();
  2151. /* step 1, read in the journal header block. Check the transaction it says
  2152. ** is the first unflushed, and if that transaction is not valid,
  2153. ** replay is done
  2154. */
  2155. journal->j_header_bh = journal_bread(p_s_sb,
  2156. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb)
  2157. + SB_ONDISK_JOURNAL_SIZE(p_s_sb));
  2158. if (!journal->j_header_bh) {
  2159. return 1;
  2160. }
  2161. jh = (struct reiserfs_journal_header *)(journal->j_header_bh->b_data);
  2162. if (le32_to_cpu(jh->j_first_unflushed_offset) <
  2163. SB_ONDISK_JOURNAL_SIZE(p_s_sb)
  2164. && le32_to_cpu(jh->j_last_flush_trans_id) > 0) {
  2165. oldest_start =
  2166. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  2167. le32_to_cpu(jh->j_first_unflushed_offset);
  2168. oldest_trans_id = le32_to_cpu(jh->j_last_flush_trans_id) + 1;
  2169. newest_mount_id = le32_to_cpu(jh->j_mount_id);
  2170. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  2171. "journal-1153: found in "
  2172. "header: first_unflushed_offset %d, last_flushed_trans_id "
  2173. "%lu", le32_to_cpu(jh->j_first_unflushed_offset),
  2174. le32_to_cpu(jh->j_last_flush_trans_id));
  2175. valid_journal_header = 1;
  2176. /* now, we try to read the first unflushed offset. If it is not valid,
  2177. ** there is nothing more we can do, and it makes no sense to read
  2178. ** through the whole log.
  2179. */
  2180. d_bh =
  2181. journal_bread(p_s_sb,
  2182. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  2183. le32_to_cpu(jh->j_first_unflushed_offset));
  2184. ret = journal_transaction_is_valid(p_s_sb, d_bh, NULL, NULL);
  2185. if (!ret) {
  2186. continue_replay = 0;
  2187. }
  2188. brelse(d_bh);
  2189. goto start_log_replay;
  2190. }
  2191. if (continue_replay && bdev_read_only(p_s_sb->s_bdev)) {
  2192. reiserfs_warning(p_s_sb,
  2193. "clm-2076: device is readonly, unable to replay log");
  2194. return -1;
  2195. }
  2196. /* ok, there are transactions that need to be replayed. start with the first log block, find
  2197. ** all the valid transactions, and pick out the oldest.
  2198. */
  2199. while (continue_replay
  2200. && cur_dblock <
  2201. (SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  2202. SB_ONDISK_JOURNAL_SIZE(p_s_sb))) {
  2203. /* Note that it is required for blocksize of primary fs device and journal
  2204. device to be the same */
  2205. d_bh =
  2206. reiserfs_breada(journal->j_dev_bd, cur_dblock,
  2207. p_s_sb->s_blocksize,
  2208. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  2209. SB_ONDISK_JOURNAL_SIZE(p_s_sb));
  2210. ret =
  2211. journal_transaction_is_valid(p_s_sb, d_bh,
  2212. &oldest_invalid_trans_id,
  2213. &newest_mount_id);
  2214. if (ret == 1) {
  2215. desc = (struct reiserfs_journal_desc *)d_bh->b_data;
  2216. if (oldest_start == 0) { /* init all oldest_ values */
  2217. oldest_trans_id = get_desc_trans_id(desc);
  2218. oldest_start = d_bh->b_blocknr;
  2219. newest_mount_id = get_desc_mount_id(desc);
  2220. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  2221. "journal-1179: Setting "
  2222. "oldest_start to offset %llu, trans_id %lu",
  2223. oldest_start -
  2224. SB_ONDISK_JOURNAL_1st_BLOCK
  2225. (p_s_sb), oldest_trans_id);
  2226. } else if (oldest_trans_id > get_desc_trans_id(desc)) {
  2227. /* one we just read was older */
  2228. oldest_trans_id = get_desc_trans_id(desc);
  2229. oldest_start = d_bh->b_blocknr;
  2230. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  2231. "journal-1180: Resetting "
  2232. "oldest_start to offset %lu, trans_id %lu",
  2233. oldest_start -
  2234. SB_ONDISK_JOURNAL_1st_BLOCK
  2235. (p_s_sb), oldest_trans_id);
  2236. }
  2237. if (newest_mount_id < get_desc_mount_id(desc)) {
  2238. newest_mount_id = get_desc_mount_id(desc);
  2239. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  2240. "journal-1299: Setting "
  2241. "newest_mount_id to %d",
  2242. get_desc_mount_id(desc));
  2243. }
  2244. cur_dblock += get_desc_trans_len(desc) + 2;
  2245. } else {
  2246. cur_dblock++;
  2247. }
  2248. brelse(d_bh);
  2249. }
  2250. start_log_replay:
  2251. cur_dblock = oldest_start;
  2252. if (oldest_trans_id) {
  2253. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  2254. "journal-1206: Starting replay "
  2255. "from offset %llu, trans_id %lu",
  2256. cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb),
  2257. oldest_trans_id);
  2258. }
  2259. replay_count = 0;
  2260. while (continue_replay && oldest_trans_id > 0) {
  2261. ret =
  2262. journal_read_transaction(p_s_sb, cur_dblock, oldest_start,
  2263. oldest_trans_id, newest_mount_id);
  2264. if (ret < 0) {
  2265. return ret;
  2266. } else if (ret != 0) {
  2267. break;
  2268. }
  2269. cur_dblock =
  2270. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + journal->j_start;
  2271. replay_count++;
  2272. if (cur_dblock == oldest_start)
  2273. break;
  2274. }
  2275. if (oldest_trans_id == 0) {
  2276. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
  2277. "journal-1225: No valid " "transactions found");
  2278. }
  2279. /* j_start does not get set correctly if we don't replay any transactions.
  2280. ** if we had a valid journal_header, set j_start to the first unflushed transaction value,
  2281. ** copy the trans_id from the header
  2282. */
  2283. if (valid_journal_header && replay_count == 0) {
  2284. journal->j_start = le32_to_cpu(jh->j_first_unflushed_offset);
  2285. journal->j_trans_id =
  2286. le32_to_cpu(jh->j_last_flush_trans_id) + 1;
  2287. /* check for trans_id overflow */
  2288. if (journal->j_trans_id == 0)
  2289. journal->j_trans_id = 10;
  2290. journal->j_last_flush_trans_id =
  2291. le32_to_cpu(jh->j_last_flush_trans_id);
  2292. journal->j_mount_id = le32_to_cpu(jh->j_mount_id) + 1;
  2293. } else {
  2294. journal->j_mount_id = newest_mount_id + 1;
  2295. }
  2296. reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1299: Setting "
  2297. "newest_mount_id to %lu", journal->j_mount_id);
  2298. journal->j_first_unflushed_offset = journal->j_start;
  2299. if (replay_count > 0) {
  2300. reiserfs_info(p_s_sb,
  2301. "replayed %d transactions in %lu seconds\n",
  2302. replay_count, get_seconds() - start);
  2303. }
  2304. if (!bdev_read_only(p_s_sb->s_bdev) &&
  2305. _update_journal_header_block(p_s_sb, journal->j_start,
  2306. journal->j_last_flush_trans_id)) {
  2307. /* replay failed, caller must call free_journal_ram and abort
  2308. ** the mount
  2309. */
  2310. return -1;
  2311. }
  2312. return 0;
  2313. }
  2314. static struct reiserfs_journal_list *alloc_journal_list(struct super_block *s)
  2315. {
  2316. struct reiserfs_journal_list *jl;
  2317. jl = kzalloc(sizeof(struct reiserfs_journal_list),
  2318. GFP_NOFS | __GFP_NOFAIL);
  2319. INIT_LIST_HEAD(&jl->j_list);
  2320. INIT_LIST_HEAD(&jl->j_working_list);
  2321. INIT_LIST_HEAD(&jl->j_tail_bh_list);
  2322. INIT_LIST_HEAD(&jl->j_bh_list);
  2323. sema_init(&jl->j_commit_lock, 1);
  2324. SB_JOURNAL(s)->j_num_lists++;
  2325. get_journal_list(jl);
  2326. return jl;
  2327. }
  2328. static void journal_list_init(struct super_block *p_s_sb)
  2329. {
  2330. SB_JOURNAL(p_s_sb)->j_current_jl = alloc_journal_list(p_s_sb);
  2331. }
  2332. static int release_journal_dev(struct super_block *super,
  2333. struct reiserfs_journal *journal)
  2334. {
  2335. int result;
  2336. result = 0;
  2337. if (journal->j_dev_file != NULL) {
  2338. result = filp_close(journal->j_dev_file, NULL);
  2339. journal->j_dev_file = NULL;
  2340. journal->j_dev_bd = NULL;
  2341. } else if (journal->j_dev_bd != NULL) {
  2342. result = blkdev_put(journal->j_dev_bd);
  2343. journal->j_dev_bd = NULL;
  2344. }
  2345. if (result != 0) {
  2346. reiserfs_warning(super,
  2347. "sh-457: release_journal_dev: Cannot release journal device: %i",
  2348. result);
  2349. }
  2350. return result;
  2351. }
  2352. static int journal_init_dev(struct super_block *super,
  2353. struct reiserfs_journal *journal,
  2354. const char *jdev_name)
  2355. {
  2356. int result;
  2357. dev_t jdev;
  2358. int blkdev_mode = FMODE_READ | FMODE_WRITE;
  2359. char b[BDEVNAME_SIZE];
  2360. result = 0;
  2361. journal->j_dev_bd = NULL;
  2362. journal->j_dev_file = NULL;
  2363. jdev = SB_ONDISK_JOURNAL_DEVICE(super) ?
  2364. new_decode_dev(SB_ONDISK_JOURNAL_DEVICE(super)) : super->s_dev;
  2365. if (bdev_read_only(super->s_bdev))
  2366. blkdev_mode = FMODE_READ;
  2367. /* there is no "jdev" option and journal is on separate device */
  2368. if ((!jdev_name || !jdev_name[0])) {
  2369. journal->j_dev_bd = open_by_devnum(jdev, blkdev_mode);
  2370. if (IS_ERR(journal->j_dev_bd)) {
  2371. result = PTR_ERR(journal->j_dev_bd);
  2372. journal->j_dev_bd = NULL;
  2373. reiserfs_warning(super, "sh-458: journal_init_dev: "
  2374. "cannot init journal device '%s': %i",
  2375. __bdevname(jdev, b), result);
  2376. return result;
  2377. } else if (jdev != super->s_dev)
  2378. set_blocksize(journal->j_dev_bd, super->s_blocksize);
  2379. return 0;
  2380. }
  2381. journal->j_dev_file = filp_open(jdev_name, 0, 0);
  2382. if (!IS_ERR(journal->j_dev_file)) {
  2383. struct inode *jdev_inode = journal->j_dev_file->f_mapping->host;
  2384. if (!S_ISBLK(jdev_inode->i_mode)) {
  2385. reiserfs_warning(super, "journal_init_dev: '%s' is "
  2386. "not a block device", jdev_name);
  2387. result = -ENOTBLK;
  2388. release_journal_dev(super, journal);
  2389. } else {
  2390. /* ok */
  2391. journal->j_dev_bd = I_BDEV(jdev_inode);
  2392. set_blocksize(journal->j_dev_bd, super->s_blocksize);
  2393. reiserfs_info(super,
  2394. "journal_init_dev: journal device: %s\n",
  2395. bdevname(journal->j_dev_bd, b));
  2396. }
  2397. } else {
  2398. result = PTR_ERR(journal->j_dev_file);
  2399. journal->j_dev_file = NULL;
  2400. reiserfs_warning(super,
  2401. "journal_init_dev: Cannot open '%s': %i",
  2402. jdev_name, result);
  2403. }
  2404. return result;
  2405. }
  2406. /*
  2407. ** must be called once on fs mount. calls journal_read for you
  2408. */
  2409. int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
  2410. int old_format, unsigned int commit_max_age)
  2411. {
  2412. int num_cnodes = SB_ONDISK_JOURNAL_SIZE(p_s_sb) * 2;
  2413. struct buffer_head *bhjh;
  2414. struct reiserfs_super_block *rs;
  2415. struct reiserfs_journal_header *jh;
  2416. struct reiserfs_journal *journal;
  2417. struct reiserfs_journal_list *jl;
  2418. char b[BDEVNAME_SIZE];
  2419. journal = SB_JOURNAL(p_s_sb) = vmalloc(sizeof(struct reiserfs_journal));
  2420. if (!journal) {
  2421. reiserfs_warning(p_s_sb,
  2422. "journal-1256: unable to get memory for journal structure");
  2423. return 1;
  2424. }
  2425. memset(journal, 0, sizeof(struct reiserfs_journal));
  2426. INIT_LIST_HEAD(&journal->j_bitmap_nodes);
  2427. INIT_LIST_HEAD(&journal->j_prealloc_list);
  2428. INIT_LIST_HEAD(&journal->j_working_list);
  2429. INIT_LIST_HEAD(&journal->j_journal_list);
  2430. journal->j_persistent_trans = 0;
  2431. if (reiserfs_allocate_list_bitmaps(p_s_sb,
  2432. journal->j_list_bitmap,
  2433. SB_BMAP_NR(p_s_sb)))
  2434. goto free_and_return;
  2435. allocate_bitmap_nodes(p_s_sb);
  2436. /* reserved for journal area support */
  2437. SB_JOURNAL_1st_RESERVED_BLOCK(p_s_sb) = (old_format ?
  2438. REISERFS_OLD_DISK_OFFSET_IN_BYTES
  2439. / p_s_sb->s_blocksize +
  2440. SB_BMAP_NR(p_s_sb) +
  2441. 1 :
  2442. REISERFS_DISK_OFFSET_IN_BYTES /
  2443. p_s_sb->s_blocksize + 2);
  2444. /* Sanity check to see is the standard journal fitting withing first bitmap
  2445. (actual for small blocksizes) */
  2446. if (!SB_ONDISK_JOURNAL_DEVICE(p_s_sb) &&
  2447. (SB_JOURNAL_1st_RESERVED_BLOCK(p_s_sb) +
  2448. SB_ONDISK_JOURNAL_SIZE(p_s_sb) > p_s_sb->s_blocksize * 8)) {
  2449. reiserfs_warning(p_s_sb,
  2450. "journal-1393: journal does not fit for area "
  2451. "addressed by first of bitmap blocks. It starts at "
  2452. "%u and its size is %u. Block size %ld",
  2453. SB_JOURNAL_1st_RESERVED_BLOCK(p_s_sb),
  2454. SB_ONDISK_JOURNAL_SIZE(p_s_sb),
  2455. p_s_sb->s_blocksize);
  2456. goto free_and_return;
  2457. }
  2458. if (journal_init_dev(p_s_sb, journal, j_dev_name) != 0) {
  2459. reiserfs_warning(p_s_sb,
  2460. "sh-462: unable to initialize jornal device");
  2461. goto free_and_return;
  2462. }
  2463. rs = SB_DISK_SUPER_BLOCK(p_s_sb);
  2464. /* read journal header */
  2465. bhjh = journal_bread(p_s_sb,
  2466. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  2467. SB_ONDISK_JOURNAL_SIZE(p_s_sb));
  2468. if (!bhjh) {
  2469. reiserfs_warning(p_s_sb,
  2470. "sh-459: unable to read journal header");
  2471. goto free_and_return;
  2472. }
  2473. jh = (struct reiserfs_journal_header *)(bhjh->b_data);
  2474. /* make sure that journal matches to the super block */
  2475. if (is_reiserfs_jr(rs)
  2476. && (le32_to_cpu(jh->jh_journal.jp_journal_magic) !=
  2477. sb_jp_journal_magic(rs))) {
  2478. reiserfs_warning(p_s_sb,
  2479. "sh-460: journal header magic %x "
  2480. "(device %s) does not match to magic found in super "
  2481. "block %x", jh->jh_journal.jp_journal_magic,
  2482. bdevname(journal->j_dev_bd, b),
  2483. sb_jp_journal_magic(rs));
  2484. brelse(bhjh);
  2485. goto free_and_return;
  2486. }
  2487. journal->j_trans_max = le32_to_cpu(jh->jh_journal.jp_journal_trans_max);
  2488. journal->j_max_batch = le32_to_cpu(jh->jh_journal.jp_journal_max_batch);
  2489. journal->j_max_commit_age =
  2490. le32_to_cpu(jh->jh_journal.jp_journal_max_commit_age);
  2491. journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
  2492. if (journal->j_trans_max) {
  2493. /* make sure these parameters are available, assign it if they are not */
  2494. __u32 initial = journal->j_trans_max;
  2495. __u32 ratio = 1;
  2496. if (p_s_sb->s_blocksize < 4096)
  2497. ratio = 4096 / p_s_sb->s_blocksize;
  2498. if (SB_ONDISK_JOURNAL_SIZE(p_s_sb) / journal->j_trans_max <
  2499. JOURNAL_MIN_RATIO)
  2500. journal->j_trans_max =
  2501. SB_ONDISK_JOURNAL_SIZE(p_s_sb) / JOURNAL_MIN_RATIO;
  2502. if (journal->j_trans_max > JOURNAL_TRANS_MAX_DEFAULT / ratio)
  2503. journal->j_trans_max =
  2504. JOURNAL_TRANS_MAX_DEFAULT / ratio;
  2505. if (journal->j_trans_max < JOURNAL_TRANS_MIN_DEFAULT / ratio)
  2506. journal->j_trans_max =
  2507. JOURNAL_TRANS_MIN_DEFAULT / ratio;
  2508. if (journal->j_trans_max != initial)
  2509. reiserfs_warning(p_s_sb,
  2510. "sh-461: journal_init: wrong transaction max size (%u). Changed to %u",
  2511. initial, journal->j_trans_max);
  2512. journal->j_max_batch = journal->j_trans_max *
  2513. JOURNAL_MAX_BATCH_DEFAULT / JOURNAL_TRANS_MAX_DEFAULT;
  2514. }
  2515. if (!journal->j_trans_max) {
  2516. /*we have the file system was created by old version of mkreiserfs
  2517. so this field contains zero value */
  2518. journal->j_trans_max = JOURNAL_TRANS_MAX_DEFAULT;
  2519. journal->j_max_batch = JOURNAL_MAX_BATCH_DEFAULT;
  2520. journal->j_max_commit_age = JOURNAL_MAX_COMMIT_AGE;
  2521. /* for blocksize >= 4096 - max transaction size is 1024. For block size < 4096
  2522. trans max size is decreased proportionally */
  2523. if (p_s_sb->s_blocksize < 4096) {
  2524. journal->j_trans_max /= (4096 / p_s_sb->s_blocksize);
  2525. journal->j_max_batch = (journal->j_trans_max) * 9 / 10;
  2526. }
  2527. }
  2528. journal->j_default_max_commit_age = journal->j_max_commit_age;
  2529. if (commit_max_age != 0) {
  2530. journal->j_max_commit_age = commit_max_age;
  2531. journal->j_max_trans_age = commit_max_age;
  2532. }
  2533. reiserfs_info(p_s_sb, "journal params: device %s, size %u, "
  2534. "journal first block %u, max trans len %u, max batch %u, "
  2535. "max commit age %u, max trans age %u\n",
  2536. bdevname(journal->j_dev_bd, b),
  2537. SB_ONDISK_JOURNAL_SIZE(p_s_sb),
  2538. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb),
  2539. journal->j_trans_max,
  2540. journal->j_max_batch,
  2541. journal->j_max_commit_age, journal->j_max_trans_age);
  2542. brelse(bhjh);
  2543. journal->j_list_bitmap_index = 0;
  2544. journal_list_init(p_s_sb);
  2545. memset(journal->j_list_hash_table, 0,
  2546. JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *));
  2547. INIT_LIST_HEAD(&journal->j_dirty_buffers);
  2548. spin_lock_init(&journal->j_dirty_buffers_lock);
  2549. journal->j_start = 0;
  2550. journal->j_len = 0;
  2551. journal->j_len_alloc = 0;
  2552. atomic_set(&(journal->j_wcount), 0);
  2553. atomic_set(&(journal->j_async_throttle), 0);
  2554. journal->j_bcount = 0;
  2555. journal->j_trans_start_time = 0;
  2556. journal->j_last = NULL;
  2557. journal->j_first = NULL;
  2558. init_waitqueue_head(&(journal->j_join_wait));
  2559. sema_init(&journal->j_lock, 1);
  2560. sema_init(&journal->j_flush_sem, 1);
  2561. journal->j_trans_id = 10;
  2562. journal->j_mount_id = 10;
  2563. journal->j_state = 0;
  2564. atomic_set(&(journal->j_jlock), 0);
  2565. journal->j_cnode_free_list = allocate_cnodes(num_cnodes);
  2566. journal->j_cnode_free_orig = journal->j_cnode_free_list;
  2567. journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0;
  2568. journal->j_cnode_used = 0;
  2569. journal->j_must_wait = 0;
  2570. if (journal->j_cnode_free == 0) {
  2571. reiserfs_warning(p_s_sb, "journal-2004: Journal cnode memory "
  2572. "allocation failed (%ld bytes). Journal is "
  2573. "too large for available memory. Usually "
  2574. "this is due to a journal that is too large.",
  2575. sizeof (struct reiserfs_journal_cnode) * num_cnodes);
  2576. goto free_and_return;
  2577. }
  2578. init_journal_hash(p_s_sb);
  2579. jl = journal->j_current_jl;
  2580. jl->j_list_bitmap = get_list_bitmap(p_s_sb, jl);
  2581. if (!jl->j_list_bitmap) {
  2582. reiserfs_warning(p_s_sb,
  2583. "journal-2005, get_list_bitmap failed for journal list 0");
  2584. goto free_and_return;
  2585. }
  2586. if (journal_read(p_s_sb) < 0) {
  2587. reiserfs_warning(p_s_sb, "Replay Failure, unable to mount");
  2588. goto free_and_return;
  2589. }
  2590. reiserfs_mounted_fs_count++;
  2591. if (reiserfs_mounted_fs_count <= 1)
  2592. commit_wq = create_workqueue("reiserfs");
  2593. INIT_DELAYED_WORK(&journal->j_work, flush_async_commits);
  2594. journal->j_work_sb = p_s_sb;
  2595. return 0;
  2596. free_and_return:
  2597. free_journal_ram(p_s_sb);
  2598. return 1;
  2599. }
  2600. /*
  2601. ** test for a polite end of the current transaction. Used by file_write, and should
  2602. ** be used by delete to make sure they don't write more than can fit inside a single
  2603. ** transaction
  2604. */
  2605. int journal_transaction_should_end(struct reiserfs_transaction_handle *th,
  2606. int new_alloc)
  2607. {
  2608. struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
  2609. time_t now = get_seconds();
  2610. /* cannot restart while nested */
  2611. BUG_ON(!th->t_trans_id);
  2612. if (th->t_refcount > 1)
  2613. return 0;
  2614. if (journal->j_must_wait > 0 ||
  2615. (journal->j_len_alloc + new_alloc) >= journal->j_max_batch ||
  2616. atomic_read(&(journal->j_jlock)) ||
  2617. (now - journal->j_trans_start_time) > journal->j_max_trans_age ||
  2618. journal->j_cnode_free < (journal->j_trans_max * 3)) {
  2619. return 1;
  2620. }
  2621. /* protected by the BKL here */
  2622. journal->j_len_alloc += new_alloc;
  2623. th->t_blocks_allocated += new_alloc ;
  2624. return 0;
  2625. }
  2626. /* this must be called inside a transaction, and requires the
  2627. ** kernel_lock to be held
  2628. */
  2629. void reiserfs_block_writes(struct reiserfs_transaction_handle *th)
  2630. {
  2631. struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
  2632. BUG_ON(!th->t_trans_id);
  2633. journal->j_must_wait = 1;
  2634. set_bit(J_WRITERS_BLOCKED, &journal->j_state);
  2635. return;
  2636. }
  2637. /* this must be called without a transaction started, and does not
  2638. ** require BKL
  2639. */
  2640. void reiserfs_allow_writes(struct super_block *s)
  2641. {
  2642. struct reiserfs_journal *journal = SB_JOURNAL(s);
  2643. clear_bit(J_WRITERS_BLOCKED, &journal->j_state);
  2644. wake_up(&journal->j_join_wait);
  2645. }
  2646. /* this must be called without a transaction started, and does not
  2647. ** require BKL
  2648. */
  2649. void reiserfs_wait_on_write_block(struct super_block *s)
  2650. {
  2651. struct reiserfs_journal *journal = SB_JOURNAL(s);
  2652. wait_event(journal->j_join_wait,
  2653. !test_bit(J_WRITERS_BLOCKED, &journal->j_state));
  2654. }
  2655. static void queue_log_writer(struct super_block *s)
  2656. {
  2657. wait_queue_t wait;
  2658. struct reiserfs_journal *journal = SB_JOURNAL(s);
  2659. set_bit(J_WRITERS_QUEUED, &journal->j_state);
  2660. /*
  2661. * we don't want to use wait_event here because
  2662. * we only want to wait once.
  2663. */
  2664. init_waitqueue_entry(&wait, current);
  2665. add_wait_queue(&journal->j_join_wait, &wait);
  2666. set_current_state(TASK_UNINTERRUPTIBLE);
  2667. if (test_bit(J_WRITERS_QUEUED, &journal->j_state))
  2668. schedule();
  2669. current->state = TASK_RUNNING;
  2670. remove_wait_queue(&journal->j_join_wait, &wait);
  2671. }
  2672. static void wake_queued_writers(struct super_block *s)
  2673. {
  2674. struct reiserfs_journal *journal = SB_JOURNAL(s);
  2675. if (test_and_clear_bit(J_WRITERS_QUEUED, &journal->j_state))
  2676. wake_up(&journal->j_join_wait);
  2677. }
  2678. static void let_transaction_grow(struct super_block *sb, unsigned long trans_id)
  2679. {
  2680. struct reiserfs_journal *journal = SB_JOURNAL(sb);
  2681. unsigned long bcount = journal->j_bcount;
  2682. while (1) {
  2683. schedule_timeout_uninterruptible(1);
  2684. journal->j_current_jl->j_state |= LIST_COMMIT_PENDING;
  2685. while ((atomic_read(&journal->j_wcount) > 0 ||
  2686. atomic_read(&journal->j_jlock)) &&
  2687. journal->j_trans_id == trans_id) {
  2688. queue_log_writer(sb);
  2689. }
  2690. if (journal->j_trans_id != trans_id)
  2691. break;
  2692. if (bcount == journal->j_bcount)
  2693. break;
  2694. bcount = journal->j_bcount;
  2695. }
  2696. }
  2697. /* join == true if you must join an existing transaction.
  2698. ** join == false if you can deal with waiting for others to finish
  2699. **
  2700. ** this will block until the transaction is joinable. send the number of blocks you
  2701. ** expect to use in nblocks.
  2702. */
  2703. static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
  2704. struct super_block *p_s_sb, unsigned long nblocks,
  2705. int join)
  2706. {
  2707. time_t now = get_seconds();
  2708. int old_trans_id;
  2709. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  2710. struct reiserfs_transaction_handle myth;
  2711. int sched_count = 0;
  2712. int retval;
  2713. reiserfs_check_lock_depth(p_s_sb, "journal_begin");
  2714. BUG_ON(nblocks > journal->j_trans_max);
  2715. PROC_INFO_INC(p_s_sb, journal.journal_being);
  2716. /* set here for journal_join */
  2717. th->t_refcount = 1;
  2718. th->t_super = p_s_sb;
  2719. relock:
  2720. lock_journal(p_s_sb);
  2721. if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) {
  2722. unlock_journal(p_s_sb);
  2723. retval = journal->j_errno;
  2724. goto out_fail;
  2725. }
  2726. journal->j_bcount++;
  2727. if (test_bit(J_WRITERS_BLOCKED, &journal->j_state)) {
  2728. unlock_journal(p_s_sb);
  2729. reiserfs_wait_on_write_block(p_s_sb);
  2730. PROC_INFO_INC(p_s_sb, journal.journal_relock_writers);
  2731. goto relock;
  2732. }
  2733. now = get_seconds();
  2734. /* if there is no room in the journal OR
  2735. ** if this transaction is too old, and we weren't called joinable, wait for it to finish before beginning
  2736. ** we don't sleep if there aren't other writers
  2737. */
  2738. if ((!join && journal->j_must_wait > 0) ||
  2739. (!join
  2740. && (journal->j_len_alloc + nblocks + 2) >= journal->j_max_batch)
  2741. || (!join && atomic_read(&journal->j_wcount) > 0
  2742. && journal->j_trans_start_time > 0
  2743. && (now - journal->j_trans_start_time) >
  2744. journal->j_max_trans_age) || (!join
  2745. && atomic_read(&journal->j_jlock))
  2746. || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) {
  2747. old_trans_id = journal->j_trans_id;
  2748. unlock_journal(p_s_sb); /* allow others to finish this transaction */
  2749. if (!join && (journal->j_len_alloc + nblocks + 2) >=
  2750. journal->j_max_batch &&
  2751. ((journal->j_len + nblocks + 2) * 100) <
  2752. (journal->j_len_alloc * 75)) {
  2753. if (atomic_read(&journal->j_wcount) > 10) {
  2754. sched_count++;
  2755. queue_log_writer(p_s_sb);
  2756. goto relock;
  2757. }
  2758. }
  2759. /* don't mess with joining the transaction if all we have to do is
  2760. * wait for someone else to do a commit
  2761. */
  2762. if (atomic_read(&journal->j_jlock)) {
  2763. while (journal->j_trans_id == old_trans_id &&
  2764. atomic_read(&journal->j_jlock)) {
  2765. queue_log_writer(p_s_sb);
  2766. }
  2767. goto relock;
  2768. }
  2769. retval = journal_join(&myth, p_s_sb, 1);
  2770. if (retval)
  2771. goto out_fail;
  2772. /* someone might have ended the transaction while we joined */
  2773. if (old_trans_id != journal->j_trans_id) {
  2774. retval = do_journal_end(&myth, p_s_sb, 1, 0);
  2775. } else {
  2776. retval = do_journal_end(&myth, p_s_sb, 1, COMMIT_NOW);
  2777. }
  2778. if (retval)
  2779. goto out_fail;
  2780. PROC_INFO_INC(p_s_sb, journal.journal_relock_wcount);
  2781. goto relock;
  2782. }
  2783. /* we are the first writer, set trans_id */
  2784. if (journal->j_trans_start_time == 0) {
  2785. journal->j_trans_start_time = get_seconds();
  2786. }
  2787. atomic_inc(&(journal->j_wcount));
  2788. journal->j_len_alloc += nblocks;
  2789. th->t_blocks_logged = 0;
  2790. th->t_blocks_allocated = nblocks;
  2791. th->t_trans_id = journal->j_trans_id;
  2792. unlock_journal(p_s_sb);
  2793. INIT_LIST_HEAD(&th->t_list);
  2794. get_fs_excl();
  2795. return 0;
  2796. out_fail:
  2797. memset(th, 0, sizeof(*th));
  2798. /* Re-set th->t_super, so we can properly keep track of how many
  2799. * persistent transactions there are. We need to do this so if this
  2800. * call is part of a failed restart_transaction, we can free it later */
  2801. th->t_super = p_s_sb;
  2802. return retval;
  2803. }
  2804. struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct
  2805. super_block
  2806. *s,
  2807. int nblocks)
  2808. {
  2809. int ret;
  2810. struct reiserfs_transaction_handle *th;
  2811. /* if we're nesting into an existing transaction. It will be
  2812. ** persistent on its own
  2813. */
  2814. if (reiserfs_transaction_running(s)) {
  2815. th = current->journal_info;
  2816. th->t_refcount++;
  2817. BUG_ON(th->t_refcount < 2);
  2818. return th;
  2819. }
  2820. th = kmalloc(sizeof(struct reiserfs_transaction_handle), GFP_NOFS);
  2821. if (!th)
  2822. return NULL;
  2823. ret = journal_begin(th, s, nblocks);
  2824. if (ret) {
  2825. kfree(th);
  2826. return NULL;
  2827. }
  2828. SB_JOURNAL(s)->j_persistent_trans++;
  2829. return th;
  2830. }
  2831. int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *th)
  2832. {
  2833. struct super_block *s = th->t_super;
  2834. int ret = 0;
  2835. if (th->t_trans_id)
  2836. ret = journal_end(th, th->t_super, th->t_blocks_allocated);
  2837. else
  2838. ret = -EIO;
  2839. if (th->t_refcount == 0) {
  2840. SB_JOURNAL(s)->j_persistent_trans--;
  2841. kfree(th);
  2842. }
  2843. return ret;
  2844. }
  2845. static int journal_join(struct reiserfs_transaction_handle *th,
  2846. struct super_block *p_s_sb, unsigned long nblocks)
  2847. {
  2848. struct reiserfs_transaction_handle *cur_th = current->journal_info;
  2849. /* this keeps do_journal_end from NULLing out the current->journal_info
  2850. ** pointer
  2851. */
  2852. th->t_handle_save = cur_th;
  2853. BUG_ON(cur_th && cur_th->t_refcount > 1);
  2854. return do_journal_begin_r(th, p_s_sb, nblocks, JBEGIN_JOIN);
  2855. }
  2856. int journal_join_abort(struct reiserfs_transaction_handle *th,
  2857. struct super_block *p_s_sb, unsigned long nblocks)
  2858. {
  2859. struct reiserfs_transaction_handle *cur_th = current->journal_info;
  2860. /* this keeps do_journal_end from NULLing out the current->journal_info
  2861. ** pointer
  2862. */
  2863. th->t_handle_save = cur_th;
  2864. BUG_ON(cur_th && cur_th->t_refcount > 1);
  2865. return do_journal_begin_r(th, p_s_sb, nblocks, JBEGIN_ABORT);
  2866. }
  2867. int journal_begin(struct reiserfs_transaction_handle *th,
  2868. struct super_block *p_s_sb, unsigned long nblocks)
  2869. {
  2870. struct reiserfs_transaction_handle *cur_th = current->journal_info;
  2871. int ret;
  2872. th->t_handle_save = NULL;
  2873. if (cur_th) {
  2874. /* we are nesting into the current transaction */
  2875. if (cur_th->t_super == p_s_sb) {
  2876. BUG_ON(!cur_th->t_refcount);
  2877. cur_th->t_refcount++;
  2878. memcpy(th, cur_th, sizeof(*th));
  2879. if (th->t_refcount <= 1)
  2880. reiserfs_warning(p_s_sb,
  2881. "BAD: refcount <= 1, but journal_info != 0");
  2882. return 0;
  2883. } else {
  2884. /* we've ended up with a handle from a different filesystem.
  2885. ** save it and restore on journal_end. This should never
  2886. ** really happen...
  2887. */
  2888. reiserfs_warning(p_s_sb,
  2889. "clm-2100: nesting info a different FS");
  2890. th->t_handle_save = current->journal_info;
  2891. current->journal_info = th;
  2892. }
  2893. } else {
  2894. current->journal_info = th;
  2895. }
  2896. ret = do_journal_begin_r(th, p_s_sb, nblocks, JBEGIN_REG);
  2897. BUG_ON(current->journal_info != th);
  2898. /* I guess this boils down to being the reciprocal of clm-2100 above.
  2899. * If do_journal_begin_r fails, we need to put it back, since journal_end
  2900. * won't be called to do it. */
  2901. if (ret)
  2902. current->journal_info = th->t_handle_save;
  2903. else
  2904. BUG_ON(!th->t_refcount);
  2905. return ret;
  2906. }
  2907. /*
  2908. ** puts bh into the current transaction. If it was already there, reorders removes the
  2909. ** old pointers from the hash, and puts new ones in (to make sure replay happen in the right order).
  2910. **
  2911. ** if it was dirty, cleans and files onto the clean list. I can't let it be dirty again until the
  2912. ** transaction is committed.
  2913. **
  2914. ** if j_len, is bigger than j_len_alloc, it pushes j_len_alloc to 10 + j_len.
  2915. */
  2916. int journal_mark_dirty(struct reiserfs_transaction_handle *th,
  2917. struct super_block *p_s_sb, struct buffer_head *bh)
  2918. {
  2919. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  2920. struct reiserfs_journal_cnode *cn = NULL;
  2921. int count_already_incd = 0;
  2922. int prepared = 0;
  2923. BUG_ON(!th->t_trans_id);
  2924. PROC_INFO_INC(p_s_sb, journal.mark_dirty);
  2925. if (th->t_trans_id != journal->j_trans_id) {
  2926. reiserfs_panic(th->t_super,
  2927. "journal-1577: handle trans id %ld != current trans id %ld\n",
  2928. th->t_trans_id, journal->j_trans_id);
  2929. }
  2930. p_s_sb->s_dirt = 1;
  2931. prepared = test_clear_buffer_journal_prepared(bh);
  2932. clear_buffer_journal_restore_dirty(bh);
  2933. /* already in this transaction, we are done */
  2934. if (buffer_journaled(bh)) {
  2935. PROC_INFO_INC(p_s_sb, journal.mark_dirty_already);
  2936. return 0;
  2937. }
  2938. /* this must be turned into a panic instead of a warning. We can't allow
  2939. ** a dirty or journal_dirty or locked buffer to be logged, as some changes
  2940. ** could get to disk too early. NOT GOOD.
  2941. */
  2942. if (!prepared || buffer_dirty(bh)) {
  2943. reiserfs_warning(p_s_sb, "journal-1777: buffer %llu bad state "
  2944. "%cPREPARED %cLOCKED %cDIRTY %cJDIRTY_WAIT",
  2945. (unsigned long long)bh->b_blocknr,
  2946. prepared ? ' ' : '!',
  2947. buffer_locked(bh) ? ' ' : '!',
  2948. buffer_dirty(bh) ? ' ' : '!',
  2949. buffer_journal_dirty(bh) ? ' ' : '!');
  2950. }
  2951. if (atomic_read(&(journal->j_wcount)) <= 0) {
  2952. reiserfs_warning(p_s_sb,
  2953. "journal-1409: journal_mark_dirty returning because j_wcount was %d",
  2954. atomic_read(&(journal->j_wcount)));
  2955. return 1;
  2956. }
  2957. /* this error means I've screwed up, and we've overflowed the transaction.
  2958. ** Nothing can be done here, except make the FS readonly or panic.
  2959. */
  2960. if (journal->j_len >= journal->j_trans_max) {
  2961. reiserfs_panic(th->t_super,
  2962. "journal-1413: journal_mark_dirty: j_len (%lu) is too big\n",
  2963. journal->j_len);
  2964. }
  2965. if (buffer_journal_dirty(bh)) {
  2966. count_already_incd = 1;
  2967. PROC_INFO_INC(p_s_sb, journal.mark_dirty_notjournal);
  2968. clear_buffer_journal_dirty(bh);
  2969. }
  2970. if (journal->j_len > journal->j_len_alloc) {
  2971. journal->j_len_alloc = journal->j_len + JOURNAL_PER_BALANCE_CNT;
  2972. }
  2973. set_buffer_journaled(bh);
  2974. /* now put this guy on the end */
  2975. if (!cn) {
  2976. cn = get_cnode(p_s_sb);
  2977. if (!cn) {
  2978. reiserfs_panic(p_s_sb, "get_cnode failed!\n");
  2979. }
  2980. if (th->t_blocks_logged == th->t_blocks_allocated) {
  2981. th->t_blocks_allocated += JOURNAL_PER_BALANCE_CNT;
  2982. journal->j_len_alloc += JOURNAL_PER_BALANCE_CNT;
  2983. }
  2984. th->t_blocks_logged++;
  2985. journal->j_len++;
  2986. cn->bh = bh;
  2987. cn->blocknr = bh->b_blocknr;
  2988. cn->sb = p_s_sb;
  2989. cn->jlist = NULL;
  2990. insert_journal_hash(journal->j_hash_table, cn);
  2991. if (!count_already_incd) {
  2992. get_bh(bh);
  2993. }
  2994. }
  2995. cn->next = NULL;
  2996. cn->prev = journal->j_last;
  2997. cn->bh = bh;
  2998. if (journal->j_last) {
  2999. journal->j_last->next = cn;
  3000. journal->j_last = cn;
  3001. } else {
  3002. journal->j_first = cn;
  3003. journal->j_last = cn;
  3004. }
  3005. return 0;
  3006. }
  3007. int journal_end(struct reiserfs_transaction_handle *th,
  3008. struct super_block *p_s_sb, unsigned long nblocks)
  3009. {
  3010. if (!current->journal_info && th->t_refcount > 1)
  3011. reiserfs_warning(p_s_sb, "REISER-NESTING: th NULL, refcount %d",
  3012. th->t_refcount);
  3013. if (!th->t_trans_id) {
  3014. WARN_ON(1);
  3015. return -EIO;
  3016. }
  3017. th->t_refcount--;
  3018. if (th->t_refcount > 0) {
  3019. struct reiserfs_transaction_handle *cur_th =
  3020. current->journal_info;
  3021. /* we aren't allowed to close a nested transaction on a different
  3022. ** filesystem from the one in the task struct
  3023. */
  3024. BUG_ON(cur_th->t_super != th->t_super);
  3025. if (th != cur_th) {
  3026. memcpy(current->journal_info, th, sizeof(*th));
  3027. th->t_trans_id = 0;
  3028. }
  3029. return 0;
  3030. } else {
  3031. return do_journal_end(th, p_s_sb, nblocks, 0);
  3032. }
  3033. }
  3034. /* removes from the current transaction, relsing and descrementing any counters.
  3035. ** also files the removed buffer directly onto the clean list
  3036. **
  3037. ** called by journal_mark_freed when a block has been deleted
  3038. **
  3039. ** returns 1 if it cleaned and relsed the buffer. 0 otherwise
  3040. */
  3041. static int remove_from_transaction(struct super_block *p_s_sb,
  3042. b_blocknr_t blocknr, int already_cleaned)
  3043. {
  3044. struct buffer_head *bh;
  3045. struct reiserfs_journal_cnode *cn;
  3046. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  3047. int ret = 0;
  3048. cn = get_journal_hash_dev(p_s_sb, journal->j_hash_table, blocknr);
  3049. if (!cn || !cn->bh) {
  3050. return ret;
  3051. }
  3052. bh = cn->bh;
  3053. if (cn->prev) {
  3054. cn->prev->next = cn->next;
  3055. }
  3056. if (cn->next) {
  3057. cn->next->prev = cn->prev;
  3058. }
  3059. if (cn == journal->j_first) {
  3060. journal->j_first = cn->next;
  3061. }
  3062. if (cn == journal->j_last) {
  3063. journal->j_last = cn->prev;
  3064. }
  3065. if (bh)
  3066. remove_journal_hash(p_s_sb, journal->j_hash_table, NULL,
  3067. bh->b_blocknr, 0);
  3068. clear_buffer_journaled(bh); /* don't log this one */
  3069. if (!already_cleaned) {
  3070. clear_buffer_journal_dirty(bh);
  3071. clear_buffer_dirty(bh);
  3072. clear_buffer_journal_test(bh);
  3073. put_bh(bh);
  3074. if (atomic_read(&(bh->b_count)) < 0) {
  3075. reiserfs_warning(p_s_sb,
  3076. "journal-1752: remove from trans, b_count < 0");
  3077. }
  3078. ret = 1;
  3079. }
  3080. journal->j_len--;
  3081. journal->j_len_alloc--;
  3082. free_cnode(p_s_sb, cn);
  3083. return ret;
  3084. }
  3085. /*
  3086. ** for any cnode in a journal list, it can only be dirtied of all the
  3087. ** transactions that include it are committed to disk.
  3088. ** this checks through each transaction, and returns 1 if you are allowed to dirty,
  3089. ** and 0 if you aren't
  3090. **
  3091. ** it is called by dirty_journal_list, which is called after flush_commit_list has gotten all the log
  3092. ** blocks for a given transaction on disk
  3093. **
  3094. */
  3095. static int can_dirty(struct reiserfs_journal_cnode *cn)
  3096. {
  3097. struct super_block *sb = cn->sb;
  3098. b_blocknr_t blocknr = cn->blocknr;
  3099. struct reiserfs_journal_cnode *cur = cn->hprev;
  3100. int can_dirty = 1;
  3101. /* first test hprev. These are all newer than cn, so any node here
  3102. ** with the same block number and dev means this node can't be sent
  3103. ** to disk right now.
  3104. */
  3105. while (cur && can_dirty) {
  3106. if (cur->jlist && cur->bh && cur->blocknr && cur->sb == sb &&
  3107. cur->blocknr == blocknr) {
  3108. can_dirty = 0;
  3109. }
  3110. cur = cur->hprev;
  3111. }
  3112. /* then test hnext. These are all older than cn. As long as they
  3113. ** are committed to the log, it is safe to write cn to disk
  3114. */
  3115. cur = cn->hnext;
  3116. while (cur && can_dirty) {
  3117. if (cur->jlist && cur->jlist->j_len > 0 &&
  3118. atomic_read(&(cur->jlist->j_commit_left)) > 0 && cur->bh &&
  3119. cur->blocknr && cur->sb == sb && cur->blocknr == blocknr) {
  3120. can_dirty = 0;
  3121. }
  3122. cur = cur->hnext;
  3123. }
  3124. return can_dirty;
  3125. }
  3126. /* syncs the commit blocks, but does not force the real buffers to disk
  3127. ** will wait until the current transaction is done/committed before returning
  3128. */
  3129. int journal_end_sync(struct reiserfs_transaction_handle *th,
  3130. struct super_block *p_s_sb, unsigned long nblocks)
  3131. {
  3132. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  3133. BUG_ON(!th->t_trans_id);
  3134. /* you can sync while nested, very, very bad */
  3135. BUG_ON(th->t_refcount > 1);
  3136. if (journal->j_len == 0) {
  3137. reiserfs_prepare_for_journal(p_s_sb, SB_BUFFER_WITH_SB(p_s_sb),
  3138. 1);
  3139. journal_mark_dirty(th, p_s_sb, SB_BUFFER_WITH_SB(p_s_sb));
  3140. }
  3141. return do_journal_end(th, p_s_sb, nblocks, COMMIT_NOW | WAIT);
  3142. }
  3143. /*
  3144. ** writeback the pending async commits to disk
  3145. */
  3146. static void flush_async_commits(struct work_struct *work)
  3147. {
  3148. struct reiserfs_journal *journal =
  3149. container_of(work, struct reiserfs_journal, j_work.work);
  3150. struct super_block *p_s_sb = journal->j_work_sb;
  3151. struct reiserfs_journal_list *jl;
  3152. struct list_head *entry;
  3153. lock_kernel();
  3154. if (!list_empty(&journal->j_journal_list)) {
  3155. /* last entry is the youngest, commit it and you get everything */
  3156. entry = journal->j_journal_list.prev;
  3157. jl = JOURNAL_LIST_ENTRY(entry);
  3158. flush_commit_list(p_s_sb, jl, 1);
  3159. }
  3160. unlock_kernel();
  3161. }
  3162. /*
  3163. ** flushes any old transactions to disk
  3164. ** ends the current transaction if it is too old
  3165. */
  3166. int reiserfs_flush_old_commits(struct super_block *p_s_sb)
  3167. {
  3168. time_t now;
  3169. struct reiserfs_transaction_handle th;
  3170. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  3171. now = get_seconds();
  3172. /* safety check so we don't flush while we are replaying the log during
  3173. * mount
  3174. */
  3175. if (list_empty(&journal->j_journal_list)) {
  3176. return 0;
  3177. }
  3178. /* check the current transaction. If there are no writers, and it is
  3179. * too old, finish it, and force the commit blocks to disk
  3180. */
  3181. if (atomic_read(&journal->j_wcount) <= 0 &&
  3182. journal->j_trans_start_time > 0 &&
  3183. journal->j_len > 0 &&
  3184. (now - journal->j_trans_start_time) > journal->j_max_trans_age) {
  3185. if (!journal_join(&th, p_s_sb, 1)) {
  3186. reiserfs_prepare_for_journal(p_s_sb,
  3187. SB_BUFFER_WITH_SB(p_s_sb),
  3188. 1);
  3189. journal_mark_dirty(&th, p_s_sb,
  3190. SB_BUFFER_WITH_SB(p_s_sb));
  3191. /* we're only being called from kreiserfsd, it makes no sense to do
  3192. ** an async commit so that kreiserfsd can do it later
  3193. */
  3194. do_journal_end(&th, p_s_sb, 1, COMMIT_NOW | WAIT);
  3195. }
  3196. }
  3197. return p_s_sb->s_dirt;
  3198. }
  3199. /*
  3200. ** returns 0 if do_journal_end should return right away, returns 1 if do_journal_end should finish the commit
  3201. **
  3202. ** if the current transaction is too old, but still has writers, this will wait on j_join_wait until all
  3203. ** the writers are done. By the time it wakes up, the transaction it was called has already ended, so it just
  3204. ** flushes the commit list and returns 0.
  3205. **
  3206. ** Won't batch when flush or commit_now is set. Also won't batch when others are waiting on j_join_wait.
  3207. **
  3208. ** Note, we can't allow the journal_end to proceed while there are still writers in the log.
  3209. */
  3210. static int check_journal_end(struct reiserfs_transaction_handle *th,
  3211. struct super_block *p_s_sb, unsigned long nblocks,
  3212. int flags)
  3213. {
  3214. time_t now;
  3215. int flush = flags & FLUSH_ALL;
  3216. int commit_now = flags & COMMIT_NOW;
  3217. int wait_on_commit = flags & WAIT;
  3218. struct reiserfs_journal_list *jl;
  3219. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  3220. BUG_ON(!th->t_trans_id);
  3221. if (th->t_trans_id != journal->j_trans_id) {
  3222. reiserfs_panic(th->t_super,
  3223. "journal-1577: handle trans id %ld != current trans id %ld\n",
  3224. th->t_trans_id, journal->j_trans_id);
  3225. }
  3226. journal->j_len_alloc -= (th->t_blocks_allocated - th->t_blocks_logged);
  3227. if (atomic_read(&(journal->j_wcount)) > 0) { /* <= 0 is allowed. unmounting might not call begin */
  3228. atomic_dec(&(journal->j_wcount));
  3229. }
  3230. /* BUG, deal with case where j_len is 0, but people previously freed blocks need to be released
  3231. ** will be dealt with by next transaction that actually writes something, but should be taken
  3232. ** care of in this trans
  3233. */
  3234. BUG_ON(journal->j_len == 0);
  3235. /* if wcount > 0, and we are called to with flush or commit_now,
  3236. ** we wait on j_join_wait. We will wake up when the last writer has
  3237. ** finished the transaction, and started it on its way to the disk.
  3238. ** Then, we flush the commit or journal list, and just return 0
  3239. ** because the rest of journal end was already done for this transaction.
  3240. */
  3241. if (atomic_read(&(journal->j_wcount)) > 0) {
  3242. if (flush || commit_now) {
  3243. unsigned trans_id;
  3244. jl = journal->j_current_jl;
  3245. trans_id = jl->j_trans_id;
  3246. if (wait_on_commit)
  3247. jl->j_state |= LIST_COMMIT_PENDING;
  3248. atomic_set(&(journal->j_jlock), 1);
  3249. if (flush) {
  3250. journal->j_next_full_flush = 1;
  3251. }
  3252. unlock_journal(p_s_sb);
  3253. /* sleep while the current transaction is still j_jlocked */
  3254. while (journal->j_trans_id == trans_id) {
  3255. if (atomic_read(&journal->j_jlock)) {
  3256. queue_log_writer(p_s_sb);
  3257. } else {
  3258. lock_journal(p_s_sb);
  3259. if (journal->j_trans_id == trans_id) {
  3260. atomic_set(&(journal->j_jlock),
  3261. 1);
  3262. }
  3263. unlock_journal(p_s_sb);
  3264. }
  3265. }
  3266. BUG_ON(journal->j_trans_id == trans_id);
  3267. if (commit_now
  3268. && journal_list_still_alive(p_s_sb, trans_id)
  3269. && wait_on_commit) {
  3270. flush_commit_list(p_s_sb, jl, 1);
  3271. }
  3272. return 0;
  3273. }
  3274. unlock_journal(p_s_sb);
  3275. return 0;
  3276. }
  3277. /* deal with old transactions where we are the last writers */
  3278. now = get_seconds();
  3279. if ((now - journal->j_trans_start_time) > journal->j_max_trans_age) {
  3280. commit_now = 1;
  3281. journal->j_next_async_flush = 1;
  3282. }
  3283. /* don't batch when someone is waiting on j_join_wait */
  3284. /* don't batch when syncing the commit or flushing the whole trans */
  3285. if (!(journal->j_must_wait > 0) && !(atomic_read(&(journal->j_jlock)))
  3286. && !flush && !commit_now && (journal->j_len < journal->j_max_batch)
  3287. && journal->j_len_alloc < journal->j_max_batch
  3288. && journal->j_cnode_free > (journal->j_trans_max * 3)) {
  3289. journal->j_bcount++;
  3290. unlock_journal(p_s_sb);
  3291. return 0;
  3292. }
  3293. if (journal->j_start > SB_ONDISK_JOURNAL_SIZE(p_s_sb)) {
  3294. reiserfs_panic(p_s_sb,
  3295. "journal-003: journal_end: j_start (%ld) is too high\n",
  3296. journal->j_start);
  3297. }
  3298. return 1;
  3299. }
  3300. /*
  3301. ** Does all the work that makes deleting blocks safe.
  3302. ** when deleting a block mark BH_JNew, just remove it from the current transaction, clean it's buffer_head and move on.
  3303. **
  3304. ** otherwise:
  3305. ** set a bit for the block in the journal bitmap. That will prevent it from being allocated for unformatted nodes
  3306. ** before this transaction has finished.
  3307. **
  3308. ** mark any cnodes for this block as BLOCK_FREED, and clear their bh pointers. That will prevent any old transactions with
  3309. ** this block from trying to flush to the real location. Since we aren't removing the cnode from the journal_list_hash,
  3310. ** the block can't be reallocated yet.
  3311. **
  3312. ** Then remove it from the current transaction, decrementing any counters and filing it on the clean list.
  3313. */
  3314. int journal_mark_freed(struct reiserfs_transaction_handle *th,
  3315. struct super_block *p_s_sb, b_blocknr_t blocknr)
  3316. {
  3317. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  3318. struct reiserfs_journal_cnode *cn = NULL;
  3319. struct buffer_head *bh = NULL;
  3320. struct reiserfs_list_bitmap *jb = NULL;
  3321. int cleaned = 0;
  3322. BUG_ON(!th->t_trans_id);
  3323. cn = get_journal_hash_dev(p_s_sb, journal->j_hash_table, blocknr);
  3324. if (cn && cn->bh) {
  3325. bh = cn->bh;
  3326. get_bh(bh);
  3327. }
  3328. /* if it is journal new, we just remove it from this transaction */
  3329. if (bh && buffer_journal_new(bh)) {
  3330. clear_buffer_journal_new(bh);
  3331. clear_prepared_bits(bh);
  3332. reiserfs_clean_and_file_buffer(bh);
  3333. cleaned = remove_from_transaction(p_s_sb, blocknr, cleaned);
  3334. } else {
  3335. /* set the bit for this block in the journal bitmap for this transaction */
  3336. jb = journal->j_current_jl->j_list_bitmap;
  3337. if (!jb) {
  3338. reiserfs_panic(p_s_sb,
  3339. "journal-1702: journal_mark_freed, journal_list_bitmap is NULL\n");
  3340. }
  3341. set_bit_in_list_bitmap(p_s_sb, blocknr, jb);
  3342. /* Note, the entire while loop is not allowed to schedule. */
  3343. if (bh) {
  3344. clear_prepared_bits(bh);
  3345. reiserfs_clean_and_file_buffer(bh);
  3346. }
  3347. cleaned = remove_from_transaction(p_s_sb, blocknr, cleaned);
  3348. /* find all older transactions with this block, make sure they don't try to write it out */
  3349. cn = get_journal_hash_dev(p_s_sb, journal->j_list_hash_table,
  3350. blocknr);
  3351. while (cn) {
  3352. if (p_s_sb == cn->sb && blocknr == cn->blocknr) {
  3353. set_bit(BLOCK_FREED, &cn->state);
  3354. if (cn->bh) {
  3355. if (!cleaned) {
  3356. /* remove_from_transaction will brelse the buffer if it was
  3357. ** in the current trans
  3358. */
  3359. clear_buffer_journal_dirty(cn->
  3360. bh);
  3361. clear_buffer_dirty(cn->bh);
  3362. clear_buffer_journal_test(cn->
  3363. bh);
  3364. cleaned = 1;
  3365. put_bh(cn->bh);
  3366. if (atomic_read
  3367. (&(cn->bh->b_count)) < 0) {
  3368. reiserfs_warning(p_s_sb,
  3369. "journal-2138: cn->bh->b_count < 0");
  3370. }
  3371. }
  3372. if (cn->jlist) { /* since we are clearing the bh, we MUST dec nonzerolen */
  3373. atomic_dec(&
  3374. (cn->jlist->
  3375. j_nonzerolen));
  3376. }
  3377. cn->bh = NULL;
  3378. }
  3379. }
  3380. cn = cn->hnext;
  3381. }
  3382. }
  3383. if (bh) {
  3384. put_bh(bh); /* get_hash grabs the buffer */
  3385. if (atomic_read(&(bh->b_count)) < 0) {
  3386. reiserfs_warning(p_s_sb,
  3387. "journal-2165: bh->b_count < 0");
  3388. }
  3389. }
  3390. return 0;
  3391. }
  3392. void reiserfs_update_inode_transaction(struct inode *inode)
  3393. {
  3394. struct reiserfs_journal *journal = SB_JOURNAL(inode->i_sb);
  3395. REISERFS_I(inode)->i_jl = journal->j_current_jl;
  3396. REISERFS_I(inode)->i_trans_id = journal->j_trans_id;
  3397. }
  3398. /*
  3399. * returns -1 on error, 0 if no commits/barriers were done and 1
  3400. * if a transaction was actually committed and the barrier was done
  3401. */
  3402. static int __commit_trans_jl(struct inode *inode, unsigned long id,
  3403. struct reiserfs_journal_list *jl)
  3404. {
  3405. struct reiserfs_transaction_handle th;
  3406. struct super_block *sb = inode->i_sb;
  3407. struct reiserfs_journal *journal = SB_JOURNAL(sb);
  3408. int ret = 0;
  3409. /* is it from the current transaction, or from an unknown transaction? */
  3410. if (id == journal->j_trans_id) {
  3411. jl = journal->j_current_jl;
  3412. /* try to let other writers come in and grow this transaction */
  3413. let_transaction_grow(sb, id);
  3414. if (journal->j_trans_id != id) {
  3415. goto flush_commit_only;
  3416. }
  3417. ret = journal_begin(&th, sb, 1);
  3418. if (ret)
  3419. return ret;
  3420. /* someone might have ended this transaction while we joined */
  3421. if (journal->j_trans_id != id) {
  3422. reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
  3423. 1);
  3424. journal_mark_dirty(&th, sb, SB_BUFFER_WITH_SB(sb));
  3425. ret = journal_end(&th, sb, 1);
  3426. goto flush_commit_only;
  3427. }
  3428. ret = journal_end_sync(&th, sb, 1);
  3429. if (!ret)
  3430. ret = 1;
  3431. } else {
  3432. /* this gets tricky, we have to make sure the journal list in
  3433. * the inode still exists. We know the list is still around
  3434. * if we've got a larger transaction id than the oldest list
  3435. */
  3436. flush_commit_only:
  3437. if (journal_list_still_alive(inode->i_sb, id)) {
  3438. /*
  3439. * we only set ret to 1 when we know for sure
  3440. * the barrier hasn't been started yet on the commit
  3441. * block.
  3442. */
  3443. if (atomic_read(&jl->j_commit_left) > 1)
  3444. ret = 1;
  3445. flush_commit_list(sb, jl, 1);
  3446. if (journal->j_errno)
  3447. ret = journal->j_errno;
  3448. }
  3449. }
  3450. /* otherwise the list is gone, and long since committed */
  3451. return ret;
  3452. }
  3453. int reiserfs_commit_for_inode(struct inode *inode)
  3454. {
  3455. unsigned long id = REISERFS_I(inode)->i_trans_id;
  3456. struct reiserfs_journal_list *jl = REISERFS_I(inode)->i_jl;
  3457. /* for the whole inode, assume unset id means it was
  3458. * changed in the current transaction. More conservative
  3459. */
  3460. if (!id || !jl) {
  3461. reiserfs_update_inode_transaction(inode);
  3462. id = REISERFS_I(inode)->i_trans_id;
  3463. /* jl will be updated in __commit_trans_jl */
  3464. }
  3465. return __commit_trans_jl(inode, id, jl);
  3466. }
  3467. void reiserfs_restore_prepared_buffer(struct super_block *p_s_sb,
  3468. struct buffer_head *bh)
  3469. {
  3470. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  3471. PROC_INFO_INC(p_s_sb, journal.restore_prepared);
  3472. if (!bh) {
  3473. return;
  3474. }
  3475. if (test_clear_buffer_journal_restore_dirty(bh) &&
  3476. buffer_journal_dirty(bh)) {
  3477. struct reiserfs_journal_cnode *cn;
  3478. cn = get_journal_hash_dev(p_s_sb,
  3479. journal->j_list_hash_table,
  3480. bh->b_blocknr);
  3481. if (cn && can_dirty(cn)) {
  3482. set_buffer_journal_test(bh);
  3483. mark_buffer_dirty(bh);
  3484. }
  3485. }
  3486. clear_buffer_journal_prepared(bh);
  3487. }
  3488. extern struct tree_balance *cur_tb;
  3489. /*
  3490. ** before we can change a metadata block, we have to make sure it won't
  3491. ** be written to disk while we are altering it. So, we must:
  3492. ** clean it
  3493. ** wait on it.
  3494. **
  3495. */
  3496. int reiserfs_prepare_for_journal(struct super_block *p_s_sb,
  3497. struct buffer_head *bh, int wait)
  3498. {
  3499. PROC_INFO_INC(p_s_sb, journal.prepare);
  3500. if (test_set_buffer_locked(bh)) {
  3501. if (!wait)
  3502. return 0;
  3503. lock_buffer(bh);
  3504. }
  3505. set_buffer_journal_prepared(bh);
  3506. if (test_clear_buffer_dirty(bh) && buffer_journal_dirty(bh)) {
  3507. clear_buffer_journal_test(bh);
  3508. set_buffer_journal_restore_dirty(bh);
  3509. }
  3510. unlock_buffer(bh);
  3511. return 1;
  3512. }
  3513. static void flush_old_journal_lists(struct super_block *s)
  3514. {
  3515. struct reiserfs_journal *journal = SB_JOURNAL(s);
  3516. struct reiserfs_journal_list *jl;
  3517. struct list_head *entry;
  3518. time_t now = get_seconds();
  3519. while (!list_empty(&journal->j_journal_list)) {
  3520. entry = journal->j_journal_list.next;
  3521. jl = JOURNAL_LIST_ENTRY(entry);
  3522. /* this check should always be run, to send old lists to disk */
  3523. if (jl->j_timestamp < (now - (JOURNAL_MAX_TRANS_AGE * 4)) &&
  3524. atomic_read(&jl->j_commit_left) == 0 &&
  3525. test_transaction(s, jl)) {
  3526. flush_used_journal_lists(s, jl);
  3527. } else {
  3528. break;
  3529. }
  3530. }
  3531. }
  3532. /*
  3533. ** long and ugly. If flush, will not return until all commit
  3534. ** blocks and all real buffers in the trans are on disk.
  3535. ** If no_async, won't return until all commit blocks are on disk.
  3536. **
  3537. ** keep reading, there are comments as you go along
  3538. **
  3539. ** If the journal is aborted, we just clean up. Things like flushing
  3540. ** journal lists, etc just won't happen.
  3541. */
  3542. static int do_journal_end(struct reiserfs_transaction_handle *th,
  3543. struct super_block *p_s_sb, unsigned long nblocks,
  3544. int flags)
  3545. {
  3546. struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
  3547. struct reiserfs_journal_cnode *cn, *next, *jl_cn;
  3548. struct reiserfs_journal_cnode *last_cn = NULL;
  3549. struct reiserfs_journal_desc *desc;
  3550. struct reiserfs_journal_commit *commit;
  3551. struct buffer_head *c_bh; /* commit bh */
  3552. struct buffer_head *d_bh; /* desc bh */
  3553. int cur_write_start = 0; /* start index of current log write */
  3554. int old_start;
  3555. int i;
  3556. int flush;
  3557. int wait_on_commit;
  3558. struct reiserfs_journal_list *jl, *temp_jl;
  3559. struct list_head *entry, *safe;
  3560. unsigned long jindex;
  3561. unsigned long commit_trans_id;
  3562. int trans_half;
  3563. BUG_ON(th->t_refcount > 1);
  3564. BUG_ON(!th->t_trans_id);
  3565. /* protect flush_older_commits from doing mistakes if the
  3566. transaction ID counter gets overflowed. */
  3567. if (th->t_trans_id == ~0UL)
  3568. flags |= FLUSH_ALL | COMMIT_NOW | WAIT;
  3569. flush = flags & FLUSH_ALL;
  3570. wait_on_commit = flags & WAIT;
  3571. put_fs_excl();
  3572. current->journal_info = th->t_handle_save;
  3573. reiserfs_check_lock_depth(p_s_sb, "journal end");
  3574. if (journal->j_len == 0) {
  3575. reiserfs_prepare_for_journal(p_s_sb, SB_BUFFER_WITH_SB(p_s_sb),
  3576. 1);
  3577. journal_mark_dirty(th, p_s_sb, SB_BUFFER_WITH_SB(p_s_sb));
  3578. }
  3579. lock_journal(p_s_sb);
  3580. if (journal->j_next_full_flush) {
  3581. flags |= FLUSH_ALL;
  3582. flush = 1;
  3583. }
  3584. if (journal->j_next_async_flush) {
  3585. flags |= COMMIT_NOW | WAIT;
  3586. wait_on_commit = 1;
  3587. }
  3588. /* check_journal_end locks the journal, and unlocks if it does not return 1
  3589. ** it tells us if we should continue with the journal_end, or just return
  3590. */
  3591. if (!check_journal_end(th, p_s_sb, nblocks, flags)) {
  3592. p_s_sb->s_dirt = 1;
  3593. wake_queued_writers(p_s_sb);
  3594. reiserfs_async_progress_wait(p_s_sb);
  3595. goto out;
  3596. }
  3597. /* check_journal_end might set these, check again */
  3598. if (journal->j_next_full_flush) {
  3599. flush = 1;
  3600. }
  3601. /*
  3602. ** j must wait means we have to flush the log blocks, and the real blocks for
  3603. ** this transaction
  3604. */
  3605. if (journal->j_must_wait > 0) {
  3606. flush = 1;
  3607. }
  3608. #ifdef REISERFS_PREALLOCATE
  3609. /* quota ops might need to nest, setup the journal_info pointer for them
  3610. * and raise the refcount so that it is > 0. */
  3611. current->journal_info = th;
  3612. th->t_refcount++;
  3613. reiserfs_discard_all_prealloc(th); /* it should not involve new blocks into
  3614. * the transaction */
  3615. th->t_refcount--;
  3616. current->journal_info = th->t_handle_save;
  3617. #endif
  3618. /* setup description block */
  3619. d_bh =
  3620. journal_getblk(p_s_sb,
  3621. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  3622. journal->j_start);
  3623. set_buffer_uptodate(d_bh);
  3624. desc = (struct reiserfs_journal_desc *)(d_bh)->b_data;
  3625. memset(d_bh->b_data, 0, d_bh->b_size);
  3626. memcpy(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8);
  3627. set_desc_trans_id(desc, journal->j_trans_id);
  3628. /* setup commit block. Don't write (keep it clean too) this one until after everyone else is written */
  3629. c_bh = journal_getblk(p_s_sb, SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  3630. ((journal->j_start + journal->j_len +
  3631. 1) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)));
  3632. commit = (struct reiserfs_journal_commit *)c_bh->b_data;
  3633. memset(c_bh->b_data, 0, c_bh->b_size);
  3634. set_commit_trans_id(commit, journal->j_trans_id);
  3635. set_buffer_uptodate(c_bh);
  3636. /* init this journal list */
  3637. jl = journal->j_current_jl;
  3638. /* we lock the commit before doing anything because
  3639. * we want to make sure nobody tries to run flush_commit_list until
  3640. * the new transaction is fully setup, and we've already flushed the
  3641. * ordered bh list
  3642. */
  3643. down(&jl->j_commit_lock);
  3644. /* save the transaction id in case we need to commit it later */
  3645. commit_trans_id = jl->j_trans_id;
  3646. atomic_set(&jl->j_older_commits_done, 0);
  3647. jl->j_trans_id = journal->j_trans_id;
  3648. jl->j_timestamp = journal->j_trans_start_time;
  3649. jl->j_commit_bh = c_bh;
  3650. jl->j_start = journal->j_start;
  3651. jl->j_len = journal->j_len;
  3652. atomic_set(&jl->j_nonzerolen, journal->j_len);
  3653. atomic_set(&jl->j_commit_left, journal->j_len + 2);
  3654. jl->j_realblock = NULL;
  3655. /* The ENTIRE FOR LOOP MUST not cause schedule to occur.
  3656. ** for each real block, add it to the journal list hash,
  3657. ** copy into real block index array in the commit or desc block
  3658. */
  3659. trans_half = journal_trans_half(p_s_sb->s_blocksize);
  3660. for (i = 0, cn = journal->j_first; cn; cn = cn->next, i++) {
  3661. if (buffer_journaled(cn->bh)) {
  3662. jl_cn = get_cnode(p_s_sb);
  3663. if (!jl_cn) {
  3664. reiserfs_panic(p_s_sb,
  3665. "journal-1676, get_cnode returned NULL\n");
  3666. }
  3667. if (i == 0) {
  3668. jl->j_realblock = jl_cn;
  3669. }
  3670. jl_cn->prev = last_cn;
  3671. jl_cn->next = NULL;
  3672. if (last_cn) {
  3673. last_cn->next = jl_cn;
  3674. }
  3675. last_cn = jl_cn;
  3676. /* make sure the block we are trying to log is not a block
  3677. of journal or reserved area */
  3678. if (is_block_in_log_or_reserved_area
  3679. (p_s_sb, cn->bh->b_blocknr)) {
  3680. reiserfs_panic(p_s_sb,
  3681. "journal-2332: Trying to log block %lu, which is a log block\n",
  3682. cn->bh->b_blocknr);
  3683. }
  3684. jl_cn->blocknr = cn->bh->b_blocknr;
  3685. jl_cn->state = 0;
  3686. jl_cn->sb = p_s_sb;
  3687. jl_cn->bh = cn->bh;
  3688. jl_cn->jlist = jl;
  3689. insert_journal_hash(journal->j_list_hash_table, jl_cn);
  3690. if (i < trans_half) {
  3691. desc->j_realblock[i] =
  3692. cpu_to_le32(cn->bh->b_blocknr);
  3693. } else {
  3694. commit->j_realblock[i - trans_half] =
  3695. cpu_to_le32(cn->bh->b_blocknr);
  3696. }
  3697. } else {
  3698. i--;
  3699. }
  3700. }
  3701. set_desc_trans_len(desc, journal->j_len);
  3702. set_desc_mount_id(desc, journal->j_mount_id);
  3703. set_desc_trans_id(desc, journal->j_trans_id);
  3704. set_commit_trans_len(commit, journal->j_len);
  3705. /* special check in case all buffers in the journal were marked for not logging */
  3706. BUG_ON(journal->j_len == 0);
  3707. /* we're about to dirty all the log blocks, mark the description block
  3708. * dirty now too. Don't mark the commit block dirty until all the
  3709. * others are on disk
  3710. */
  3711. mark_buffer_dirty(d_bh);
  3712. /* first data block is j_start + 1, so add one to cur_write_start wherever you use it */
  3713. cur_write_start = journal->j_start;
  3714. cn = journal->j_first;
  3715. jindex = 1; /* start at one so we don't get the desc again */
  3716. while (cn) {
  3717. clear_buffer_journal_new(cn->bh);
  3718. /* copy all the real blocks into log area. dirty log blocks */
  3719. if (buffer_journaled(cn->bh)) {
  3720. struct buffer_head *tmp_bh;
  3721. char *addr;
  3722. struct page *page;
  3723. tmp_bh =
  3724. journal_getblk(p_s_sb,
  3725. SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
  3726. ((cur_write_start +
  3727. jindex) %
  3728. SB_ONDISK_JOURNAL_SIZE(p_s_sb)));
  3729. set_buffer_uptodate(tmp_bh);
  3730. page = cn->bh->b_page;
  3731. addr = kmap(page);
  3732. memcpy(tmp_bh->b_data,
  3733. addr + offset_in_page(cn->bh->b_data),
  3734. cn->bh->b_size);
  3735. kunmap(page);
  3736. mark_buffer_dirty(tmp_bh);
  3737. jindex++;
  3738. set_buffer_journal_dirty(cn->bh);
  3739. clear_buffer_journaled(cn->bh);
  3740. } else {
  3741. /* JDirty cleared sometime during transaction. don't log this one */
  3742. reiserfs_warning(p_s_sb,
  3743. "journal-2048: do_journal_end: BAD, buffer in journal hash, but not JDirty!");
  3744. brelse(cn->bh);
  3745. }
  3746. next = cn->next;
  3747. free_cnode(p_s_sb, cn);
  3748. cn = next;
  3749. cond_resched();
  3750. }
  3751. /* we are done with both the c_bh and d_bh, but
  3752. ** c_bh must be written after all other commit blocks,
  3753. ** so we dirty/relse c_bh in flush_commit_list, with commit_left <= 1.
  3754. */
  3755. journal->j_current_jl = alloc_journal_list(p_s_sb);
  3756. /* now it is safe to insert this transaction on the main list */
  3757. list_add_tail(&jl->j_list, &journal->j_journal_list);
  3758. list_add_tail(&jl->j_working_list, &journal->j_working_list);
  3759. journal->j_num_work_lists++;
  3760. /* reset journal values for the next transaction */
  3761. old_start = journal->j_start;
  3762. journal->j_start =
  3763. (journal->j_start + journal->j_len +
  3764. 2) % SB_ONDISK_JOURNAL_SIZE(p_s_sb);
  3765. atomic_set(&(journal->j_wcount), 0);
  3766. journal->j_bcount = 0;
  3767. journal->j_last = NULL;
  3768. journal->j_first = NULL;
  3769. journal->j_len = 0;
  3770. journal->j_trans_start_time = 0;
  3771. /* check for trans_id overflow */
  3772. if (++journal->j_trans_id == 0)
  3773. journal->j_trans_id = 10;
  3774. journal->j_current_jl->j_trans_id = journal->j_trans_id;
  3775. journal->j_must_wait = 0;
  3776. journal->j_len_alloc = 0;
  3777. journal->j_next_full_flush = 0;
  3778. journal->j_next_async_flush = 0;
  3779. init_journal_hash(p_s_sb);
  3780. // make sure reiserfs_add_jh sees the new current_jl before we
  3781. // write out the tails
  3782. smp_mb();
  3783. /* tail conversion targets have to hit the disk before we end the
  3784. * transaction. Otherwise a later transaction might repack the tail
  3785. * before this transaction commits, leaving the data block unflushed and
  3786. * clean, if we crash before the later transaction commits, the data block
  3787. * is lost.
  3788. */
  3789. if (!list_empty(&jl->j_tail_bh_list)) {
  3790. unlock_kernel();
  3791. write_ordered_buffers(&journal->j_dirty_buffers_lock,
  3792. journal, jl, &jl->j_tail_bh_list);
  3793. lock_kernel();
  3794. }
  3795. BUG_ON(!list_empty(&jl->j_tail_bh_list));
  3796. up(&jl->j_commit_lock);
  3797. /* honor the flush wishes from the caller, simple commits can
  3798. ** be done outside the journal lock, they are done below
  3799. **
  3800. ** if we don't flush the commit list right now, we put it into
  3801. ** the work queue so the people waiting on the async progress work
  3802. ** queue don't wait for this proc to flush journal lists and such.
  3803. */
  3804. if (flush) {
  3805. flush_commit_list(p_s_sb, jl, 1);
  3806. flush_journal_list(p_s_sb, jl, 1);
  3807. } else if (!(jl->j_state & LIST_COMMIT_PENDING))
  3808. queue_delayed_work(commit_wq, &journal->j_work, HZ / 10);
  3809. /* if the next transaction has any chance of wrapping, flush
  3810. ** transactions that might get overwritten. If any journal lists are very
  3811. ** old flush them as well.
  3812. */
  3813. first_jl:
  3814. list_for_each_safe(entry, safe, &journal->j_journal_list) {
  3815. temp_jl = JOURNAL_LIST_ENTRY(entry);
  3816. if (journal->j_start <= temp_jl->j_start) {
  3817. if ((journal->j_start + journal->j_trans_max + 1) >=
  3818. temp_jl->j_start) {
  3819. flush_used_journal_lists(p_s_sb, temp_jl);
  3820. goto first_jl;
  3821. } else if ((journal->j_start +
  3822. journal->j_trans_max + 1) <
  3823. SB_ONDISK_JOURNAL_SIZE(p_s_sb)) {
  3824. /* if we don't cross into the next transaction and we don't
  3825. * wrap, there is no way we can overlap any later transactions
  3826. * break now
  3827. */
  3828. break;
  3829. }
  3830. } else if ((journal->j_start +
  3831. journal->j_trans_max + 1) >
  3832. SB_ONDISK_JOURNAL_SIZE(p_s_sb)) {
  3833. if (((journal->j_start + journal->j_trans_max + 1) %
  3834. SB_ONDISK_JOURNAL_SIZE(p_s_sb)) >=
  3835. temp_jl->j_start) {
  3836. flush_used_journal_lists(p_s_sb, temp_jl);
  3837. goto first_jl;
  3838. } else {
  3839. /* we don't overlap anything from out start to the end of the
  3840. * log, and our wrapped portion doesn't overlap anything at
  3841. * the start of the log. We can break
  3842. */
  3843. break;
  3844. }
  3845. }
  3846. }
  3847. flush_old_journal_lists(p_s_sb);
  3848. journal->j_current_jl->j_list_bitmap =
  3849. get_list_bitmap(p_s_sb, journal->j_current_jl);
  3850. if (!(journal->j_current_jl->j_list_bitmap)) {
  3851. reiserfs_panic(p_s_sb,
  3852. "journal-1996: do_journal_end, could not get a list bitmap\n");
  3853. }
  3854. atomic_set(&(journal->j_jlock), 0);
  3855. unlock_journal(p_s_sb);
  3856. /* wake up any body waiting to join. */
  3857. clear_bit(J_WRITERS_QUEUED, &journal->j_state);
  3858. wake_up(&(journal->j_join_wait));
  3859. if (!flush && wait_on_commit &&
  3860. journal_list_still_alive(p_s_sb, commit_trans_id)) {
  3861. flush_commit_list(p_s_sb, jl, 1);
  3862. }
  3863. out:
  3864. reiserfs_check_lock_depth(p_s_sb, "journal end2");
  3865. memset(th, 0, sizeof(*th));
  3866. /* Re-set th->t_super, so we can properly keep track of how many
  3867. * persistent transactions there are. We need to do this so if this
  3868. * call is part of a failed restart_transaction, we can free it later */
  3869. th->t_super = p_s_sb;
  3870. return journal->j_errno;
  3871. }
  3872. static void __reiserfs_journal_abort_hard(struct super_block *sb)
  3873. {
  3874. struct reiserfs_journal *journal = SB_JOURNAL(sb);
  3875. if (test_bit(J_ABORTED, &journal->j_state))
  3876. return;
  3877. printk(KERN_CRIT "REISERFS: Aborting journal for filesystem on %s\n",
  3878. reiserfs_bdevname(sb));
  3879. sb->s_flags |= MS_RDONLY;
  3880. set_bit(J_ABORTED, &journal->j_state);
  3881. #ifdef CONFIG_REISERFS_CHECK
  3882. dump_stack();
  3883. #endif
  3884. }
  3885. static void __reiserfs_journal_abort_soft(struct super_block *sb, int errno)
  3886. {
  3887. struct reiserfs_journal *journal = SB_JOURNAL(sb);
  3888. if (test_bit(J_ABORTED, &journal->j_state))
  3889. return;
  3890. if (!journal->j_errno)
  3891. journal->j_errno = errno;
  3892. __reiserfs_journal_abort_hard(sb);
  3893. }
  3894. void reiserfs_journal_abort(struct super_block *sb, int errno)
  3895. {
  3896. return __reiserfs_journal_abort_soft(sb, errno);
  3897. }