| blob | 072156c4f8951efc3095ff4251e77619863d54f5 |
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Write ahead logging implementation copyright Chris Mason 2000
4 *
5 * The background commits make this code very interrelated, and
6 * overly complex. I need to rethink things a bit....The major players:
7 *
8 * journal_begin -- call with the number of blocks you expect to log.
9 * If the current transaction is too
10 * old, it will block until the current transaction is
11 * finished, and then start a new one.
12 * Usually, your transaction will get joined in with
13 * previous ones for speed.
14 *
15 * journal_join -- same as journal_begin, but won't block on the current
16 * transaction regardless of age. Don't ever call
17 * this. Ever. There are only two places it should be
18 * called from, and they are both inside this file.
19 *
20 * journal_mark_dirty -- adds blocks into this transaction. clears any flags
21 * that might make them get sent to disk
22 * and then marks them BH_JDirty. Puts the buffer head
23 * into the current transaction hash.
24 *
25 * journal_end -- if the current transaction is batchable, it does nothing
26 * otherwise, it could do an async/synchronous commit, or
27 * a full flush of all log and real blocks in the
28 * transaction.
29 *
30 * flush_old_commits -- if the current transaction is too old, it is ended and
31 * commit blocks are sent to disk. Forces commit blocks
32 * to disk for all backgrounded commits that have been
33 * around too long.
34 * -- Note, if you call this as an immediate flush from
35 * from within kupdate, it will ignore the immediate flag
36 */
38 #include <linux/time.h>
39 #include <linux/semaphore.h>
40 #include <linux/vmalloc.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/buffer_head.h>
48 #include <linux/workqueue.h>
49 #include <linux/writeback.h>
50 #include <linux/blkdev.h>
51 #include <linux/backing-dev.h>
52 #include <linux/uaccess.h>
53 #include <linux/slab.h>
56 /* gets a struct reiserfs_journal_list * from a list head */
57 #define JOURNAL_LIST_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \
58 j_list))
60 /* must be correct to keep the desc and commit structs at 4k */
61 #define JOURNAL_TRANS_HALF 1018
64 /* cnode stat bits. Move these into reiserfs_fs.h */
66 /* this block was freed, and can't be written. */
67 #define BLOCK_FREED 2
68 /* this block was freed during this transaction, and can't be written */
69 #define BLOCK_FREED_HOLDER 3
71 /* used in flush_journal_list */
72 #define BLOCK_NEEDS_FLUSH 4
73 #define BLOCK_DIRTIED 5
75 /* journal list state bits */
76 #define LIST_TOUCHED 1
77 #define LIST_DIRTY 2
80 /* flags for do_journal_end */
100 /* values for join in do_journal_begin_r */
103 /* join the running transaction if at all possible */
105 /* called from cleanup code, ignores aborted flag */
107 };
114 {
118 }
120 /*
121 * clears BH_Dirty and sticks the buffer on the clean list. Called because
122 * I can't allow refile_buffer to make schedule happen after I've freed a
123 * block. Look at remove_from_transaction and journal_mark_freed for
124 * more details.
125 */
127 {
131 }
133 }
137 {
144 }
149 }
153 }
156 {
162 repeat:
170 }
175 }
177 }
180 {
189 }
190 }
193 {
203 /* this is ok, we'll try again when more are needed */
205 }
206 }
207 }
210 b_blocknr_t block,
212 {
218 }
221 }
225 {
234 }
235 }
236 }
238 /*
239 * only call this on FS unmount.
240 */
243 {
252 }
254 }
257 {
269 }
272 }
274 /*
275 * get memory for JOURNAL_NUM_BITMAPS worth of bitmaps.
276 * jb_array is the array to be filled in.
277 */
281 {
296 }
297 }
301 }
303 }
305 /*
306 * find an available list bitmap. If you can't find one, flush a commit list
307 * and try again
308 */
310 struct reiserfs_journal_list
312 {
327 }
330 }
331 }
332 /* double check to make sure if flushed correctly */
337 }
339 /*
340 * allocates a new chunk of X nodes, and links them all together as a list.
341 * Uses the cnode->next and cnode->prev pointers
342 * returns NULL on failure
343 */
345 {
350 }
355 }
361 }
364 }
366 /* pulls a cnode off the free list, or returns NULL on failure */
368 {
376 }
382 }
385 }
389 }
391 /*
392 * returns a cnode to the free list
393 */
396 {
403 /* memset(cn, 0, sizeof(struct reiserfs_journal_cnode)) ; */
407 }
408 cn->prev = NULL; /* not needed with the memset, but I might kill the memset, and forget to do this */
410 }
413 {
416 }
418 /*
419 * return a cnode with same dev, block number and size in table,
420 * or null if not found
421 */
423 super_block
425 struct
426 reiserfs_journal_cnode
429 {
436 }
438 }
440 /*
441 * this actually means 'can this block be reallocated yet?'. If you set
442 * search_all, a block can only be allocated if it is not in the current
443 * transaction, was not freed by the current transaction, and has no chance
444 * of ever being overwritten by a replay after crashing.
445 *
446 * If you don't set search_all, a block can only be allocated if it is not
447 * in the current transaction. Since deleting a block removes it from the
448 * current transaction, this case should never happen. If you don't set
449 * search_all, make sure you never write the block without logging it.
450 *
451 * next_zero_bit is a suggestion about the next block to try for find_forward.
452 * when bl is rejected because it is set in a journal list bitmap, we search
453 * for the next zero bit in the bitmap that rejected bl. Then, we return
454 * that through next_zero_bit for find_forward to try.
455 *
456 * Just because we return something in next_zero_bit does not mean we won't
457 * reject it on the next call to reiserfs_in_journal
458 */
462 {
472 /*
473 * If we aren't doing a search_all, this is a metablock, and it
474 * will be logged before use. if we crash before the transaction
475 * that freed it commits, this transaction won't have committed
476 * either, and the block will never be written
477 */
485 data)) {
489 data),
493 }
494 }
495 }
498 /* is it in any old transactions? */
503 }
505 /* is it in the current transaction. This should never happen */
509 }
512 /* safe for reuse */
514 }
516 /* insert cn into table */
519 {
527 }
529 }
531 /* lock the current transaction */
533 {
537 }
539 /* unlock the current transaction */
541 {
543 }
546 {
548 }
552 {
556 }
559 }
561 /*
562 * this used to be much more involved, and I'm keeping it just in case
563 * things get ugly again. it gets called by flush_commit_list, and
564 * cleans up any data stored about blocks freed during a transaction.
565 */
568 {
573 }
576 }
580 {
589 }
590 }
592 }
594 /*
595 * If page->mapping was null, we failed to truncate this page for
596 * some reason. Most likely because it was truncated after being
597 * logged via data=journal.
598 *
599 * This does a check to see if the buffer belongs to one of these
600 * lost pages before doing the final put_bh. If page->mapping was
601 * null, it tries to free buffers on the page, which should make the
602 * final put_page drop the page from the lru.
603 */
605 {
616 }
617 }
620 {
625 }
628 else
633 }
636 {
639 else
643 }
646 {
656 }
659 {
666 }
668 #define CHUNK_SIZE 32
672 };
675 {
679 }
681 }
684 {
688 }
690 }
694 {
706 }
707 }
709 }
713 {
720 }
722 }
723 }
725 /*
726 * we want to free the jh when the buffer has been written
727 * and waited on
728 */
730 {
743 }
744 }
748 {
756 }
760 no_jh:
764 /*
765 * buffer must be locked for __add_jh, should be able to have
766 * two adds at the same time
767 */
771 }
777 }
780 }
783 {
785 }
787 {
789 }
791 #define JH_ENTRY(l) list_entry((l), struct reiserfs_jh, list)
796 {
814 }
822 }
823 /*
824 * in theory, dirty non-uptodate buffers should never get here,
825 * but the upper layer io error paths still have a few quirks.
826 * Handle them here as gracefully as we can
827 */
831 }
838 }
839 loop_next:
842 }
847 }
858 }
861 }
862 /*
863 * ugly interaction with invalidatepage here.
864 * reiserfs_invalidate_page will pin any buffer that has a
865 * valid journal head from an older transaction. If someone
866 * else sets our buffer dirty after we write it in the first
867 * loop, and then someone truncates the page away, nobody
868 * will ever write the buffer. We're safe if we write the
869 * page one last time after freeing the journal header.
870 */
875 }
878 }
881 }
885 {
893 find_first:
894 /*
895 * first we walk backwards to find the oldest uncommitted transation
896 */
907 }
909 /* if we didn't find any older uncommitted transactions, return now */
912 }
923 /* list we were called with is gone, return */
927 /*
928 * the one we just flushed is gone, this means
929 * all older lists are also gone, so first_jl
930 * is no longer valid either. Go back to the
931 * beginning.
932 */
936 }
937 }
943 }
944 }
946 }
949 {
958 }
961 }
963 /*
964 * if this journal list still has commit blocks unflushed, send them to disk.
965 *
966 * log areas must be flushed in order (transaction 2 can't commit before
967 * transaction 1) Before the commit block can by written, every other log
968 * block must be safely on disk
969 */
972 {
974 b_blocknr_t bn;
986 }
988 /*
989 * before we can put our commit blocks on disk, we have to make
990 * sure everyone older than us is on disk too
991 */
998 /*
999 * list disappeared during flush_older_commits.
1000 * return
1001 */
1003 }
1004 }
1006 /* make sure nobody is trying to flush this one at the same time */
1012 }
1015 /* this commit is done, exit */
1019 }
1022 }
1027 /*
1028 * We might sleep in numerous places inside
1029 * write_ordered_buffers. Relax the write lock.
1030 */
1037 }
1039 /*
1040 * for the description block and all the log blocks, submit any buffers
1041 * that haven't already reached the disk. Try to write at least 256
1042 * log blocks. later on, we will only wait on blocks that correspond
1043 * to this transaction, but while we're unplugging we might as well
1044 * get a chunk of data on there.
1045 */
1059 }
1061 }
1062 }
1073 /*
1074 * since we're using ll_rw_blk above, it might have skipped
1075 * over a locked buffer. Double check here
1076 */
1077 /* redundant, sync_dirty_buffer() checks */
1082 }
1084 #ifdef CONFIG_REISERFS_CHECK
1087 #endif
1089 }
1090 /* once for journal_find_get_block */
1092 /* once due to original getblk in do_journal_end */
1095 }
1099 /*
1100 * If there was a write error in the journal - we can't commit
1101 * this transaction - it will be invalid and, if successful,
1102 * will just end up propagating the write error out to
1103 * the file system.
1104 */
1113 else
1116 }
1118 /*
1119 * If there was a write error in the journal - we can't commit this
1120 * transaction - it will be invalid and, if successful, will just end
1121 * up propagating the write error out to the filesystem.
1122 */
1124 #ifdef CONFIG_REISERFS_CHECK
1126 #endif
1128 }
1134 }
1137 /*
1138 * now, every commit block is on the disk. It is safe to allow
1139 * blocks freed during this transaction to be reallocated
1140 */
1145 /* mark the metadata dirty */
1152 }
1154 put_jl:
1159 __func__);
1161 }
1163 /*
1164 * flush_journal_list frequently needs to find a newer transaction for a
1165 * given block. This does that, or returns NULL if it can't find anything
1166 */
1168 reiserfs_journal_cnode
1170 {
1178 }
1180 }
1182 }
1189 /*
1190 * once all the real blocks have been flushed, it is safe to remove them
1191 * from the journal list for this transaction. Aside from freeing the
1192 * cnode, this also allows the block to be reallocated for data blocks
1193 * if it had been deleted.
1194 */
1198 {
1203 /*
1204 * which is better, to lock once around the whole loop, or
1205 * to lock for each call to remove_journal_hash?
1206 */
1214 }
1218 }
1222 }
1224 }
1226 /*
1227 * if this timestamp is greater than the timestamp we wrote last to the
1228 * header block, write it to the header block. once this is done, I can
1229 * safely say the log area for this transaction won't ever be replayed,
1230 * and I can start releasing blocks in this transaction for reuse as data
1231 * blocks. called by flush_journal_list, before it calls
1232 * remove_all_from_journal_list
1233 */
1237 {
1251 #ifdef CONFIG_REISERFS_CHECK
1254 #endif
1256 }
1257 }
1261 b_data);
1272 else
1280 }
1281 }
1283 }
1288 {
1290 }
1292 /*
1293 ** flush any and all journal lists older than you are
1294 ** can only be called from flush_journal_list
1295 */
1298 {
1304 /*
1305 * we know we are the only ones flushing things, no extra race
1306 * protection is required.
1307 */
1308 restart:
1310 /* Did we wrap? */
1316 /* do not flush all */
1319 /* other_jl is now deleted from the list */
1321 }
1323 }
1327 {
1332 }
1333 }
1335 /*
1336 * flush a journal list, both commit and real blocks
1337 *
1338 * always set flushall to 1, unless you are calling from inside
1339 * flush_journal_list
1340 *
1341 * IMPORTANT. This can only be called while there are no journal writers,
1342 * and the journal is locked. That means it can only be called from
1343 * do_journal_end, or by journal_release
1344 */
1347 {
1364 }
1366 /* if flushall == 0, the lock is already held */
1371 }
1378 }
1380 /* if all the work is already done, get out of here */
1384 }
1386 /*
1387 * start by putting the commit list on disk. This will also flush
1388 * the commit lists of any olders transactions
1389 */
1396 /* are we done now? */
1400 }
1402 /*
1403 * loop through each cnode, see if we need to write it,
1404 * or wait on a more recent transaction, or just ignore it
1405 */
1409 }
1415 /* blocknr of 0 is no longer in the hash, ignore it */
1418 }
1420 /*
1421 * This transaction failed commit.
1422 * Don't write out to the disk
1423 */
1428 /*
1429 * the order is important here. We check pjl to make sure we
1430 * don't clear BH_JDirty_wait if we aren't the one writing this
1431 * block to disk
1432 */
1436 /*
1437 * we do this to make sure nobody releases the
1438 * buffer while we are working with it
1439 */
1447 /*
1448 * everything with !pjl && jwait
1449 * should be writable
1450 */
1452 }
1453 }
1455 /*
1456 * if someone has this block in a newer transaction, just make
1457 * sure they are committed, and don't try writing it to disk
1458 */
1463 }
1465 /*
1466 * bh == NULL when the block got to disk on its own, OR,
1467 * the block got freed in a future transaction
1468 */
1471 }
1473 /*
1474 * this should never happen. kupdate_one_transaction has
1475 * this list locked while it works, so we should never see a
1476 * buffer here that is not marked JDirty_wait
1477 */
1480 "BAD! buffer %llu %cdirty %cjwait, "
1485 }
1487 /*
1488 * we inc again because saved_bh gets decremented
1489 * at free_cnode
1490 */
1497 else
1499 count++;
1505 }
1506 free_cnode:
1509 /*
1510 * we incremented this to keep others from
1511 * taking the buffer head away
1512 */
1517 }
1518 }
1519 }
1527 }
1536 }
1538 #ifdef CONFIG_REISERFS_CHECK
1541 #endif
1543 }
1544 /*
1545 * note, we must clear the JDirty_wait bit
1546 * after the up to date check, otherwise we
1547 * race against our flushpage routine
1548 */
1552 /* drop one ref for us */
1554 /* drop one ref for journal_mark_dirty */
1556 }
1558 }
1559 }
1564 __func__);
1565 flush_older_and_return:
1567 /*
1568 * before we can update the journal header block, we _must_ flush all
1569 * real blocks from all older transactions to disk. This is because
1570 * once the header block is updated, this transaction will not be
1571 * replayed after a crash
1572 */
1575 }
1578 /*
1579 * before we can remove everything from the hash tables for this
1580 * transaction, we must make sure it can never be replayed
1581 *
1582 * since we are only called from do_journal_end, we know for sure there
1583 * are no allocations going on while we are flushing journal lists. So,
1584 * we only need to update the journal header block for the last list
1585 * being flushed
1586 */
1588 err =
1596 __func__);
1597 }
1607 }
1610 /*
1611 * not strictly required since we are freeing the list, but it should
1612 * help find code using dead lists later on
1613 */
1625 }
1630 {
1638 }
1642 /*
1643 * if the blocknr == 0, this has been cleared from the hash,
1644 * skip it
1645 */
1648 }
1651 /*
1652 * we can race against journal_mark_freed when we try
1653 * to lock_buffer(cn->bh), so we have to inc the buffer
1654 * count, and recheck things after locking
1655 */
1664 ret++;
1666 /* note, cn->bh might be null now */
1668 }
1670 }
1671 next:
1674 }
1676 }
1678 /* used by flush_commit_list */
1681 {
1688 /*
1689 * look for a more recent transaction that logged this
1690 * buffer. Only the most recent transaction with a buffer in
1691 * it is allowed to send that buffer to disk
1692 */
1697 /*
1698 * if the buffer is prepared, it will either be logged
1699 * or restored. If restored, we need to make sure
1700 * it actually gets marked dirty
1701 */
1708 }
1709 }
1711 }
1712 }
1719 {
1732 }
1734 /*
1735 * we've got j_flush_mutex held, nobody is going to delete any
1736 * of these lists out from underneath us
1737 */
1746 }
1751 transactions_flushed++;
1755 /* did we wrap? */
1758 }
1761 /* don't bother with older transactions */
1764 }
1767 }
1769 done:
1772 }
1774 /*
1775 * for o_sync and fsync heavy applications, they tend to use
1776 * all the journa list slots with tiny transactions. These
1777 * trigger lots and lots of calls to update the header block, which
1778 * adds seeks and slows things down.
1779 *
1780 * This function tries to clear out a large chunk of the journal lists
1781 * at once, which makes everything faster since only the newest journal
1782 * list updates the header block
1783 */
1786 {
1798 /* in data logging mode, try harder to flush a lot of blocks */
1801 /* flush for 256 transactions or limit blocks, whichever comes first */
1806 }
1810 }
1816 }
1820 /*
1821 * try to find a group of blocks we can flush across all the
1822 * transactions, but only bother if we've actually spanned
1823 * across multiple lists
1824 */
1832 }
1834 /*
1835 * removes any nodes in table with name block and dev as bh.
1836 * only touchs the hnext and hprev pointers.
1837 */
1842 {
1849 }
1857 }
1862 }
1866 /*
1867 * anybody who clears the cur->bh will also
1868 * dec the nonzerolen
1869 */
1874 }
1876 }
1877 }
1880 {
1890 }
1891 /*
1892 * j_header_bh is on the journal dev, make sure
1893 * not to release the journal dev until we brelse j_header_bh
1894 */
1897 }
1899 /*
1900 * call on unmount. Only set error to 1 if you haven't made your way out
1901 * of read_super() yet. Any other caller must keep error at 0.
1902 */
1905 {
1909 /*
1910 * we only want to flush out transactions if we were
1911 * called with error == 0
1912 */
1914 /* end the current trans */
1918 /*
1919 * make sure something gets logged to force
1920 * our way into the flush code
1921 */
1928 }
1929 }
1931 /* this also catches errors during the do_journal_end above */
1940 }
1941 }
1944 /*
1945 * We must release the write lock here because
1946 * the workqueue job (flush_async_commit) needs this lock
1947 */
1950 /*
1951 * Cancel flushing of old commits. Note that neither of these works
1952 * will be requeued because superblock is being shutdown and doesn't
1953 * have SB_ACTIVE set.
1954 */
1956 /* wait for all commits to finish */
1964 }
1966 /* * call on unmount. flush all journal trans, release all alloc'd ram */
1969 {
1971 }
1973 /* only call from an error condition inside reiserfs_read_super! */
1976 {
1978 }
1980 /*
1981 * compares description block with commit block.
1982 * returns 1 if they differ, 0 if they are the same
1983 */
1987 {
1993 }
1995 }
1997 /*
1998 * returns 0 if it did not find a description block
1999 * returns -1 if it found a corrupt commit block
2000 * returns 1 if both desc and commit were valid
2001 * NOTE: only called during fs mount
2002 */
2007 {
2022 "journal-986: transaction "
2023 "is valid returning because trans_id %d is greater than "
2028 }
2032 "journal-1087: transaction "
2033 "is valid returning because mount_id %d is less than "
2038 }
2041 "Bad transaction length %d "
2045 }
2048 /*
2049 * ok, we have a journal description block,
2050 * let's see if the transaction was valid
2051 */
2052 c_bh =
2062 "journal_transaction_is_valid, commit offset %ld had bad "
2073 "journal-1004: "
2074 "transaction_is_valid setting oldest invalid trans_id "
2077 }
2079 }
2082 "journal-1006: found valid "
2091 }
2092 }
2095 {
2099 }
2100 }
2102 /*
2103 * given the start, and values for the oldest acceptable transactions,
2104 * this either reads in a replays a transaction, or returns because the
2105 * transaction is invalid, or too old.
2106 * NOTE: only called during fs mount
2107 */
2113 {
2138 cur_dblock -
2142 }
2145 "journal_read_trans skipping because %d is != "
2147 newest_mount_id);
2150 }
2157 }
2161 "journal_read_transaction, "
2170 }
2178 }
2181 /*
2182 * now we know we've got a good transaction, and it was
2183 * inside the valid time ranges
2184 */
2187 GFP_NOFS);
2190 GFP_NOFS);
2199 }
2200 /* get all the buffer heads */
2217 }
2220 "REPLAY FAILURE fsck required! "
2221 "Block to replay is outside of "
2224 }
2225 /* make sure we don't try to replay onto log or reserved area */
2229 "REPLAY FAILURE fsck required! "
2231 abort_replay:
2239 }
2240 }
2241 /* read in the log blocks, memcpy to the corresponding real block */
2248 "REPLAY FAILURE fsck required! "
2258 }
2263 }
2264 /* flush out the real blocks */
2268 }
2273 "REPLAY FAILURE, fsck required! "
2282 }
2284 }
2285 cur_dblock =
2293 /*
2294 * init starting values for the first transaction, in case
2295 * this is the last transaction to be replayed.
2296 */
2300 /* check for trans_id overflow */
2308 }
2310 /*
2311 * This function reads blocks starting from block and to max_block of bufsize
2312 * size (but no more than BUFNR blocks at a time). This proved to improve
2313 * mounting speed on self-rebuilding raid5 arrays at least.
2314 * Right now it is only used from journal code. But later we might use it
2315 * from other places.
2316 * Note: Do not use journal_getblk/sb_getblk functions here!
2317 */
2320 b_blocknr_t max_block)
2321 {
2333 }
2343 }
2353 }
2355 /*
2356 * read and replay the log
2357 * on a clean unmount, the journal header's next unflushed pointer will be
2358 * to an invalid transaction. This tests that before finding all the
2359 * transactions in the log, which makes normal mount times fast.
2360 *
2361 * After a crash, this starts with the next unflushed transaction, and
2362 * replays until it finds one too old, or invalid.
2363 *
2364 * On exit, it sets things up so the first transaction will work correctly.
2365 * NOTE: only called during fs mount
2366 */
2368 {
2373 time64_t start;
2389 /*
2390 * step 1, read in the journal header block. Check the transaction
2391 * it says is the first unflushed, and if that transaction is not
2392 * valid, replay is done
2393 */
2399 }
2404 oldest_start =
2410 "journal-1153: found in "
2411 "header: first_unflushed_offset %d, last_flushed_trans_id "
2416 /*
2417 * now, we try to read the first unflushed offset. If it
2418 * is not valid, there is nothing more we can do, and it
2419 * makes no sense to read through the whole log.
2420 */
2421 d_bh =
2428 }
2431 }
2433 /*
2434 * ok, there are transactions that need to be replayed. start
2435 * with the first log block, find all the valid transactions, and
2436 * pick out the oldest.
2437 */
2442 /*
2443 * Note that it is required for blocksize of primary fs
2444 * device and journal device to be the same
2445 */
2446 d_bh =
2451 ret =
2462 "journal-1179: Setting "
2464 oldest_start -
2465 SB_ONDISK_JOURNAL_1st_BLOCK
2468 /* one we just read was older */
2472 "journal-1180: Resetting "
2474 oldest_start -
2475 SB_ONDISK_JOURNAL_1st_BLOCK
2477 }
2481 "journal-1299: Setting "
2484 }
2487 cur_dblock++;
2488 }
2490 }
2492 start_log_replay:
2496 "journal-1206: Starting replay "
2499 oldest_trans_id);
2501 }
2504 ret =
2511 }
2512 cur_dblock =
2514 replay_count++;
2517 }
2522 }
2523 /*
2524 * j_start does not get set correctly if we don't replay any
2525 * transactions. if we had a valid journal_header, set j_start
2526 * to the first unflushed transaction value, copy the trans_id
2527 * from the header
2528 */
2533 /* check for trans_id overflow */
2541 }
2549 }
2550 /* needed to satisfy the locking in _update_journal_header_block */
2556 /*
2557 * replay failed, caller must call free_journal_ram and abort
2558 * the mount
2559 */
2561 }
2564 }
2567 {
2579 }
2582 {
2584 }
2588 {
2592 }
2593 }
2598 {
2600 dev_t jdev;
2613 /* there is no "jdev" option and journal is on separate device */
2618 journal);
2631 }
2642 }
2649 }
2651 /*
2652 * When creating/tuning a file system user can assign some
2653 * journal params within boundaries which depend on the ratio
2654 * blocksize/standard_blocksize.
2655 *
2656 * For blocks >= standard_blocksize transaction size should
2657 * be not less then JOURNAL_TRANS_MIN_DEFAULT, and not more
2658 * then JOURNAL_TRANS_MAX_DEFAULT.
2659 *
2660 * For blocks < standard_blocksize these boundaries should be
2661 * decreased proportionally.
2662 */
2663 #define REISERFS_STANDARD_BLKSIZE (4096)
2667 {
2669 /* Non-default journal params. Do sanity check for them. */
2677 JOURNAL_MIN_RATIO) {
2679 "bad transaction max size (%u). "
2682 }
2686 "bad transaction max batch (%u). "
2689 }
2691 /*
2692 * Default journal params.
2693 * The file system was created by old version
2694 * of mkreiserfs, so some fields contain zeros,
2695 * and we need to advise proper values for them
2696 */
2701 }
2705 }
2707 }
2709 /* must be called once on fs mount. calls journal_read for you */
2712 {
2726 }
2738 /* reserved for journal area support */
2740 REISERFS_OLD_DISK_OFFSET_IN_BYTES
2744 REISERFS_DISK_OFFSET_IN_BYTES /
2747 /*
2748 * Sanity check to see is the standard journal fitting
2749 * within first bitmap (actual for small blocksizes)
2750 */
2755 "journal does not fit for area addressed "
2756 "by first of bitmap blocks. It starts at "
2762 }
2768 }
2772 /* read journal header */
2780 }
2783 /* make sure that journal matches to the super block */
2788 "journal header magic %x (device %pg) does "
2795 }
2810 }
2813 "journal first block %u, max trans len %u, max batch %u, "
2858 "allocation failed (%ld bytes). Journal is "
2859 "too large for available memory. Usually "
2863 }
2868 /*
2869 * get_list_bitmap() may call flush_commit_list() which
2870 * requires the lock. Calling flush_commit_list() shouldn't happen
2871 * this early but I like to be paranoid.
2872 */
2880 }
2887 }
2892 free_and_return:
2895 }
2897 /*
2898 * test for a polite end of the current transaction. Used by file_write,
2899 * and should be used by delete to make sure they don't write more than
2900 * can fit inside a single transaction
2901 */
2904 {
2907 /* cannot restart while nested */
2917 }
2922 }
2924 /* this must be called inside a transaction */
2926 {
2932 }
2934 /* this must be called without a transaction started */
2936 {
2940 }
2942 /* this must be called without a transaction started */
2944 {
2948 }
2951 {
2952 wait_queue_entry_t wait;
2956 /*
2957 * we don't want to use wait_event here because
2958 * we only want to wait once.
2959 */
2967 }
2970 }
2973 {
2977 }
2980 {
2995 }
3001 }
3002 }
3004 /*
3005 * join == true if you must join an existing transaction.
3006 * join == false if you can deal with waiting for others to finish
3007 *
3008 * this will block until the transaction is joinable. send the number of
3009 * blocks you expect to use in nblocks.
3010 */
3014 {
3027 /* set here for journal_join */
3031 relock:
3037 }
3047 }
3050 /*
3051 * if there is no room in the journal OR
3052 * if this transaction is too old, and we weren't called joinable,
3053 * wait for it to finish before beginning we don't sleep if there
3054 * aren't other writers
3055 */
3058 (!join
3068 /* allow others to finish this transaction */
3076 sched_count++;
3079 }
3080 }
3081 /*
3082 * don't mess with joining the transaction if all we
3083 * have to do is wait for someone else to do a commit
3084 */
3089 }
3091 }
3096 /* someone might have ended the transaction while we joined */
3101 }
3108 }
3109 /* we are the first writer, set trans_id */
3112 }
3122 out_fail:
3124 /*
3125 * Re-set th->t_super, so we can properly keep track of how many
3126 * persistent transactions there are. We need to do this so if this
3127 * call is part of a failed restart_transaction, we can free it later
3128 */
3131 }
3134 super_block
3137 {
3141 /*
3142 * if we're nesting into an existing transaction. It will be
3143 * persistent on its own
3144 */
3151 }
3159 }
3163 }
3166 {
3171 else
3176 }
3178 }
3182 {
3185 /*
3186 * this keeps do_journal_end from NULLing out the
3187 * current->journal_info pointer
3188 */
3192 }
3196 {
3199 /*
3200 * this keeps do_journal_end from NULLing out the
3201 * current->journal_info pointer
3202 */
3206 }
3210 {
3216 /* we are nesting into the current transaction */
3223 "BAD: refcount <= 1, but "
3227 /*
3228 * we've ended up with a handle from a different
3229 * filesystem. save it and restore on journal_end.
3230 * This should never really happen...
3231 */
3236 }
3239 }
3243 /*
3244 * I guess this boils down to being the reciprocal of clm-2100 above.
3245 * If do_journal_begin_r fails, we need to put it back, since
3246 * journal_end won't be called to do it. */
3249 else
3253 }
3255 /*
3256 * puts bh into the current transaction. If it was already there, reorders
3257 * removes the old pointers from the hash, and puts new ones in (to make
3258 * sure replay happen in the right order).
3259 *
3260 * if it was dirty, cleans and files onto the clean list. I can't let it
3261 * be dirty again until the transaction is committed.
3262 *
3263 * if j_len, is bigger than j_len_alloc, it pushes j_len_alloc to 10 + j_len.
3264 */
3267 {
3280 }
3284 /* already in this transaction, we are done */
3288 }
3290 /*
3291 * this must be turned into a panic instead of a warning. We can't
3292 * allow a dirty or journal_dirty or locked buffer to be logged, as
3293 * some changes could get to disk too early. NOT GOOD.
3294 */
3297 "buffer %llu bad state "
3304 }
3311 }
3312 /*
3313 * this error means I've screwed up, and we've overflowed
3314 * the transaction. Nothing can be done here, except make the
3315 * FS readonly or panic.
3316 */
3321 }
3327 }
3331 }
3335 /* now put this guy on the end */
3340 }
3345 }
3356 }
3357 }
3367 }
3370 }
3373 {
3382 }
3389 /*
3390 * we aren't allowed to close a nested transaction on a
3391 * different filesystem from the one in the task struct
3392 */
3398 }
3402 }
3403 }
3405 /*
3406 * removes from the current transaction, relsing and descrementing any counters.
3407 * also files the removed buffer directly onto the clean list
3408 *
3409 * called by journal_mark_freed when a block has been deleted
3410 *
3411 * returns 1 if it cleaned and relsed the buffer. 0 otherwise
3412 */
3415 {
3424 }
3428 }
3431 }
3434 }
3437 }
3450 }
3452 }
3457 }
3459 /*
3460 * for any cnode in a journal list, it can only be dirtied of all the
3461 * transactions that include it are committed to disk.
3462 * this checks through each transaction, and returns 1 if you are allowed
3463 * to dirty, and 0 if you aren't
3464 *
3465 * it is called by dirty_journal_list, which is called after
3466 * flush_commit_list has gotten all the log blocks for a given
3467 * transaction on disk
3468 *
3469 */
3471 {
3477 /*
3478 * first test hprev. These are all newer than cn, so any node here
3479 * with the same block number and dev means this node can't be sent
3480 * to disk right now.
3481 */
3486 }
3488 }
3489 /*
3490 * then test hnext. These are all older than cn. As long as they
3491 * are committed to the log, it is safe to write cn to disk
3492 */
3499 }
3501 }
3503 }
3505 /*
3506 * syncs the commit blocks, but does not force the real buffers to disk
3507 * will wait until the current transaction is done/committed before returning
3508 */
3510 {
3515 /* you can sync while nested, very, very bad */
3521 }
3523 }
3525 /* writeback the pending async commits to disk */
3527 {
3536 /* last entry is the youngest, commit it and you get everything */
3540 }
3542 }
3544 /*
3545 * flushes any old transactions to disk
3546 * ends the current transaction if it is too old
3547 */
3549 {
3550 time64_t now;
3555 /*
3556 * safety check so we don't flush while we are replaying the log during
3557 * mount
3558 */
3562 /*
3563 * check the current transaction. If there are no writers, and it is
3564 * too old, finish it, and force the commit blocks to disk
3565 */
3576 /*
3577 * we're only being called from kreiserfsd, it makes
3578 * no sense to do an async commit so that kreiserfsd
3579 * can do it later
3580 */
3582 }
3583 }
3584 }
3586 /*
3587 * returns 0 if do_journal_end should return right away, returns 1 if
3588 * do_journal_end should finish the commit
3589 *
3590 * if the current transaction is too old, but still has writers, this will
3591 * wait on j_join_wait until all the writers are done. By the time it
3592 * wakes up, the transaction it was called has already ended, so it just
3593 * flushes the commit list and returns 0.
3594 *
3595 * Won't batch when flush or commit_now is set. Also won't batch when
3596 * others are waiting on j_join_wait.
3597 *
3598 * Note, we can't allow the journal_end to proceed while there are still
3599 * writers in the log.
3600 */
3602 {
3604 time64_t now;
3618 }
3621 /* <= 0 is allowed. unmounting might not call begin */
3625 /*
3626 * BUG, deal with case where j_len is 0, but people previously
3627 * freed blocks need to be released will be dealt with by next
3628 * transaction that actually writes something, but should be taken
3629 * care of in this trans
3630 */
3633 /*
3634 * if wcount > 0, and we are called to with flush or commit_now,
3635 * we wait on j_join_wait. We will wake up when the last writer has
3636 * finished the transaction, and started it on its way to the disk.
3637 * Then, we flush the commit or journal list, and just return 0
3638 * because the rest of journal end was already done for this
3639 * transaction.
3640 */
3652 }
3655 /*
3656 * sleep while the current transaction is
3657 * still j_jlocked
3658 */
3667 }
3669 }
3670 }
3677 }
3679 }
3682 }
3684 /* deal with old transactions where we are the last writers */
3689 }
3690 /* don't batch when someone is waiting on j_join_wait */
3691 /* don't batch when syncing the commit or flushing the whole trans */
3699 }
3705 }
3707 }
3709 /*
3710 * Does all the work that makes deleting blocks safe.
3711 * when deleting a block mark BH_JNew, just remove it from the current
3712 * transaction, clean it's buffer_head and move on.
3713 *
3714 * otherwise:
3715 * set a bit for the block in the journal bitmap. That will prevent it from
3716 * being allocated for unformatted nodes before this transaction has finished.
3717 *
3718 * mark any cnodes for this block as BLOCK_FREED, and clear their bh pointers.
3719 * That will prevent any old transactions with this block from trying to flush
3720 * to the real location. Since we aren't removing the cnode from the
3721 * journal_list_hash, *the block can't be reallocated yet.
3722 *
3723 * Then remove it from the current transaction, decrementing any counters and
3724 * filing it on the clean list.
3725 */
3728 {
3740 }
3741 /* if it is journal new, we just remove it from this transaction */
3748 /*
3749 * set the bit for this block in the journal bitmap
3750 * for this transaction
3751 */
3756 }
3759 /* Note, the entire while loop is not allowed to schedule. */
3764 }
3767 /*
3768 * find all older transactions with this block,
3769 * make sure they don't try to write it out
3770 */
3772 blocknr);
3777 /*
3778 * remove_from_transaction will brelse
3779 * the buffer if it was in the current
3780 * trans
3781 */
3784 bh);
3787 bh);
3795 }
3796 }
3797 /*
3798 * since we are clearing the bh,
3799 * we MUST dec nonzerolen
3800 */
3803 j_nonzerolen);
3804 }
3806 }
3807 }
3809 }
3810 }
3815 }
3818 {
3822 }
3824 /*
3825 * returns -1 on error, 0 if no commits/barriers were done and 1
3826 * if a transaction was actually committed and the barrier was done
3827 */
3830 {
3836 /*
3837 * is it from the current transaction,
3838 * or from an unknown transaction?
3839 */
3842 /*
3843 * try to let other writers come in and
3844 * grow this transaction
3845 */
3849 }
3855 /* someone might have ended this transaction while we joined */
3862 }
3869 /*
3870 * this gets tricky, we have to make sure the journal list in
3871 * the inode still exists. We know the list is still around
3872 * if we've got a larger transaction id than the oldest list
3873 */
3874 flush_commit_only:
3876 /*
3877 * we only set ret to 1 when we know for sure
3878 * the barrier hasn't been started yet on the commit
3879 * block.
3880 */
3886 }
3887 }
3888 /* otherwise the list is gone, and long since committed */
3890 }
3893 {
3897 /*
3898 * for the whole inode, assume unset id means it was
3899 * changed in the current transaction. More conservative
3900 */
3904 /* jl will be updated in __commit_trans_jl */
3905 }
3908 }
3912 {
3917 }
3928 }
3930 }
3932 }
3935 /*
3936 * before we can change a metadata block, we have to make sure it won't
3937 * be written to disk while we are altering it. So, we must:
3938 * clean it
3939 * wait on it.
3940 */
3943 {
3950 }
3955 }
3958 }
3960 /*
3961 * long and ugly. If flush, will not return until all commit
3962 * blocks and all real buffers in the trans are on disk.
3963 * If no_async, won't return until all commit blocks are on disk.
3964 *
3965 * keep reading, there are comments as you go along
3966 *
3967 * If the journal is aborted, we just clean up. Things like flushing
3968 * journal lists, etc just won't happen.
3969 */
3971 {
3995 /*
3996 * protect flush_older_commits from doing mistakes if the
3997 * transaction ID counter gets overflowed.
3998 */
4010 }
4016 }
4020 }
4022 /*
4023 * check_journal_end locks the journal, and unlocks if it does
4024 * not return 1 it tells us if we should continue with the
4025 * journal_end, or just return
4026 */
4032 }
4034 /* check_journal_end might set these, check again */
4037 }
4039 /*
4040 * j must wait means we have to flush the log blocks, and the
4041 * real blocks for this transaction
4042 */
4045 }
4046 #ifdef REISERFS_PREALLOCATE
4047 /*
4048 * quota ops might need to nest, setup the journal_info pointer
4049 * for them and raise the refcount so that it is > 0.
4050 */
4054 /* it should not involve new blocks into the transaction */
4059 #endif
4061 /* setup description block */
4062 d_bh =
4072 /*
4073 * setup commit block. Don't write (keep it clean too) this one
4074 * until after everyone else is written
4075 */
4084 /* init this journal list */
4087 /*
4088 * we lock the commit before doing anything because
4089 * we want to make sure nobody tries to run flush_commit_list until
4090 * the new transaction is fully setup, and we've already flushed the
4091 * ordered bh list
4092 */
4095 /* save the transaction id in case we need to commit it later */
4108 /*
4109 * The ENTIRE FOR LOOP MUST not cause schedule to occur.
4110 * for each real block, add it to the journal list hash,
4111 * copy into real block index array in the commit or desc block
4112 */
4120 }
4123 }
4128 }
4130 /*
4131 * make sure the block we are trying to log
4132 * is not a block of journal or reserved area
4133 */
4137 "Trying to log block %lu, "
4140 }
4153 }
4155 i--;
4156 }
4157 }
4163 /*
4164 * special check in case all buffers in the journal
4165 * were marked for not logging
4166 */
4169 /*
4170 * we're about to dirty all the log blocks, mark the description block
4171 * dirty now too. Don't mark the commit block dirty until all the
4172 * others are on disk
4173 */
4176 /*
4177 * first data block is j_start + 1, so add one to
4178 * cur_write_start wherever you use it
4179 */
4185 /* copy all the real blocks into log area. dirty log blocks */
4190 tmp_bh =
4194 jindex) %
4204 jindex++;
4208 /*
4209 * JDirty cleared sometime during transaction.
4210 * don't log this one
4211 */
4213 "BAD, buffer in journal hash, "
4216 }
4221 }
4223 /*
4224 * we are done with both the c_bh and d_bh, but
4225 * c_bh must be written after all other commit blocks,
4226 * so we dirty/relse c_bh in flush_commit_list, with commit_left <= 1.
4227 */
4231 /* now it is safe to insert this transaction on the main list */
4236 /* reset journal values for the next transaction */
4246 /* check for trans_id overflow */
4256 /*
4257 * make sure reiserfs_add_jh sees the new current_jl before we
4258 * write out the tails
4259 */
4262 /*
4263 * tail conversion targets have to hit the disk before we end the
4264 * transaction. Otherwise a later transaction might repack the tail
4265 * before this transaction commits, leaving the data block unflushed
4266 * and clean, if we crash before the later transaction commits, the
4267 * data block is lost.
4268 */
4274 }
4278 /*
4279 * honor the flush wishes from the caller, simple commits can
4280 * be done outside the journal lock, they are done below
4281 *
4282 * if we don't flush the commit list right now, we put it into
4283 * the work queue so the people waiting on the async progress work
4284 * queue don't wait for this proc to flush journal lists and such.
4285 */
4290 /*
4291 * Avoid queueing work when sb is being shut down. Transaction
4292 * will be flushed on journal shutdown.
4293 */
4297 }
4299 /*
4300 * if the next transaction has any chance of wrapping, flush
4301 * transactions that might get overwritten. If any journal lists
4302 * are very old flush them as well.
4303 */
4304 first_jl:
4315 /*
4316 * if we don't cross into the next
4317 * transaction and we don't wrap, there is
4318 * no way we can overlap any later transactions
4319 * break now
4320 */
4322 }
4332 /*
4333 * we don't overlap anything from out start
4334 * to the end of the log, and our wrapped
4335 * portion doesn't overlap anything at
4336 * the start of the log. We can break
4337 */
4339 }
4340 }
4341 }
4349 }
4353 /* wake up any body waiting to join. */
4360 }
4361 out:
4365 /*
4366 * Re-set th->t_super, so we can properly keep track of how many
4367 * persistent transactions there are. We need to do this so if this
4368 * call is part of a failed restart_transaction, we can free it later
4369 */
4373 }
4375 /* Send the file system read only and refuse new transactions */
4377 {
4388 #ifdef CONFIG_REISERFS_CHECK
4390 #endif
4391 }