journal.c 55 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073
  1. /*
  2. * linux/fs/jbd/journal.c
  3. *
  4. * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
  5. *
  6. * Copyright 1998 Red Hat corp --- All Rights Reserved
  7. *
  8. * This file is part of the Linux kernel and is made available under
  9. * the terms of the GNU General Public License, version 2, or at your
  10. * option, any later version, incorporated herein by reference.
  11. *
  12. * Generic filesystem journal-writing code; part of the ext2fs
  13. * journaling system.
  14. *
  15. * This file manages journals: areas of disk reserved for logging
  16. * transactional updates. This includes the kernel journaling thread
  17. * which is responsible for scheduling updates to the log.
  18. *
  19. * We do not actually manage the physical storage of the journal in this
  20. * file: that is left to a per-journal policy function, which allows us
  21. * to store the journal within a filesystem-specified area for ext2
  22. * journaling (ext2 can use a reserved inode for storing the log).
  23. */
  24. #include <linux/module.h>
  25. #include <linux/time.h>
  26. #include <linux/fs.h>
  27. #include <linux/jbd.h>
  28. #include <linux/errno.h>
  29. #include <linux/slab.h>
  30. #include <linux/smp_lock.h>
  31. #include <linux/init.h>
  32. #include <linux/mm.h>
  33. #include <linux/freezer.h>
  34. #include <linux/pagemap.h>
  35. #include <linux/kthread.h>
  36. #include <linux/poison.h>
  37. #include <linux/proc_fs.h>
  38. #include <asm/uaccess.h>
  39. #include <asm/page.h>
  40. EXPORT_SYMBOL(journal_start);
  41. EXPORT_SYMBOL(journal_restart);
  42. EXPORT_SYMBOL(journal_extend);
  43. EXPORT_SYMBOL(journal_stop);
  44. EXPORT_SYMBOL(journal_lock_updates);
  45. EXPORT_SYMBOL(journal_unlock_updates);
  46. EXPORT_SYMBOL(journal_get_write_access);
  47. EXPORT_SYMBOL(journal_get_create_access);
  48. EXPORT_SYMBOL(journal_get_undo_access);
  49. EXPORT_SYMBOL(journal_dirty_data);
  50. EXPORT_SYMBOL(journal_dirty_metadata);
  51. EXPORT_SYMBOL(journal_release_buffer);
  52. EXPORT_SYMBOL(journal_forget);
  53. #if 0
  54. EXPORT_SYMBOL(journal_sync_buffer);
  55. #endif
  56. EXPORT_SYMBOL(journal_flush);
  57. EXPORT_SYMBOL(journal_revoke);
  58. EXPORT_SYMBOL(journal_init_dev);
  59. EXPORT_SYMBOL(journal_init_inode);
  60. EXPORT_SYMBOL(journal_update_format);
  61. EXPORT_SYMBOL(journal_check_used_features);
  62. EXPORT_SYMBOL(journal_check_available_features);
  63. EXPORT_SYMBOL(journal_set_features);
  64. EXPORT_SYMBOL(journal_create);
  65. EXPORT_SYMBOL(journal_load);
  66. EXPORT_SYMBOL(journal_destroy);
  67. EXPORT_SYMBOL(journal_update_superblock);
  68. EXPORT_SYMBOL(journal_abort);
  69. EXPORT_SYMBOL(journal_errno);
  70. EXPORT_SYMBOL(journal_ack_err);
  71. EXPORT_SYMBOL(journal_clear_err);
  72. EXPORT_SYMBOL(log_wait_commit);
  73. EXPORT_SYMBOL(journal_start_commit);
  74. EXPORT_SYMBOL(journal_force_commit_nested);
  75. EXPORT_SYMBOL(journal_wipe);
  76. EXPORT_SYMBOL(journal_blocks_per_page);
  77. EXPORT_SYMBOL(journal_invalidatepage);
  78. EXPORT_SYMBOL(journal_try_to_free_buffers);
  79. EXPORT_SYMBOL(journal_force_commit);
  80. static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);
  81. static void __journal_abort_soft (journal_t *journal, int errno);
  82. static int journal_create_jbd_slab(size_t slab_size);
  83. /*
  84. * Helper function used to manage commit timeouts
  85. */
  86. static void commit_timeout(unsigned long __data)
  87. {
  88. struct task_struct * p = (struct task_struct *) __data;
  89. wake_up_process(p);
  90. }
  91. /*
  92. * kjournald: The main thread function used to manage a logging device
  93. * journal.
  94. *
  95. * This kernel thread is responsible for two things:
  96. *
  97. * 1) COMMIT: Every so often we need to commit the current state of the
  98. * filesystem to disk. The journal thread is responsible for writing
  99. * all of the metadata buffers to disk.
  100. *
  101. * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
  102. * of the data in that part of the log has been rewritten elsewhere on
  103. * the disk. Flushing these old buffers to reclaim space in the log is
  104. * known as checkpointing, and this thread is responsible for that job.
  105. */
  106. static int kjournald(void *arg)
  107. {
  108. journal_t *journal = arg;
  109. transaction_t *transaction;
  110. /*
  111. * Set up an interval timer which can be used to trigger a commit wakeup
  112. * after the commit interval expires
  113. */
  114. setup_timer(&journal->j_commit_timer, commit_timeout,
  115. (unsigned long)current);
  116. /* Record that the journal thread is running */
  117. journal->j_task = current;
  118. wake_up(&journal->j_wait_done_commit);
  119. printk(KERN_INFO "kjournald starting. Commit interval %ld seconds\n",
  120. journal->j_commit_interval / HZ);
  121. /*
  122. * And now, wait forever for commit wakeup events.
  123. */
  124. spin_lock(&journal->j_state_lock);
  125. loop:
  126. if (journal->j_flags & JFS_UNMOUNT)
  127. goto end_loop;
  128. jbd_debug(1, "commit_sequence=%d, commit_request=%d\n",
  129. journal->j_commit_sequence, journal->j_commit_request);
  130. if (journal->j_commit_sequence != journal->j_commit_request) {
  131. jbd_debug(1, "OK, requests differ\n");
  132. spin_unlock(&journal->j_state_lock);
  133. del_timer_sync(&journal->j_commit_timer);
  134. journal_commit_transaction(journal);
  135. spin_lock(&journal->j_state_lock);
  136. goto loop;
  137. }
  138. wake_up(&journal->j_wait_done_commit);
  139. if (freezing(current)) {
  140. /*
  141. * The simpler the better. Flushing journal isn't a
  142. * good idea, because that depends on threads that may
  143. * be already stopped.
  144. */
  145. jbd_debug(1, "Now suspending kjournald\n");
  146. spin_unlock(&journal->j_state_lock);
  147. refrigerator();
  148. spin_lock(&journal->j_state_lock);
  149. } else {
  150. /*
  151. * We assume on resume that commits are already there,
  152. * so we don't sleep
  153. */
  154. DEFINE_WAIT(wait);
  155. int should_sleep = 1;
  156. prepare_to_wait(&journal->j_wait_commit, &wait,
  157. TASK_INTERRUPTIBLE);
  158. if (journal->j_commit_sequence != journal->j_commit_request)
  159. should_sleep = 0;
  160. transaction = journal->j_running_transaction;
  161. if (transaction && time_after_eq(jiffies,
  162. transaction->t_expires))
  163. should_sleep = 0;
  164. if (journal->j_flags & JFS_UNMOUNT)
  165. should_sleep = 0;
  166. if (should_sleep) {
  167. spin_unlock(&journal->j_state_lock);
  168. schedule();
  169. spin_lock(&journal->j_state_lock);
  170. }
  171. finish_wait(&journal->j_wait_commit, &wait);
  172. }
  173. jbd_debug(1, "kjournald wakes\n");
  174. /*
  175. * Were we woken up by a commit wakeup event?
  176. */
  177. transaction = journal->j_running_transaction;
  178. if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
  179. journal->j_commit_request = transaction->t_tid;
  180. jbd_debug(1, "woke because of timeout\n");
  181. }
  182. goto loop;
  183. end_loop:
  184. spin_unlock(&journal->j_state_lock);
  185. del_timer_sync(&journal->j_commit_timer);
  186. journal->j_task = NULL;
  187. wake_up(&journal->j_wait_done_commit);
  188. jbd_debug(1, "Journal thread exiting.\n");
  189. return 0;
  190. }
  191. static void journal_start_thread(journal_t *journal)
  192. {
  193. kthread_run(kjournald, journal, "kjournald");
  194. wait_event(journal->j_wait_done_commit, journal->j_task != 0);
  195. }
  196. static void journal_kill_thread(journal_t *journal)
  197. {
  198. spin_lock(&journal->j_state_lock);
  199. journal->j_flags |= JFS_UNMOUNT;
  200. while (journal->j_task) {
  201. wake_up(&journal->j_wait_commit);
  202. spin_unlock(&journal->j_state_lock);
  203. wait_event(journal->j_wait_done_commit, journal->j_task == 0);
  204. spin_lock(&journal->j_state_lock);
  205. }
  206. spin_unlock(&journal->j_state_lock);
  207. }
  208. /*
  209. * journal_write_metadata_buffer: write a metadata buffer to the journal.
  210. *
  211. * Writes a metadata buffer to a given disk block. The actual IO is not
  212. * performed but a new buffer_head is constructed which labels the data
  213. * to be written with the correct destination disk block.
  214. *
  215. * Any magic-number escaping which needs to be done will cause a
  216. * copy-out here. If the buffer happens to start with the
  217. * JFS_MAGIC_NUMBER, then we can't write it to the log directly: the
  218. * magic number is only written to the log for descripter blocks. In
  219. * this case, we copy the data and replace the first word with 0, and we
  220. * return a result code which indicates that this buffer needs to be
  221. * marked as an escaped buffer in the corresponding log descriptor
  222. * block. The missing word can then be restored when the block is read
  223. * during recovery.
  224. *
  225. * If the source buffer has already been modified by a new transaction
  226. * since we took the last commit snapshot, we use the frozen copy of
  227. * that data for IO. If we end up using the existing buffer_head's data
  228. * for the write, then we *have* to lock the buffer to prevent anyone
  229. * else from using and possibly modifying it while the IO is in
  230. * progress.
  231. *
  232. * The function returns a pointer to the buffer_heads to be used for IO.
  233. *
  234. * We assume that the journal has already been locked in this function.
  235. *
  236. * Return value:
  237. * <0: Error
  238. * >=0: Finished OK
  239. *
  240. * On success:
  241. * Bit 0 set == escape performed on the data
  242. * Bit 1 set == buffer copy-out performed (kfree the data after IO)
  243. */
  244. int journal_write_metadata_buffer(transaction_t *transaction,
  245. struct journal_head *jh_in,
  246. struct journal_head **jh_out,
  247. unsigned long blocknr)
  248. {
  249. int need_copy_out = 0;
  250. int done_copy_out = 0;
  251. int do_escape = 0;
  252. char *mapped_data;
  253. struct buffer_head *new_bh;
  254. struct journal_head *new_jh;
  255. struct page *new_page;
  256. unsigned int new_offset;
  257. struct buffer_head *bh_in = jh2bh(jh_in);
  258. /*
  259. * The buffer really shouldn't be locked: only the current committing
  260. * transaction is allowed to write it, so nobody else is allowed
  261. * to do any IO.
  262. *
  263. * akpm: except if we're journalling data, and write() output is
  264. * also part of a shared mapping, and another thread has
  265. * decided to launch a writepage() against this buffer.
  266. */
  267. J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
  268. new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL);
  269. /*
  270. * If a new transaction has already done a buffer copy-out, then
  271. * we use that version of the data for the commit.
  272. */
  273. jbd_lock_bh_state(bh_in);
  274. repeat:
  275. if (jh_in->b_frozen_data) {
  276. done_copy_out = 1;
  277. new_page = virt_to_page(jh_in->b_frozen_data);
  278. new_offset = offset_in_page(jh_in->b_frozen_data);
  279. } else {
  280. new_page = jh2bh(jh_in)->b_page;
  281. new_offset = offset_in_page(jh2bh(jh_in)->b_data);
  282. }
  283. mapped_data = kmap_atomic(new_page, KM_USER0);
  284. /*
  285. * Check for escaping
  286. */
  287. if (*((__be32 *)(mapped_data + new_offset)) ==
  288. cpu_to_be32(JFS_MAGIC_NUMBER)) {
  289. need_copy_out = 1;
  290. do_escape = 1;
  291. }
  292. kunmap_atomic(mapped_data, KM_USER0);
  293. /*
  294. * Do we need to do a data copy?
  295. */
  296. if (need_copy_out && !done_copy_out) {
  297. char *tmp;
  298. jbd_unlock_bh_state(bh_in);
  299. tmp = jbd_slab_alloc(bh_in->b_size, GFP_NOFS);
  300. jbd_lock_bh_state(bh_in);
  301. if (jh_in->b_frozen_data) {
  302. jbd_slab_free(tmp, bh_in->b_size);
  303. goto repeat;
  304. }
  305. jh_in->b_frozen_data = tmp;
  306. mapped_data = kmap_atomic(new_page, KM_USER0);
  307. memcpy(tmp, mapped_data + new_offset, jh2bh(jh_in)->b_size);
  308. kunmap_atomic(mapped_data, KM_USER0);
  309. new_page = virt_to_page(tmp);
  310. new_offset = offset_in_page(tmp);
  311. done_copy_out = 1;
  312. }
  313. /*
  314. * Did we need to do an escaping? Now we've done all the
  315. * copying, we can finally do so.
  316. */
  317. if (do_escape) {
  318. mapped_data = kmap_atomic(new_page, KM_USER0);
  319. *((unsigned int *)(mapped_data + new_offset)) = 0;
  320. kunmap_atomic(mapped_data, KM_USER0);
  321. }
  322. /* keep subsequent assertions sane */
  323. new_bh->b_state = 0;
  324. init_buffer(new_bh, NULL, NULL);
  325. atomic_set(&new_bh->b_count, 1);
  326. jbd_unlock_bh_state(bh_in);
  327. new_jh = journal_add_journal_head(new_bh); /* This sleeps */
  328. set_bh_page(new_bh, new_page, new_offset);
  329. new_jh->b_transaction = NULL;
  330. new_bh->b_size = jh2bh(jh_in)->b_size;
  331. new_bh->b_bdev = transaction->t_journal->j_dev;
  332. new_bh->b_blocknr = blocknr;
  333. set_buffer_mapped(new_bh);
  334. set_buffer_dirty(new_bh);
  335. *jh_out = new_jh;
  336. /*
  337. * The to-be-written buffer needs to get moved to the io queue,
  338. * and the original buffer whose contents we are shadowing or
  339. * copying is moved to the transaction's shadow queue.
  340. */
  341. JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
  342. journal_file_buffer(jh_in, transaction, BJ_Shadow);
  343. JBUFFER_TRACE(new_jh, "file as BJ_IO");
  344. journal_file_buffer(new_jh, transaction, BJ_IO);
  345. return do_escape | (done_copy_out << 1);
  346. }
  347. /*
  348. * Allocation code for the journal file. Manage the space left in the
  349. * journal, so that we can begin checkpointing when appropriate.
  350. */
  351. /*
  352. * __log_space_left: Return the number of free blocks left in the journal.
  353. *
  354. * Called with the journal already locked.
  355. *
  356. * Called under j_state_lock
  357. */
  358. int __log_space_left(journal_t *journal)
  359. {
  360. int left = journal->j_free;
  361. assert_spin_locked(&journal->j_state_lock);
  362. /*
  363. * Be pessimistic here about the number of those free blocks which
  364. * might be required for log descriptor control blocks.
  365. */
  366. #define MIN_LOG_RESERVED_BLOCKS 32 /* Allow for rounding errors */
  367. left -= MIN_LOG_RESERVED_BLOCKS;
  368. if (left <= 0)
  369. return 0;
  370. left -= (left >> 3);
  371. return left;
  372. }
  373. /*
  374. * Called under j_state_lock. Returns true if a transaction was started.
  375. */
  376. int __log_start_commit(journal_t *journal, tid_t target)
  377. {
  378. /*
  379. * Are we already doing a recent enough commit?
  380. */
  381. if (!tid_geq(journal->j_commit_request, target)) {
  382. /*
  383. * We want a new commit: OK, mark the request and wakup the
  384. * commit thread. We do _not_ do the commit ourselves.
  385. */
  386. journal->j_commit_request = target;
  387. jbd_debug(1, "JBD: requesting commit %d/%d\n",
  388. journal->j_commit_request,
  389. journal->j_commit_sequence);
  390. wake_up(&journal->j_wait_commit);
  391. return 1;
  392. }
  393. return 0;
  394. }
  395. int log_start_commit(journal_t *journal, tid_t tid)
  396. {
  397. int ret;
  398. spin_lock(&journal->j_state_lock);
  399. ret = __log_start_commit(journal, tid);
  400. spin_unlock(&journal->j_state_lock);
  401. return ret;
  402. }
  403. /*
  404. * Force and wait upon a commit if the calling process is not within
  405. * transaction. This is used for forcing out undo-protected data which contains
  406. * bitmaps, when the fs is running out of space.
  407. *
  408. * We can only force the running transaction if we don't have an active handle;
  409. * otherwise, we will deadlock.
  410. *
  411. * Returns true if a transaction was started.
  412. */
  413. int journal_force_commit_nested(journal_t *journal)
  414. {
  415. transaction_t *transaction = NULL;
  416. tid_t tid;
  417. spin_lock(&journal->j_state_lock);
  418. if (journal->j_running_transaction && !current->journal_info) {
  419. transaction = journal->j_running_transaction;
  420. __log_start_commit(journal, transaction->t_tid);
  421. } else if (journal->j_committing_transaction)
  422. transaction = journal->j_committing_transaction;
  423. if (!transaction) {
  424. spin_unlock(&journal->j_state_lock);
  425. return 0; /* Nothing to retry */
  426. }
  427. tid = transaction->t_tid;
  428. spin_unlock(&journal->j_state_lock);
  429. log_wait_commit(journal, tid);
  430. return 1;
  431. }
  432. /*
  433. * Start a commit of the current running transaction (if any). Returns true
  434. * if a transaction was started, and fills its tid in at *ptid
  435. */
  436. int journal_start_commit(journal_t *journal, tid_t *ptid)
  437. {
  438. int ret = 0;
  439. spin_lock(&journal->j_state_lock);
  440. if (journal->j_running_transaction) {
  441. tid_t tid = journal->j_running_transaction->t_tid;
  442. ret = __log_start_commit(journal, tid);
  443. if (ret && ptid)
  444. *ptid = tid;
  445. } else if (journal->j_committing_transaction && ptid) {
  446. /*
  447. * If ext3_write_super() recently started a commit, then we
  448. * have to wait for completion of that transaction
  449. */
  450. *ptid = journal->j_committing_transaction->t_tid;
  451. ret = 1;
  452. }
  453. spin_unlock(&journal->j_state_lock);
  454. return ret;
  455. }
  456. /*
  457. * Wait for a specified commit to complete.
  458. * The caller may not hold the journal lock.
  459. */
  460. int log_wait_commit(journal_t *journal, tid_t tid)
  461. {
  462. int err = 0;
  463. #ifdef CONFIG_JBD_DEBUG
  464. spin_lock(&journal->j_state_lock);
  465. if (!tid_geq(journal->j_commit_request, tid)) {
  466. printk(KERN_EMERG
  467. "%s: error: j_commit_request=%d, tid=%d\n",
  468. __FUNCTION__, journal->j_commit_request, tid);
  469. }
  470. spin_unlock(&journal->j_state_lock);
  471. #endif
  472. spin_lock(&journal->j_state_lock);
  473. while (tid_gt(tid, journal->j_commit_sequence)) {
  474. jbd_debug(1, "JBD: want %d, j_commit_sequence=%d\n",
  475. tid, journal->j_commit_sequence);
  476. wake_up(&journal->j_wait_commit);
  477. spin_unlock(&journal->j_state_lock);
  478. wait_event(journal->j_wait_done_commit,
  479. !tid_gt(tid, journal->j_commit_sequence));
  480. spin_lock(&journal->j_state_lock);
  481. }
  482. spin_unlock(&journal->j_state_lock);
  483. if (unlikely(is_journal_aborted(journal))) {
  484. printk(KERN_EMERG "journal commit I/O error\n");
  485. err = -EIO;
  486. }
  487. return err;
  488. }
  489. /*
  490. * Log buffer allocation routines:
  491. */
  492. int journal_next_log_block(journal_t *journal, unsigned long *retp)
  493. {
  494. unsigned long blocknr;
  495. spin_lock(&journal->j_state_lock);
  496. J_ASSERT(journal->j_free > 1);
  497. blocknr = journal->j_head;
  498. journal->j_head++;
  499. journal->j_free--;
  500. if (journal->j_head == journal->j_last)
  501. journal->j_head = journal->j_first;
  502. spin_unlock(&journal->j_state_lock);
  503. return journal_bmap(journal, blocknr, retp);
  504. }
  505. /*
  506. * Conversion of logical to physical block numbers for the journal
  507. *
  508. * On external journals the journal blocks are identity-mapped, so
  509. * this is a no-op. If needed, we can use j_blk_offset - everything is
  510. * ready.
  511. */
  512. int journal_bmap(journal_t *journal, unsigned long blocknr,
  513. unsigned long *retp)
  514. {
  515. int err = 0;
  516. unsigned long ret;
  517. if (journal->j_inode) {
  518. ret = bmap(journal->j_inode, blocknr);
  519. if (ret)
  520. *retp = ret;
  521. else {
  522. char b[BDEVNAME_SIZE];
  523. printk(KERN_ALERT "%s: journal block not found "
  524. "at offset %lu on %s\n",
  525. __FUNCTION__,
  526. blocknr,
  527. bdevname(journal->j_dev, b));
  528. err = -EIO;
  529. __journal_abort_soft(journal, err);
  530. }
  531. } else {
  532. *retp = blocknr; /* +journal->j_blk_offset */
  533. }
  534. return err;
  535. }
  536. /*
  537. * We play buffer_head aliasing tricks to write data/metadata blocks to
  538. * the journal without copying their contents, but for journal
  539. * descriptor blocks we do need to generate bona fide buffers.
  540. *
  541. * After the caller of journal_get_descriptor_buffer() has finished modifying
  542. * the buffer's contents they really should run flush_dcache_page(bh->b_page).
  543. * But we don't bother doing that, so there will be coherency problems with
  544. * mmaps of blockdevs which hold live JBD-controlled filesystems.
  545. */
  546. struct journal_head *journal_get_descriptor_buffer(journal_t *journal)
  547. {
  548. struct buffer_head *bh;
  549. unsigned long blocknr;
  550. int err;
  551. err = journal_next_log_block(journal, &blocknr);
  552. if (err)
  553. return NULL;
  554. bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
  555. lock_buffer(bh);
  556. memset(bh->b_data, 0, journal->j_blocksize);
  557. set_buffer_uptodate(bh);
  558. unlock_buffer(bh);
  559. BUFFER_TRACE(bh, "return this buffer");
  560. return journal_add_journal_head(bh);
  561. }
  562. /*
  563. * Management for journal control blocks: functions to create and
  564. * destroy journal_t structures, and to initialise and read existing
  565. * journal blocks from disk. */
  566. /* First: create and setup a journal_t object in memory. We initialise
  567. * very few fields yet: that has to wait until we have created the
  568. * journal structures from from scratch, or loaded them from disk. */
  569. static journal_t * journal_init_common (void)
  570. {
  571. journal_t *journal;
  572. int err;
  573. journal = jbd_kmalloc(sizeof(*journal), GFP_KERNEL);
  574. if (!journal)
  575. goto fail;
  576. memset(journal, 0, sizeof(*journal));
  577. init_waitqueue_head(&journal->j_wait_transaction_locked);
  578. init_waitqueue_head(&journal->j_wait_logspace);
  579. init_waitqueue_head(&journal->j_wait_done_commit);
  580. init_waitqueue_head(&journal->j_wait_checkpoint);
  581. init_waitqueue_head(&journal->j_wait_commit);
  582. init_waitqueue_head(&journal->j_wait_updates);
  583. mutex_init(&journal->j_barrier);
  584. mutex_init(&journal->j_checkpoint_mutex);
  585. spin_lock_init(&journal->j_revoke_lock);
  586. spin_lock_init(&journal->j_list_lock);
  587. spin_lock_init(&journal->j_state_lock);
  588. journal->j_commit_interval = (HZ * JBD_DEFAULT_MAX_COMMIT_AGE);
  589. /* The journal is marked for error until we succeed with recovery! */
  590. journal->j_flags = JFS_ABORT;
  591. /* Set up a default-sized revoke table for the new mount. */
  592. err = journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
  593. if (err) {
  594. kfree(journal);
  595. goto fail;
  596. }
  597. return journal;
  598. fail:
  599. return NULL;
  600. }
  601. /* journal_init_dev and journal_init_inode:
  602. *
  603. * Create a journal structure assigned some fixed set of disk blocks to
  604. * the journal. We don't actually touch those disk blocks yet, but we
  605. * need to set up all of the mapping information to tell the journaling
  606. * system where the journal blocks are.
  607. *
  608. */
  609. /**
  610. * journal_t * journal_init_dev() - creates an initialises a journal structure
  611. * @bdev: Block device on which to create the journal
  612. * @fs_dev: Device which hold journalled filesystem for this journal.
  613. * @start: Block nr Start of journal.
  614. * @len: Length of the journal in blocks.
  615. * @blocksize: blocksize of journalling device
  616. * @returns: a newly created journal_t *
  617. *
  618. * journal_init_dev creates a journal which maps a fixed contiguous
  619. * range of blocks on an arbitrary block device.
  620. *
  621. */
  622. journal_t * journal_init_dev(struct block_device *bdev,
  623. struct block_device *fs_dev,
  624. int start, int len, int blocksize)
  625. {
  626. journal_t *journal = journal_init_common();
  627. struct buffer_head *bh;
  628. int n;
  629. if (!journal)
  630. return NULL;
  631. /* journal descriptor can store up to n blocks -bzzz */
  632. journal->j_blocksize = blocksize;
  633. n = journal->j_blocksize / sizeof(journal_block_tag_t);
  634. journal->j_wbufsize = n;
  635. journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
  636. if (!journal->j_wbuf) {
  637. printk(KERN_ERR "%s: Cant allocate bhs for commit thread\n",
  638. __FUNCTION__);
  639. kfree(journal);
  640. journal = NULL;
  641. goto out;
  642. }
  643. journal->j_dev = bdev;
  644. journal->j_fs_dev = fs_dev;
  645. journal->j_blk_offset = start;
  646. journal->j_maxlen = len;
  647. bh = __getblk(journal->j_dev, start, journal->j_blocksize);
  648. J_ASSERT(bh != NULL);
  649. journal->j_sb_buffer = bh;
  650. journal->j_superblock = (journal_superblock_t *)bh->b_data;
  651. out:
  652. return journal;
  653. }
  654. /**
  655. * journal_t * journal_init_inode () - creates a journal which maps to a inode.
  656. * @inode: An inode to create the journal in
  657. *
  658. * journal_init_inode creates a journal which maps an on-disk inode as
  659. * the journal. The inode must exist already, must support bmap() and
  660. * must have all data blocks preallocated.
  661. */
  662. journal_t * journal_init_inode (struct inode *inode)
  663. {
  664. struct buffer_head *bh;
  665. journal_t *journal = journal_init_common();
  666. int err;
  667. int n;
  668. unsigned long blocknr;
  669. if (!journal)
  670. return NULL;
  671. journal->j_dev = journal->j_fs_dev = inode->i_sb->s_bdev;
  672. journal->j_inode = inode;
  673. jbd_debug(1,
  674. "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
  675. journal, inode->i_sb->s_id, inode->i_ino,
  676. (long long) inode->i_size,
  677. inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
  678. journal->j_maxlen = inode->i_size >> inode->i_sb->s_blocksize_bits;
  679. journal->j_blocksize = inode->i_sb->s_blocksize;
  680. /* journal descriptor can store up to n blocks -bzzz */
  681. n = journal->j_blocksize / sizeof(journal_block_tag_t);
  682. journal->j_wbufsize = n;
  683. journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
  684. if (!journal->j_wbuf) {
  685. printk(KERN_ERR "%s: Cant allocate bhs for commit thread\n",
  686. __FUNCTION__);
  687. kfree(journal);
  688. return NULL;
  689. }
  690. err = journal_bmap(journal, 0, &blocknr);
  691. /* If that failed, give up */
  692. if (err) {
  693. printk(KERN_ERR "%s: Cannnot locate journal superblock\n",
  694. __FUNCTION__);
  695. kfree(journal);
  696. return NULL;
  697. }
  698. bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
  699. J_ASSERT(bh != NULL);
  700. journal->j_sb_buffer = bh;
  701. journal->j_superblock = (journal_superblock_t *)bh->b_data;
  702. return journal;
  703. }
  704. /*
  705. * If the journal init or create aborts, we need to mark the journal
  706. * superblock as being NULL to prevent the journal destroy from writing
  707. * back a bogus superblock.
  708. */
  709. static void journal_fail_superblock (journal_t *journal)
  710. {
  711. struct buffer_head *bh = journal->j_sb_buffer;
  712. brelse(bh);
  713. journal->j_sb_buffer = NULL;
  714. }
  715. /*
  716. * Given a journal_t structure, initialise the various fields for
  717. * startup of a new journaling session. We use this both when creating
  718. * a journal, and after recovering an old journal to reset it for
  719. * subsequent use.
  720. */
  721. static int journal_reset(journal_t *journal)
  722. {
  723. journal_superblock_t *sb = journal->j_superblock;
  724. unsigned long first, last;
  725. first = be32_to_cpu(sb->s_first);
  726. last = be32_to_cpu(sb->s_maxlen);
  727. journal->j_first = first;
  728. journal->j_last = last;
  729. journal->j_head = first;
  730. journal->j_tail = first;
  731. journal->j_free = last - first;
  732. journal->j_tail_sequence = journal->j_transaction_sequence;
  733. journal->j_commit_sequence = journal->j_transaction_sequence - 1;
  734. journal->j_commit_request = journal->j_commit_sequence;
  735. journal->j_max_transaction_buffers = journal->j_maxlen / 4;
  736. /* Add the dynamic fields and write it to disk. */
  737. journal_update_superblock(journal, 1);
  738. journal_start_thread(journal);
  739. return 0;
  740. }
  741. /**
  742. * int journal_create() - Initialise the new journal file
  743. * @journal: Journal to create. This structure must have been initialised
  744. *
  745. * Given a journal_t structure which tells us which disk blocks we can
  746. * use, create a new journal superblock and initialise all of the
  747. * journal fields from scratch.
  748. **/
  749. int journal_create(journal_t *journal)
  750. {
  751. unsigned long blocknr;
  752. struct buffer_head *bh;
  753. journal_superblock_t *sb;
  754. int i, err;
  755. if (journal->j_maxlen < JFS_MIN_JOURNAL_BLOCKS) {
  756. printk (KERN_ERR "Journal length (%d blocks) too short.\n",
  757. journal->j_maxlen);
  758. journal_fail_superblock(journal);
  759. return -EINVAL;
  760. }
  761. if (journal->j_inode == NULL) {
  762. /*
  763. * We don't know what block to start at!
  764. */
  765. printk(KERN_EMERG
  766. "%s: creation of journal on external device!\n",
  767. __FUNCTION__);
  768. BUG();
  769. }
  770. /* Zero out the entire journal on disk. We cannot afford to
  771. have any blocks on disk beginning with JFS_MAGIC_NUMBER. */
  772. jbd_debug(1, "JBD: Zeroing out journal blocks...\n");
  773. for (i = 0; i < journal->j_maxlen; i++) {
  774. err = journal_bmap(journal, i, &blocknr);
  775. if (err)
  776. return err;
  777. bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
  778. lock_buffer(bh);
  779. memset (bh->b_data, 0, journal->j_blocksize);
  780. BUFFER_TRACE(bh, "marking dirty");
  781. mark_buffer_dirty(bh);
  782. BUFFER_TRACE(bh, "marking uptodate");
  783. set_buffer_uptodate(bh);
  784. unlock_buffer(bh);
  785. __brelse(bh);
  786. }
  787. sync_blockdev(journal->j_dev);
  788. jbd_debug(1, "JBD: journal cleared.\n");
  789. /* OK, fill in the initial static fields in the new superblock */
  790. sb = journal->j_superblock;
  791. sb->s_header.h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
  792. sb->s_header.h_blocktype = cpu_to_be32(JFS_SUPERBLOCK_V2);
  793. sb->s_blocksize = cpu_to_be32(journal->j_blocksize);
  794. sb->s_maxlen = cpu_to_be32(journal->j_maxlen);
  795. sb->s_first = cpu_to_be32(1);
  796. journal->j_transaction_sequence = 1;
  797. journal->j_flags &= ~JFS_ABORT;
  798. journal->j_format_version = 2;
  799. return journal_reset(journal);
  800. }
  801. /**
  802. * void journal_update_superblock() - Update journal sb on disk.
  803. * @journal: The journal to update.
  804. * @wait: Set to '0' if you don't want to wait for IO completion.
  805. *
  806. * Update a journal's dynamic superblock fields and write it to disk,
  807. * optionally waiting for the IO to complete.
  808. */
  809. void journal_update_superblock(journal_t *journal, int wait)
  810. {
  811. journal_superblock_t *sb = journal->j_superblock;
  812. struct buffer_head *bh = journal->j_sb_buffer;
  813. /*
  814. * As a special case, if the on-disk copy is already marked as needing
  815. * no recovery (s_start == 0) and there are no outstanding transactions
  816. * in the filesystem, then we can safely defer the superblock update
  817. * until the next commit by setting JFS_FLUSHED. This avoids
  818. * attempting a write to a potential-readonly device.
  819. */
  820. if (sb->s_start == 0 && journal->j_tail_sequence ==
  821. journal->j_transaction_sequence) {
  822. jbd_debug(1,"JBD: Skipping superblock update on recovered sb "
  823. "(start %ld, seq %d, errno %d)\n",
  824. journal->j_tail, journal->j_tail_sequence,
  825. journal->j_errno);
  826. goto out;
  827. }
  828. spin_lock(&journal->j_state_lock);
  829. jbd_debug(1,"JBD: updating superblock (start %ld, seq %d, errno %d)\n",
  830. journal->j_tail, journal->j_tail_sequence, journal->j_errno);
  831. sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
  832. sb->s_start = cpu_to_be32(journal->j_tail);
  833. sb->s_errno = cpu_to_be32(journal->j_errno);
  834. spin_unlock(&journal->j_state_lock);
  835. BUFFER_TRACE(bh, "marking dirty");
  836. mark_buffer_dirty(bh);
  837. if (wait)
  838. sync_dirty_buffer(bh);
  839. else
  840. ll_rw_block(SWRITE, 1, &bh);
  841. out:
  842. /* If we have just flushed the log (by marking s_start==0), then
  843. * any future commit will have to be careful to update the
  844. * superblock again to re-record the true start of the log. */
  845. spin_lock(&journal->j_state_lock);
  846. if (sb->s_start)
  847. journal->j_flags &= ~JFS_FLUSHED;
  848. else
  849. journal->j_flags |= JFS_FLUSHED;
  850. spin_unlock(&journal->j_state_lock);
  851. }
  852. /*
  853. * Read the superblock for a given journal, performing initial
  854. * validation of the format.
  855. */
  856. static int journal_get_superblock(journal_t *journal)
  857. {
  858. struct buffer_head *bh;
  859. journal_superblock_t *sb;
  860. int err = -EIO;
  861. bh = journal->j_sb_buffer;
  862. J_ASSERT(bh != NULL);
  863. if (!buffer_uptodate(bh)) {
  864. ll_rw_block(READ, 1, &bh);
  865. wait_on_buffer(bh);
  866. if (!buffer_uptodate(bh)) {
  867. printk (KERN_ERR
  868. "JBD: IO error reading journal superblock\n");
  869. goto out;
  870. }
  871. }
  872. sb = journal->j_superblock;
  873. err = -EINVAL;
  874. if (sb->s_header.h_magic != cpu_to_be32(JFS_MAGIC_NUMBER) ||
  875. sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
  876. printk(KERN_WARNING "JBD: no valid journal superblock found\n");
  877. goto out;
  878. }
  879. switch(be32_to_cpu(sb->s_header.h_blocktype)) {
  880. case JFS_SUPERBLOCK_V1:
  881. journal->j_format_version = 1;
  882. break;
  883. case JFS_SUPERBLOCK_V2:
  884. journal->j_format_version = 2;
  885. break;
  886. default:
  887. printk(KERN_WARNING "JBD: unrecognised superblock format ID\n");
  888. goto out;
  889. }
  890. if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
  891. journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
  892. else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
  893. printk (KERN_WARNING "JBD: journal file too short\n");
  894. goto out;
  895. }
  896. return 0;
  897. out:
  898. journal_fail_superblock(journal);
  899. return err;
  900. }
  901. /*
  902. * Load the on-disk journal superblock and read the key fields into the
  903. * journal_t.
  904. */
  905. static int load_superblock(journal_t *journal)
  906. {
  907. int err;
  908. journal_superblock_t *sb;
  909. err = journal_get_superblock(journal);
  910. if (err)
  911. return err;
  912. sb = journal->j_superblock;
  913. journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
  914. journal->j_tail = be32_to_cpu(sb->s_start);
  915. journal->j_first = be32_to_cpu(sb->s_first);
  916. journal->j_last = be32_to_cpu(sb->s_maxlen);
  917. journal->j_errno = be32_to_cpu(sb->s_errno);
  918. return 0;
  919. }
  920. /**
  921. * int journal_load() - Read journal from disk.
  922. * @journal: Journal to act on.
  923. *
  924. * Given a journal_t structure which tells us which disk blocks contain
  925. * a journal, read the journal from disk to initialise the in-memory
  926. * structures.
  927. */
  928. int journal_load(journal_t *journal)
  929. {
  930. int err;
  931. journal_superblock_t *sb;
  932. err = load_superblock(journal);
  933. if (err)
  934. return err;
  935. sb = journal->j_superblock;
  936. /* If this is a V2 superblock, then we have to check the
  937. * features flags on it. */
  938. if (journal->j_format_version >= 2) {
  939. if ((sb->s_feature_ro_compat &
  940. ~cpu_to_be32(JFS_KNOWN_ROCOMPAT_FEATURES)) ||
  941. (sb->s_feature_incompat &
  942. ~cpu_to_be32(JFS_KNOWN_INCOMPAT_FEATURES))) {
  943. printk (KERN_WARNING
  944. "JBD: Unrecognised features on journal\n");
  945. return -EINVAL;
  946. }
  947. }
  948. /*
  949. * Create a slab for this blocksize
  950. */
  951. err = journal_create_jbd_slab(be32_to_cpu(sb->s_blocksize));
  952. if (err)
  953. return err;
  954. /* Let the recovery code check whether it needs to recover any
  955. * data from the journal. */
  956. if (journal_recover(journal))
  957. goto recovery_error;
  958. /* OK, we've finished with the dynamic journal bits:
  959. * reinitialise the dynamic contents of the superblock in memory
  960. * and reset them on disk. */
  961. if (journal_reset(journal))
  962. goto recovery_error;
  963. journal->j_flags &= ~JFS_ABORT;
  964. journal->j_flags |= JFS_LOADED;
  965. return 0;
  966. recovery_error:
  967. printk (KERN_WARNING "JBD: recovery failed\n");
  968. return -EIO;
  969. }
  970. /**
  971. * void journal_destroy() - Release a journal_t structure.
  972. * @journal: Journal to act on.
  973. *
  974. * Release a journal_t structure once it is no longer in use by the
  975. * journaled object.
  976. */
  977. void journal_destroy(journal_t *journal)
  978. {
  979. /* Wait for the commit thread to wake up and die. */
  980. journal_kill_thread(journal);
  981. /* Force a final log commit */
  982. if (journal->j_running_transaction)
  983. journal_commit_transaction(journal);
  984. /* Force any old transactions to disk */
  985. /* Totally anal locking here... */
  986. spin_lock(&journal->j_list_lock);
  987. while (journal->j_checkpoint_transactions != NULL) {
  988. spin_unlock(&journal->j_list_lock);
  989. log_do_checkpoint(journal);
  990. spin_lock(&journal->j_list_lock);
  991. }
  992. J_ASSERT(journal->j_running_transaction == NULL);
  993. J_ASSERT(journal->j_committing_transaction == NULL);
  994. J_ASSERT(journal->j_checkpoint_transactions == NULL);
  995. spin_unlock(&journal->j_list_lock);
  996. /* We can now mark the journal as empty. */
  997. journal->j_tail = 0;
  998. journal->j_tail_sequence = ++journal->j_transaction_sequence;
  999. if (journal->j_sb_buffer) {
  1000. journal_update_superblock(journal, 1);
  1001. brelse(journal->j_sb_buffer);
  1002. }
  1003. if (journal->j_inode)
  1004. iput(journal->j_inode);
  1005. if (journal->j_revoke)
  1006. journal_destroy_revoke(journal);
  1007. kfree(journal->j_wbuf);
  1008. kfree(journal);
  1009. }
  1010. /**
  1011. *int journal_check_used_features () - Check if features specified are used.
  1012. * @journal: Journal to check.
  1013. * @compat: bitmask of compatible features
  1014. * @ro: bitmask of features that force read-only mount
  1015. * @incompat: bitmask of incompatible features
  1016. *
  1017. * Check whether the journal uses all of a given set of
  1018. * features. Return true (non-zero) if it does.
  1019. **/
  1020. int journal_check_used_features (journal_t *journal, unsigned long compat,
  1021. unsigned long ro, unsigned long incompat)
  1022. {
  1023. journal_superblock_t *sb;
  1024. if (!compat && !ro && !incompat)
  1025. return 1;
  1026. if (journal->j_format_version == 1)
  1027. return 0;
  1028. sb = journal->j_superblock;
  1029. if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
  1030. ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
  1031. ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
  1032. return 1;
  1033. return 0;
  1034. }
  1035. /**
  1036. * int journal_check_available_features() - Check feature set in journalling layer
  1037. * @journal: Journal to check.
  1038. * @compat: bitmask of compatible features
  1039. * @ro: bitmask of features that force read-only mount
  1040. * @incompat: bitmask of incompatible features
  1041. *
  1042. * Check whether the journaling code supports the use of
  1043. * all of a given set of features on this journal. Return true
  1044. * (non-zero) if it can. */
  1045. int journal_check_available_features (journal_t *journal, unsigned long compat,
  1046. unsigned long ro, unsigned long incompat)
  1047. {
  1048. journal_superblock_t *sb;
  1049. if (!compat && !ro && !incompat)
  1050. return 1;
  1051. sb = journal->j_superblock;
  1052. /* We can support any known requested features iff the
  1053. * superblock is in version 2. Otherwise we fail to support any
  1054. * extended sb features. */
  1055. if (journal->j_format_version != 2)
  1056. return 0;
  1057. if ((compat & JFS_KNOWN_COMPAT_FEATURES) == compat &&
  1058. (ro & JFS_KNOWN_ROCOMPAT_FEATURES) == ro &&
  1059. (incompat & JFS_KNOWN_INCOMPAT_FEATURES) == incompat)
  1060. return 1;
  1061. return 0;
  1062. }
  1063. /**
  1064. * int journal_set_features () - Mark a given journal feature in the superblock
  1065. * @journal: Journal to act on.
  1066. * @compat: bitmask of compatible features
  1067. * @ro: bitmask of features that force read-only mount
  1068. * @incompat: bitmask of incompatible features
  1069. *
  1070. * Mark a given journal feature as present on the
  1071. * superblock. Returns true if the requested features could be set.
  1072. *
  1073. */
  1074. int journal_set_features (journal_t *journal, unsigned long compat,
  1075. unsigned long ro, unsigned long incompat)
  1076. {
  1077. journal_superblock_t *sb;
  1078. if (journal_check_used_features(journal, compat, ro, incompat))
  1079. return 1;
  1080. if (!journal_check_available_features(journal, compat, ro, incompat))
  1081. return 0;
  1082. jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
  1083. compat, ro, incompat);
  1084. sb = journal->j_superblock;
  1085. sb->s_feature_compat |= cpu_to_be32(compat);
  1086. sb->s_feature_ro_compat |= cpu_to_be32(ro);
  1087. sb->s_feature_incompat |= cpu_to_be32(incompat);
  1088. return 1;
  1089. }
  1090. /**
  1091. * int journal_update_format () - Update on-disk journal structure.
  1092. * @journal: Journal to act on.
  1093. *
  1094. * Given an initialised but unloaded journal struct, poke about in the
  1095. * on-disk structure to update it to the most recent supported version.
  1096. */
  1097. int journal_update_format (journal_t *journal)
  1098. {
  1099. journal_superblock_t *sb;
  1100. int err;
  1101. err = journal_get_superblock(journal);
  1102. if (err)
  1103. return err;
  1104. sb = journal->j_superblock;
  1105. switch (be32_to_cpu(sb->s_header.h_blocktype)) {
  1106. case JFS_SUPERBLOCK_V2:
  1107. return 0;
  1108. case JFS_SUPERBLOCK_V1:
  1109. return journal_convert_superblock_v1(journal, sb);
  1110. default:
  1111. break;
  1112. }
  1113. return -EINVAL;
  1114. }
  1115. static int journal_convert_superblock_v1(journal_t *journal,
  1116. journal_superblock_t *sb)
  1117. {
  1118. int offset, blocksize;
  1119. struct buffer_head *bh;
  1120. printk(KERN_WARNING
  1121. "JBD: Converting superblock from version 1 to 2.\n");
  1122. /* Pre-initialise new fields to zero */
  1123. offset = ((char *) &(sb->s_feature_compat)) - ((char *) sb);
  1124. blocksize = be32_to_cpu(sb->s_blocksize);
  1125. memset(&sb->s_feature_compat, 0, blocksize-offset);
  1126. sb->s_nr_users = cpu_to_be32(1);
  1127. sb->s_header.h_blocktype = cpu_to_be32(JFS_SUPERBLOCK_V2);
  1128. journal->j_format_version = 2;
  1129. bh = journal->j_sb_buffer;
  1130. BUFFER_TRACE(bh, "marking dirty");
  1131. mark_buffer_dirty(bh);
  1132. sync_dirty_buffer(bh);
  1133. return 0;
  1134. }
  1135. /**
  1136. * int journal_flush () - Flush journal
  1137. * @journal: Journal to act on.
  1138. *
  1139. * Flush all data for a given journal to disk and empty the journal.
  1140. * Filesystems can use this when remounting readonly to ensure that
  1141. * recovery does not need to happen on remount.
  1142. */
  1143. int journal_flush(journal_t *journal)
  1144. {
  1145. int err = 0;
  1146. transaction_t *transaction = NULL;
  1147. unsigned long old_tail;
  1148. spin_lock(&journal->j_state_lock);
  1149. /* Force everything buffered to the log... */
  1150. if (journal->j_running_transaction) {
  1151. transaction = journal->j_running_transaction;
  1152. __log_start_commit(journal, transaction->t_tid);
  1153. } else if (journal->j_committing_transaction)
  1154. transaction = journal->j_committing_transaction;
  1155. /* Wait for the log commit to complete... */
  1156. if (transaction) {
  1157. tid_t tid = transaction->t_tid;
  1158. spin_unlock(&journal->j_state_lock);
  1159. log_wait_commit(journal, tid);
  1160. } else {
  1161. spin_unlock(&journal->j_state_lock);
  1162. }
  1163. /* ...and flush everything in the log out to disk. */
  1164. spin_lock(&journal->j_list_lock);
  1165. while (!err && journal->j_checkpoint_transactions != NULL) {
  1166. spin_unlock(&journal->j_list_lock);
  1167. err = log_do_checkpoint(journal);
  1168. spin_lock(&journal->j_list_lock);
  1169. }
  1170. spin_unlock(&journal->j_list_lock);
  1171. cleanup_journal_tail(journal);
  1172. /* Finally, mark the journal as really needing no recovery.
  1173. * This sets s_start==0 in the underlying superblock, which is
  1174. * the magic code for a fully-recovered superblock. Any future
  1175. * commits of data to the journal will restore the current
  1176. * s_start value. */
  1177. spin_lock(&journal->j_state_lock);
  1178. old_tail = journal->j_tail;
  1179. journal->j_tail = 0;
  1180. spin_unlock(&journal->j_state_lock);
  1181. journal_update_superblock(journal, 1);
  1182. spin_lock(&journal->j_state_lock);
  1183. journal->j_tail = old_tail;
  1184. J_ASSERT(!journal->j_running_transaction);
  1185. J_ASSERT(!journal->j_committing_transaction);
  1186. J_ASSERT(!journal->j_checkpoint_transactions);
  1187. J_ASSERT(journal->j_head == journal->j_tail);
  1188. J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
  1189. spin_unlock(&journal->j_state_lock);
  1190. return err;
  1191. }
  1192. /**
  1193. * int journal_wipe() - Wipe journal contents
  1194. * @journal: Journal to act on.
  1195. * @write: flag (see below)
  1196. *
  1197. * Wipe out all of the contents of a journal, safely. This will produce
  1198. * a warning if the journal contains any valid recovery information.
  1199. * Must be called between journal_init_*() and journal_load().
  1200. *
  1201. * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
  1202. * we merely suppress recovery.
  1203. */
  1204. int journal_wipe(journal_t *journal, int write)
  1205. {
  1206. journal_superblock_t *sb;
  1207. int err = 0;
  1208. J_ASSERT (!(journal->j_flags & JFS_LOADED));
  1209. err = load_superblock(journal);
  1210. if (err)
  1211. return err;
  1212. sb = journal->j_superblock;
  1213. if (!journal->j_tail)
  1214. goto no_recovery;
  1215. printk (KERN_WARNING "JBD: %s recovery information on journal\n",
  1216. write ? "Clearing" : "Ignoring");
  1217. err = journal_skip_recovery(journal);
  1218. if (write)
  1219. journal_update_superblock(journal, 1);
  1220. no_recovery:
  1221. return err;
  1222. }
  1223. /*
  1224. * journal_dev_name: format a character string to describe on what
  1225. * device this journal is present.
  1226. */
  1227. static const char *journal_dev_name(journal_t *journal, char *buffer)
  1228. {
  1229. struct block_device *bdev;
  1230. if (journal->j_inode)
  1231. bdev = journal->j_inode->i_sb->s_bdev;
  1232. else
  1233. bdev = journal->j_dev;
  1234. return bdevname(bdev, buffer);
  1235. }
  1236. /*
  1237. * Journal abort has very specific semantics, which we describe
  1238. * for journal abort.
  1239. *
  1240. * Two internal function, which provide abort to te jbd layer
  1241. * itself are here.
  1242. */
  1243. /*
  1244. * Quick version for internal journal use (doesn't lock the journal).
  1245. * Aborts hard --- we mark the abort as occurred, but do _nothing_ else,
  1246. * and don't attempt to make any other journal updates.
  1247. */
  1248. void __journal_abort_hard(journal_t *journal)
  1249. {
  1250. transaction_t *transaction;
  1251. char b[BDEVNAME_SIZE];
  1252. if (journal->j_flags & JFS_ABORT)
  1253. return;
  1254. printk(KERN_ERR "Aborting journal on device %s.\n",
  1255. journal_dev_name(journal, b));
  1256. spin_lock(&journal->j_state_lock);
  1257. journal->j_flags |= JFS_ABORT;
  1258. transaction = journal->j_running_transaction;
  1259. if (transaction)
  1260. __log_start_commit(journal, transaction->t_tid);
  1261. spin_unlock(&journal->j_state_lock);
  1262. }
  1263. /* Soft abort: record the abort error status in the journal superblock,
  1264. * but don't do any other IO. */
  1265. static void __journal_abort_soft (journal_t *journal, int errno)
  1266. {
  1267. if (journal->j_flags & JFS_ABORT)
  1268. return;
  1269. if (!journal->j_errno)
  1270. journal->j_errno = errno;
  1271. __journal_abort_hard(journal);
  1272. if (errno)
  1273. journal_update_superblock(journal, 1);
  1274. }
  1275. /**
  1276. * void journal_abort () - Shutdown the journal immediately.
  1277. * @journal: the journal to shutdown.
  1278. * @errno: an error number to record in the journal indicating
  1279. * the reason for the shutdown.
  1280. *
  1281. * Perform a complete, immediate shutdown of the ENTIRE
  1282. * journal (not of a single transaction). This operation cannot be
  1283. * undone without closing and reopening the journal.
  1284. *
  1285. * The journal_abort function is intended to support higher level error
  1286. * recovery mechanisms such as the ext2/ext3 remount-readonly error
  1287. * mode.
  1288. *
  1289. * Journal abort has very specific semantics. Any existing dirty,
  1290. * unjournaled buffers in the main filesystem will still be written to
  1291. * disk by bdflush, but the journaling mechanism will be suspended
  1292. * immediately and no further transaction commits will be honoured.
  1293. *
  1294. * Any dirty, journaled buffers will be written back to disk without
  1295. * hitting the journal. Atomicity cannot be guaranteed on an aborted
  1296. * filesystem, but we _do_ attempt to leave as much data as possible
  1297. * behind for fsck to use for cleanup.
  1298. *
  1299. * Any attempt to get a new transaction handle on a journal which is in
  1300. * ABORT state will just result in an -EROFS error return. A
  1301. * journal_stop on an existing handle will return -EIO if we have
  1302. * entered abort state during the update.
  1303. *
  1304. * Recursive transactions are not disturbed by journal abort until the
  1305. * final journal_stop, which will receive the -EIO error.
  1306. *
  1307. * Finally, the journal_abort call allows the caller to supply an errno
  1308. * which will be recorded (if possible) in the journal superblock. This
  1309. * allows a client to record failure conditions in the middle of a
  1310. * transaction without having to complete the transaction to record the
  1311. * failure to disk. ext3_error, for example, now uses this
  1312. * functionality.
  1313. *
  1314. * Errors which originate from within the journaling layer will NOT
  1315. * supply an errno; a null errno implies that absolutely no further
  1316. * writes are done to the journal (unless there are any already in
  1317. * progress).
  1318. *
  1319. */
  1320. void journal_abort(journal_t *journal, int errno)
  1321. {
  1322. __journal_abort_soft(journal, errno);
  1323. }
  1324. /**
  1325. * int journal_errno () - returns the journal's error state.
  1326. * @journal: journal to examine.
  1327. *
  1328. * This is the errno numbet set with journal_abort(), the last
  1329. * time the journal was mounted - if the journal was stopped
  1330. * without calling abort this will be 0.
  1331. *
  1332. * If the journal has been aborted on this mount time -EROFS will
  1333. * be returned.
  1334. */
  1335. int journal_errno(journal_t *journal)
  1336. {
  1337. int err;
  1338. spin_lock(&journal->j_state_lock);
  1339. if (journal->j_flags & JFS_ABORT)
  1340. err = -EROFS;
  1341. else
  1342. err = journal->j_errno;
  1343. spin_unlock(&journal->j_state_lock);
  1344. return err;
  1345. }
  1346. /**
  1347. * int journal_clear_err () - clears the journal's error state
  1348. * @journal: journal to act on.
  1349. *
  1350. * An error must be cleared or Acked to take a FS out of readonly
  1351. * mode.
  1352. */
  1353. int journal_clear_err(journal_t *journal)
  1354. {
  1355. int err = 0;
  1356. spin_lock(&journal->j_state_lock);
  1357. if (journal->j_flags & JFS_ABORT)
  1358. err = -EROFS;
  1359. else
  1360. journal->j_errno = 0;
  1361. spin_unlock(&journal->j_state_lock);
  1362. return err;
  1363. }
  1364. /**
  1365. * void journal_ack_err() - Ack journal err.
  1366. * @journal: journal to act on.
  1367. *
  1368. * An error must be cleared or Acked to take a FS out of readonly
  1369. * mode.
  1370. */
  1371. void journal_ack_err(journal_t *journal)
  1372. {
  1373. spin_lock(&journal->j_state_lock);
  1374. if (journal->j_errno)
  1375. journal->j_flags |= JFS_ACK_ERR;
  1376. spin_unlock(&journal->j_state_lock);
  1377. }
  1378. int journal_blocks_per_page(struct inode *inode)
  1379. {
  1380. return 1 << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
  1381. }
  1382. /*
  1383. * Simple support for retrying memory allocations. Introduced to help to
  1384. * debug different VM deadlock avoidance strategies.
  1385. */
  1386. void * __jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry)
  1387. {
  1388. return kmalloc(size, flags | (retry ? __GFP_NOFAIL : 0));
  1389. }
  1390. /*
  1391. * jbd slab management: create 1k, 2k, 4k, 8k slabs as needed
  1392. * and allocate frozen and commit buffers from these slabs.
  1393. *
  1394. * Reason for doing this is to avoid, SLAB_DEBUG - since it could
  1395. * cause bh to cross page boundary.
  1396. */
  1397. #define JBD_MAX_SLABS 5
  1398. #define JBD_SLAB_INDEX(size) (size >> 11)
  1399. static struct kmem_cache *jbd_slab[JBD_MAX_SLABS];
  1400. static const char *jbd_slab_names[JBD_MAX_SLABS] = {
  1401. "jbd_1k", "jbd_2k", "jbd_4k", NULL, "jbd_8k"
  1402. };
  1403. static void journal_destroy_jbd_slabs(void)
  1404. {
  1405. int i;
  1406. for (i = 0; i < JBD_MAX_SLABS; i++) {
  1407. if (jbd_slab[i])
  1408. kmem_cache_destroy(jbd_slab[i]);
  1409. jbd_slab[i] = NULL;
  1410. }
  1411. }
  1412. static int journal_create_jbd_slab(size_t slab_size)
  1413. {
  1414. int i = JBD_SLAB_INDEX(slab_size);
  1415. BUG_ON(i >= JBD_MAX_SLABS);
  1416. /*
  1417. * Check if we already have a slab created for this size
  1418. */
  1419. if (jbd_slab[i])
  1420. return 0;
  1421. /*
  1422. * Create a slab and force alignment to be same as slabsize -
  1423. * this will make sure that allocations won't cross the page
  1424. * boundary.
  1425. */
  1426. jbd_slab[i] = kmem_cache_create(jbd_slab_names[i],
  1427. slab_size, slab_size, 0, NULL, NULL);
  1428. if (!jbd_slab[i]) {
  1429. printk(KERN_EMERG "JBD: no memory for jbd_slab cache\n");
  1430. return -ENOMEM;
  1431. }
  1432. return 0;
  1433. }
  1434. void * jbd_slab_alloc(size_t size, gfp_t flags)
  1435. {
  1436. int idx;
  1437. idx = JBD_SLAB_INDEX(size);
  1438. BUG_ON(jbd_slab[idx] == NULL);
  1439. return kmem_cache_alloc(jbd_slab[idx], flags | __GFP_NOFAIL);
  1440. }
  1441. void jbd_slab_free(void *ptr, size_t size)
  1442. {
  1443. int idx;
  1444. idx = JBD_SLAB_INDEX(size);
  1445. BUG_ON(jbd_slab[idx] == NULL);
  1446. kmem_cache_free(jbd_slab[idx], ptr);
  1447. }
  1448. /*
  1449. * Journal_head storage management
  1450. */
  1451. static struct kmem_cache *journal_head_cache;
  1452. #ifdef CONFIG_JBD_DEBUG
  1453. static atomic_t nr_journal_heads = ATOMIC_INIT(0);
  1454. #endif
  1455. static int journal_init_journal_head_cache(void)
  1456. {
  1457. int retval;
  1458. J_ASSERT(journal_head_cache == 0);
  1459. journal_head_cache = kmem_cache_create("journal_head",
  1460. sizeof(struct journal_head),
  1461. 0, /* offset */
  1462. 0, /* flags */
  1463. NULL, /* ctor */
  1464. NULL); /* dtor */
  1465. retval = 0;
  1466. if (journal_head_cache == 0) {
  1467. retval = -ENOMEM;
  1468. printk(KERN_EMERG "JBD: no memory for journal_head cache\n");
  1469. }
  1470. return retval;
  1471. }
  1472. static void journal_destroy_journal_head_cache(void)
  1473. {
  1474. J_ASSERT(journal_head_cache != NULL);
  1475. kmem_cache_destroy(journal_head_cache);
  1476. journal_head_cache = NULL;
  1477. }
  1478. /*
  1479. * journal_head splicing and dicing
  1480. */
  1481. static struct journal_head *journal_alloc_journal_head(void)
  1482. {
  1483. struct journal_head *ret;
  1484. static unsigned long last_warning;
  1485. #ifdef CONFIG_JBD_DEBUG
  1486. atomic_inc(&nr_journal_heads);
  1487. #endif
  1488. ret = kmem_cache_alloc(journal_head_cache, GFP_NOFS);
  1489. if (ret == 0) {
  1490. jbd_debug(1, "out of memory for journal_head\n");
  1491. if (time_after(jiffies, last_warning + 5*HZ)) {
  1492. printk(KERN_NOTICE "ENOMEM in %s, retrying.\n",
  1493. __FUNCTION__);
  1494. last_warning = jiffies;
  1495. }
  1496. while (ret == 0) {
  1497. yield();
  1498. ret = kmem_cache_alloc(journal_head_cache, GFP_NOFS);
  1499. }
  1500. }
  1501. return ret;
  1502. }
  1503. static void journal_free_journal_head(struct journal_head *jh)
  1504. {
  1505. #ifdef CONFIG_JBD_DEBUG
  1506. atomic_dec(&nr_journal_heads);
  1507. memset(jh, JBD_POISON_FREE, sizeof(*jh));
  1508. #endif
  1509. kmem_cache_free(journal_head_cache, jh);
  1510. }
  1511. /*
  1512. * A journal_head is attached to a buffer_head whenever JBD has an
  1513. * interest in the buffer.
  1514. *
  1515. * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
  1516. * is set. This bit is tested in core kernel code where we need to take
  1517. * JBD-specific actions. Testing the zeroness of ->b_private is not reliable
  1518. * there.
  1519. *
  1520. * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
  1521. *
  1522. * When a buffer has its BH_JBD bit set it is immune from being released by
  1523. * core kernel code, mainly via ->b_count.
  1524. *
  1525. * A journal_head may be detached from its buffer_head when the journal_head's
  1526. * b_transaction, b_cp_transaction and b_next_transaction pointers are NULL.
  1527. * Various places in JBD call journal_remove_journal_head() to indicate that the
  1528. * journal_head can be dropped if needed.
  1529. *
  1530. * Various places in the kernel want to attach a journal_head to a buffer_head
  1531. * _before_ attaching the journal_head to a transaction. To protect the
  1532. * journal_head in this situation, journal_add_journal_head elevates the
  1533. * journal_head's b_jcount refcount by one. The caller must call
  1534. * journal_put_journal_head() to undo this.
  1535. *
  1536. * So the typical usage would be:
  1537. *
  1538. * (Attach a journal_head if needed. Increments b_jcount)
  1539. * struct journal_head *jh = journal_add_journal_head(bh);
  1540. * ...
  1541. * jh->b_transaction = xxx;
  1542. * journal_put_journal_head(jh);
  1543. *
  1544. * Now, the journal_head's b_jcount is zero, but it is safe from being released
  1545. * because it has a non-zero b_transaction.
  1546. */
  1547. /*
  1548. * Give a buffer_head a journal_head.
  1549. *
  1550. * Doesn't need the journal lock.
  1551. * May sleep.
  1552. */
  1553. struct journal_head *journal_add_journal_head(struct buffer_head *bh)
  1554. {
  1555. struct journal_head *jh;
  1556. struct journal_head *new_jh = NULL;
  1557. repeat:
  1558. if (!buffer_jbd(bh)) {
  1559. new_jh = journal_alloc_journal_head();
  1560. memset(new_jh, 0, sizeof(*new_jh));
  1561. }
  1562. jbd_lock_bh_journal_head(bh);
  1563. if (buffer_jbd(bh)) {
  1564. jh = bh2jh(bh);
  1565. } else {
  1566. J_ASSERT_BH(bh,
  1567. (atomic_read(&bh->b_count) > 0) ||
  1568. (bh->b_page && bh->b_page->mapping));
  1569. if (!new_jh) {
  1570. jbd_unlock_bh_journal_head(bh);
  1571. goto repeat;
  1572. }
  1573. jh = new_jh;
  1574. new_jh = NULL; /* We consumed it */
  1575. set_buffer_jbd(bh);
  1576. bh->b_private = jh;
  1577. jh->b_bh = bh;
  1578. get_bh(bh);
  1579. BUFFER_TRACE(bh, "added journal_head");
  1580. }
  1581. jh->b_jcount++;
  1582. jbd_unlock_bh_journal_head(bh);
  1583. if (new_jh)
  1584. journal_free_journal_head(new_jh);
  1585. return bh->b_private;
  1586. }
  1587. /*
  1588. * Grab a ref against this buffer_head's journal_head. If it ended up not
  1589. * having a journal_head, return NULL
  1590. */
  1591. struct journal_head *journal_grab_journal_head(struct buffer_head *bh)
  1592. {
  1593. struct journal_head *jh = NULL;
  1594. jbd_lock_bh_journal_head(bh);
  1595. if (buffer_jbd(bh)) {
  1596. jh = bh2jh(bh);
  1597. jh->b_jcount++;
  1598. }
  1599. jbd_unlock_bh_journal_head(bh);
  1600. return jh;
  1601. }
  1602. static void __journal_remove_journal_head(struct buffer_head *bh)
  1603. {
  1604. struct journal_head *jh = bh2jh(bh);
  1605. J_ASSERT_JH(jh, jh->b_jcount >= 0);
  1606. get_bh(bh);
  1607. if (jh->b_jcount == 0) {
  1608. if (jh->b_transaction == NULL &&
  1609. jh->b_next_transaction == NULL &&
  1610. jh->b_cp_transaction == NULL) {
  1611. J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
  1612. J_ASSERT_BH(bh, buffer_jbd(bh));
  1613. J_ASSERT_BH(bh, jh2bh(jh) == bh);
  1614. BUFFER_TRACE(bh, "remove journal_head");
  1615. if (jh->b_frozen_data) {
  1616. printk(KERN_WARNING "%s: freeing "
  1617. "b_frozen_data\n",
  1618. __FUNCTION__);
  1619. jbd_slab_free(jh->b_frozen_data, bh->b_size);
  1620. }
  1621. if (jh->b_committed_data) {
  1622. printk(KERN_WARNING "%s: freeing "
  1623. "b_committed_data\n",
  1624. __FUNCTION__);
  1625. jbd_slab_free(jh->b_committed_data, bh->b_size);
  1626. }
  1627. bh->b_private = NULL;
  1628. jh->b_bh = NULL; /* debug, really */
  1629. clear_buffer_jbd(bh);
  1630. __brelse(bh);
  1631. journal_free_journal_head(jh);
  1632. } else {
  1633. BUFFER_TRACE(bh, "journal_head was locked");
  1634. }
  1635. }
  1636. }
  1637. /*
  1638. * journal_remove_journal_head(): if the buffer isn't attached to a transaction
  1639. * and has a zero b_jcount then remove and release its journal_head. If we did
  1640. * see that the buffer is not used by any transaction we also "logically"
  1641. * decrement ->b_count.
  1642. *
  1643. * We in fact take an additional increment on ->b_count as a convenience,
  1644. * because the caller usually wants to do additional things with the bh
  1645. * after calling here.
  1646. * The caller of journal_remove_journal_head() *must* run __brelse(bh) at some
  1647. * time. Once the caller has run __brelse(), the buffer is eligible for
  1648. * reaping by try_to_free_buffers().
  1649. */
  1650. void journal_remove_journal_head(struct buffer_head *bh)
  1651. {
  1652. jbd_lock_bh_journal_head(bh);
  1653. __journal_remove_journal_head(bh);
  1654. jbd_unlock_bh_journal_head(bh);
  1655. }
  1656. /*
  1657. * Drop a reference on the passed journal_head. If it fell to zero then try to
  1658. * release the journal_head from the buffer_head.
  1659. */
  1660. void journal_put_journal_head(struct journal_head *jh)
  1661. {
  1662. struct buffer_head *bh = jh2bh(jh);
  1663. jbd_lock_bh_journal_head(bh);
  1664. J_ASSERT_JH(jh, jh->b_jcount > 0);
  1665. --jh->b_jcount;
  1666. if (!jh->b_jcount && !jh->b_transaction) {
  1667. __journal_remove_journal_head(bh);
  1668. __brelse(bh);
  1669. }
  1670. jbd_unlock_bh_journal_head(bh);
  1671. }
  1672. /*
  1673. * /proc tunables
  1674. */
  1675. #if defined(CONFIG_JBD_DEBUG)
  1676. int journal_enable_debug;
  1677. EXPORT_SYMBOL(journal_enable_debug);
  1678. #endif
  1679. #if defined(CONFIG_JBD_DEBUG) && defined(CONFIG_PROC_FS)
  1680. static struct proc_dir_entry *proc_jbd_debug;
  1681. static int read_jbd_debug(char *page, char **start, off_t off,
  1682. int count, int *eof, void *data)
  1683. {
  1684. int ret;
  1685. ret = sprintf(page + off, "%d\n", journal_enable_debug);
  1686. *eof = 1;
  1687. return ret;
  1688. }
  1689. static int write_jbd_debug(struct file *file, const char __user *buffer,
  1690. unsigned long count, void *data)
  1691. {
  1692. char buf[32];
  1693. if (count > ARRAY_SIZE(buf) - 1)
  1694. count = ARRAY_SIZE(buf) - 1;
  1695. if (copy_from_user(buf, buffer, count))
  1696. return -EFAULT;
  1697. buf[ARRAY_SIZE(buf) - 1] = '\0';
  1698. journal_enable_debug = simple_strtoul(buf, NULL, 10);
  1699. return count;
  1700. }
  1701. #define JBD_PROC_NAME "sys/fs/jbd-debug"
  1702. static void __init create_jbd_proc_entry(void)
  1703. {
  1704. proc_jbd_debug = create_proc_entry(JBD_PROC_NAME, 0644, NULL);
  1705. if (proc_jbd_debug) {
  1706. /* Why is this so hard? */
  1707. proc_jbd_debug->read_proc = read_jbd_debug;
  1708. proc_jbd_debug->write_proc = write_jbd_debug;
  1709. }
  1710. }
  1711. static void __exit remove_jbd_proc_entry(void)
  1712. {
  1713. if (proc_jbd_debug)
  1714. remove_proc_entry(JBD_PROC_NAME, NULL);
  1715. }
  1716. #else
  1717. #define create_jbd_proc_entry() do {} while (0)
  1718. #define remove_jbd_proc_entry() do {} while (0)
  1719. #endif
  1720. struct kmem_cache *jbd_handle_cache;
  1721. static int __init journal_init_handle_cache(void)
  1722. {
  1723. jbd_handle_cache = kmem_cache_create("journal_handle",
  1724. sizeof(handle_t),
  1725. 0, /* offset */
  1726. 0, /* flags */
  1727. NULL, /* ctor */
  1728. NULL); /* dtor */
  1729. if (jbd_handle_cache == NULL) {
  1730. printk(KERN_EMERG "JBD: failed to create handle cache\n");
  1731. return -ENOMEM;
  1732. }
  1733. return 0;
  1734. }
  1735. static void journal_destroy_handle_cache(void)
  1736. {
  1737. if (jbd_handle_cache)
  1738. kmem_cache_destroy(jbd_handle_cache);
  1739. }
  1740. /*
  1741. * Module startup and shutdown
  1742. */
  1743. static int __init journal_init_caches(void)
  1744. {
  1745. int ret;
  1746. ret = journal_init_revoke_caches();
  1747. if (ret == 0)
  1748. ret = journal_init_journal_head_cache();
  1749. if (ret == 0)
  1750. ret = journal_init_handle_cache();
  1751. return ret;
  1752. }
  1753. static void journal_destroy_caches(void)
  1754. {
  1755. journal_destroy_revoke_caches();
  1756. journal_destroy_journal_head_cache();
  1757. journal_destroy_handle_cache();
  1758. journal_destroy_jbd_slabs();
  1759. }
  1760. static int __init journal_init(void)
  1761. {
  1762. int ret;
  1763. BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
  1764. ret = journal_init_caches();
  1765. if (ret != 0)
  1766. journal_destroy_caches();
  1767. create_jbd_proc_entry();
  1768. return ret;
  1769. }
  1770. static void __exit journal_exit(void)
  1771. {
  1772. #ifdef CONFIG_JBD_DEBUG
  1773. int n = atomic_read(&nr_journal_heads);
  1774. if (n)
  1775. printk(KERN_EMERG "JBD: leaked %d journal_heads!\n", n);
  1776. #endif
  1777. remove_jbd_proc_entry();
  1778. journal_destroy_caches();
  1779. }
  1780. MODULE_LICENSE("GPL");
  1781. module_init(journal_init);
  1782. module_exit(journal_exit);