Branch data Line data Source code
1 : : /*
2 : : * linux/fs/jbd/revoke.c
3 : : *
4 : : * Written by Stephen C. Tweedie <sct@redhat.com>, 2000
5 : : *
6 : : * Copyright 2000 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 : : * Journal revoke routines for the generic filesystem journaling code;
13 : : * part of the ext2fs journaling system.
14 : : *
15 : : * Revoke is the mechanism used to prevent old log records for deleted
16 : : * metadata from being replayed on top of newer data using the same
17 : : * blocks. The revoke mechanism is used in two separate places:
18 : : *
19 : : * + Commit: during commit we write the entire list of the current
20 : : * transaction's revoked blocks to the journal
21 : : *
22 : : * + Recovery: during recovery we record the transaction ID of all
23 : : * revoked blocks. If there are multiple revoke records in the log
24 : : * for a single block, only the last one counts, and if there is a log
25 : : * entry for a block beyond the last revoke, then that log entry still
26 : : * gets replayed.
27 : : *
28 : : * We can get interactions between revokes and new log data within a
29 : : * single transaction:
30 : : *
31 : : * Block is revoked and then journaled:
32 : : * The desired end result is the journaling of the new block, so we
33 : : * cancel the revoke before the transaction commits.
34 : : *
35 : : * Block is journaled and then revoked:
36 : : * The revoke must take precedence over the write of the block, so we
37 : : * need either to cancel the journal entry or to write the revoke
38 : : * later in the log than the log block. In this case, we choose the
39 : : * latter: journaling a block cancels any revoke record for that block
40 : : * in the current transaction, so any revoke for that block in the
41 : : * transaction must have happened after the block was journaled and so
42 : : * the revoke must take precedence.
43 : : *
44 : : * Block is revoked and then written as data:
45 : : * The data write is allowed to succeed, but the revoke is _not_
46 : : * cancelled. We still need to prevent old log records from
47 : : * overwriting the new data. We don't even need to clear the revoke
48 : : * bit here.
49 : : *
50 : : * We cache revoke status of a buffer in the current transaction in b_states
51 : : * bits. As the name says, revokevalid flag indicates that the cached revoke
52 : : * status of a buffer is valid and we can rely on the cached status.
53 : : *
54 : : * Revoke information on buffers is a tri-state value:
55 : : *
56 : : * RevokeValid clear: no cached revoke status, need to look it up
57 : : * RevokeValid set, Revoked clear:
58 : : * buffer has not been revoked, and cancel_revoke
59 : : * need do nothing.
60 : : * RevokeValid set, Revoked set:
61 : : * buffer has been revoked.
62 : : *
63 : : * Locking rules:
64 : : * We keep two hash tables of revoke records. One hashtable belongs to the
65 : : * running transaction (is pointed to by journal->j_revoke), the other one
66 : : * belongs to the committing transaction. Accesses to the second hash table
67 : : * happen only from the kjournald and no other thread touches this table. Also
68 : : * journal_switch_revoke_table() which switches which hashtable belongs to the
69 : : * running and which to the committing transaction is called only from
70 : : * kjournald. Therefore we need no locks when accessing the hashtable belonging
71 : : * to the committing transaction.
72 : : *
73 : : * All users operating on the hash table belonging to the running transaction
74 : : * have a handle to the transaction. Therefore they are safe from kjournald
75 : : * switching hash tables under them. For operations on the lists of entries in
76 : : * the hash table j_revoke_lock is used.
77 : : *
78 : : * Finally, also replay code uses the hash tables but at this moment no one else
79 : : * can touch them (filesystem isn't mounted yet) and hence no locking is
80 : : * needed.
81 : : */
82 : :
83 : : #ifndef __KERNEL__
84 : : #include "jfs_user.h"
85 : : #else
86 : : #include <linux/time.h>
87 : : #include <linux/fs.h>
88 : : #include <linux/jbd.h>
89 : : #include <linux/errno.h>
90 : : #include <linux/slab.h>
91 : : #include <linux/list.h>
92 : : #include <linux/init.h>
93 : : #include <linux/bio.h>
94 : : #endif
95 : : #include <linux/log2.h>
96 : :
97 : : static struct kmem_cache *revoke_record_cache;
98 : : static struct kmem_cache *revoke_table_cache;
99 : :
100 : : /* Each revoke record represents one single revoked block. During
101 : : journal replay, this involves recording the transaction ID of the
102 : : last transaction to revoke this block. */
103 : :
104 : : struct jbd_revoke_record_s
105 : : {
106 : : struct list_head hash;
107 : : tid_t sequence; /* Used for recovery only */
108 : : unsigned int blocknr;
109 : : };
110 : :
111 : :
112 : : /* The revoke table is just a simple hash table of revoke records. */
113 : : struct jbd_revoke_table_s
114 : : {
115 : : /* It is conceivable that we might want a larger hash table
116 : : * for recovery. Must be a power of two. */
117 : : int hash_size;
118 : : int hash_shift;
119 : : struct list_head *hash_table;
120 : : };
121 : :
122 : :
123 : : #ifdef __KERNEL__
124 : : static void write_one_revoke_record(journal_t *, transaction_t *,
125 : : struct journal_head **, int *,
126 : : struct jbd_revoke_record_s *, int);
127 : : static void flush_descriptor(journal_t *, struct journal_head *, int, int);
128 : : #endif
129 : :
130 : : /* Utility functions to maintain the revoke table */
131 : :
132 : : /* Borrowed from buffer.c: this is a tried and tested block hash function */
133 : : static inline int hash(journal_t *journal, unsigned int block)
134 : : {
135 : : struct jbd_revoke_table_s *table = journal->j_revoke;
136 : 0 : int hash_shift = table->hash_shift;
137 : :
138 : 0 : return ((block << (hash_shift - 6)) ^
139 : 0 : (block >> 13) ^
140 : 0 : (block << (hash_shift - 12))) & (table->hash_size - 1);
141 : : }
142 : :
143 : 0 : static int insert_revoke_hash(journal_t *journal, unsigned int blocknr,
144 : : tid_t seq)
145 : : {
146 : : struct list_head *hash_list;
147 : : struct jbd_revoke_record_s *record;
148 : :
149 : : repeat:
150 : 0 : record = kmem_cache_alloc(revoke_record_cache, GFP_NOFS);
151 [ # # ]: 0 : if (!record)
152 : : goto oom;
153 : :
154 : 0 : record->sequence = seq;
155 : 0 : record->blocknr = blocknr;
156 : 0 : hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
157 : : spin_lock(&journal->j_revoke_lock);
158 : 0 : list_add(&record->hash, hash_list);
159 : : spin_unlock(&journal->j_revoke_lock);
160 : : return 0;
161 : :
162 : : oom:
163 : : if (!journal_oom_retry)
164 : : return -ENOMEM;
165 : : jbd_debug(1, "ENOMEM in %s, retrying\n", __func__);
166 : 0 : yield();
167 : 0 : goto repeat;
168 : : }
169 : :
170 : : /* Find a revoke record in the journal's hash table. */
171 : :
172 : 0 : static struct jbd_revoke_record_s *find_revoke_record(journal_t *journal,
173 : : unsigned int blocknr)
174 : : {
175 : : struct list_head *hash_list;
176 : : struct jbd_revoke_record_s *record;
177 : :
178 : 0 : hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
179 : :
180 : : spin_lock(&journal->j_revoke_lock);
181 : 0 : record = (struct jbd_revoke_record_s *) hash_list->next;
182 [ # # ]: 0 : while (&(record->hash) != hash_list) {
183 [ # # ]: 0 : if (record->blocknr == blocknr) {
184 : : spin_unlock(&journal->j_revoke_lock);
185 : 0 : return record;
186 : : }
187 : 0 : record = (struct jbd_revoke_record_s *) record->hash.next;
188 : : }
189 : : spin_unlock(&journal->j_revoke_lock);
190 : 0 : return NULL;
191 : : }
192 : :
193 : 0 : void journal_destroy_revoke_caches(void)
194 : : {
195 [ # # ]: 0 : if (revoke_record_cache) {
196 : 0 : kmem_cache_destroy(revoke_record_cache);
197 : 0 : revoke_record_cache = NULL;
198 : : }
199 [ # # ]: 0 : if (revoke_table_cache) {
200 : 0 : kmem_cache_destroy(revoke_table_cache);
201 : 0 : revoke_table_cache = NULL;
202 : : }
203 : 0 : }
204 : :
205 : 0 : int __init journal_init_revoke_caches(void)
206 : : {
207 [ # # ]: 0 : J_ASSERT(!revoke_record_cache);
208 [ # # ]: 0 : J_ASSERT(!revoke_table_cache);
209 : :
210 : 0 : revoke_record_cache = kmem_cache_create("revoke_record",
211 : : sizeof(struct jbd_revoke_record_s),
212 : : 0,
213 : : SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
214 : : NULL);
215 [ # # ]: 0 : if (!revoke_record_cache)
216 : : goto record_cache_failure;
217 : :
218 : 0 : revoke_table_cache = kmem_cache_create("revoke_table",
219 : : sizeof(struct jbd_revoke_table_s),
220 : : 0, SLAB_TEMPORARY, NULL);
221 [ # # ]: 0 : if (!revoke_table_cache)
222 : : goto table_cache_failure;
223 : :
224 : : return 0;
225 : :
226 : : table_cache_failure:
227 : 0 : journal_destroy_revoke_caches();
228 : : record_cache_failure:
229 : : return -ENOMEM;
230 : : }
231 : :
232 : 0 : static struct jbd_revoke_table_s *journal_init_revoke_table(int hash_size)
233 : : {
234 : : int shift = 0;
235 : : int tmp = hash_size;
236 : : struct jbd_revoke_table_s *table;
237 : :
238 : 0 : table = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL);
239 [ # # ]: 0 : if (!table)
240 : : goto out;
241 : :
242 [ # # ]: 0 : while((tmp >>= 1UL) != 0UL)
243 : 0 : shift++;
244 : :
245 : 0 : table->hash_size = hash_size;
246 : 0 : table->hash_shift = shift;
247 : 0 : table->hash_table =
248 : 0 : kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
249 [ # # ]: 0 : if (!table->hash_table) {
250 : 0 : kmem_cache_free(revoke_table_cache, table);
251 : : table = NULL;
252 : 0 : goto out;
253 : : }
254 : :
255 [ # # ]: 0 : for (tmp = 0; tmp < hash_size; tmp++)
256 : 0 : INIT_LIST_HEAD(&table->hash_table[tmp]);
257 : :
258 : : out:
259 : 0 : return table;
260 : : }
261 : :
262 : 0 : static void journal_destroy_revoke_table(struct jbd_revoke_table_s *table)
263 : : {
264 : : int i;
265 : : struct list_head *hash_list;
266 : :
267 [ # # ]: 0 : for (i = 0; i < table->hash_size; i++) {
268 : 0 : hash_list = &table->hash_table[i];
269 [ # # ]: 0 : J_ASSERT(list_empty(hash_list));
270 : : }
271 : :
272 : 0 : kfree(table->hash_table);
273 : 0 : kmem_cache_free(revoke_table_cache, table);
274 : 0 : }
275 : :
276 : : /* Initialise the revoke table for a given journal to a given size. */
277 : 0 : int journal_init_revoke(journal_t *journal, int hash_size)
278 : : {
279 [ # # ]: 0 : J_ASSERT(journal->j_revoke_table[0] == NULL);
280 [ # # ]: 0 : J_ASSERT(is_power_of_2(hash_size));
281 : :
282 : 0 : journal->j_revoke_table[0] = journal_init_revoke_table(hash_size);
283 [ # # ]: 0 : if (!journal->j_revoke_table[0])
284 : : goto fail0;
285 : :
286 : 0 : journal->j_revoke_table[1] = journal_init_revoke_table(hash_size);
287 [ # # ]: 0 : if (!journal->j_revoke_table[1])
288 : : goto fail1;
289 : :
290 : 0 : journal->j_revoke = journal->j_revoke_table[1];
291 : :
292 : 0 : spin_lock_init(&journal->j_revoke_lock);
293 : :
294 : 0 : return 0;
295 : :
296 : : fail1:
297 : 0 : journal_destroy_revoke_table(journal->j_revoke_table[0]);
298 : : fail0:
299 : : return -ENOMEM;
300 : : }
301 : :
302 : : /* Destroy a journal's revoke table. The table must already be empty! */
303 : 0 : void journal_destroy_revoke(journal_t *journal)
304 : : {
305 : 0 : journal->j_revoke = NULL;
306 [ # # ]: 0 : if (journal->j_revoke_table[0])
307 : 0 : journal_destroy_revoke_table(journal->j_revoke_table[0]);
308 [ # # ]: 0 : if (journal->j_revoke_table[1])
309 : 0 : journal_destroy_revoke_table(journal->j_revoke_table[1]);
310 : 0 : }
311 : :
312 : :
313 : : #ifdef __KERNEL__
314 : :
315 : : /*
316 : : * journal_revoke: revoke a given buffer_head from the journal. This
317 : : * prevents the block from being replayed during recovery if we take a
318 : : * crash after this current transaction commits. Any subsequent
319 : : * metadata writes of the buffer in this transaction cancel the
320 : : * revoke.
321 : : *
322 : : * Note that this call may block --- it is up to the caller to make
323 : : * sure that there are no further calls to journal_write_metadata
324 : : * before the revoke is complete. In ext3, this implies calling the
325 : : * revoke before clearing the block bitmap when we are deleting
326 : : * metadata.
327 : : *
328 : : * Revoke performs a journal_forget on any buffer_head passed in as a
329 : : * parameter, but does _not_ forget the buffer_head if the bh was only
330 : : * found implicitly.
331 : : *
332 : : * bh_in may not be a journalled buffer - it may have come off
333 : : * the hash tables without an attached journal_head.
334 : : *
335 : : * If bh_in is non-zero, journal_revoke() will decrement its b_count
336 : : * by one.
337 : : */
338 : :
339 : 0 : int journal_revoke(handle_t *handle, unsigned int blocknr,
340 : : struct buffer_head *bh_in)
341 : : {
342 : : struct buffer_head *bh = NULL;
343 : : journal_t *journal;
344 : : struct block_device *bdev;
345 : : int err;
346 : :
347 : : might_sleep();
348 : : if (bh_in)
349 : : BUFFER_TRACE(bh_in, "enter");
350 : :
351 : 0 : journal = handle->h_transaction->t_journal;
352 [ # # ]: 0 : if (!journal_set_features(journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)){
353 : 0 : J_ASSERT (!"Cannot set revoke feature!");
354 : : return -EINVAL;
355 : : }
356 : :
357 : 0 : bdev = journal->j_fs_dev;
358 : : bh = bh_in;
359 : :
360 [ # # ]: 0 : if (!bh) {
361 : 0 : bh = __find_get_block(bdev, blocknr, journal->j_blocksize);
362 : : if (bh)
363 : : BUFFER_TRACE(bh, "found on hash");
364 : : }
365 : : #ifdef JBD_EXPENSIVE_CHECKING
366 : : else {
367 : : struct buffer_head *bh2;
368 : :
369 : : /* If there is a different buffer_head lying around in
370 : : * memory anywhere... */
371 : : bh2 = __find_get_block(bdev, blocknr, journal->j_blocksize);
372 : : if (bh2) {
373 : : /* ... and it has RevokeValid status... */
374 : : if (bh2 != bh && buffer_revokevalid(bh2))
375 : : /* ...then it better be revoked too,
376 : : * since it's illegal to create a revoke
377 : : * record against a buffer_head which is
378 : : * not marked revoked --- that would
379 : : * risk missing a subsequent revoke
380 : : * cancel. */
381 : : J_ASSERT_BH(bh2, buffer_revoked(bh2));
382 : : put_bh(bh2);
383 : : }
384 : : }
385 : : #endif
386 : :
387 : : /* We really ought not ever to revoke twice in a row without
388 : : first having the revoke cancelled: it's illegal to free a
389 : : block twice without allocating it in between! */
390 [ # # ]: 0 : if (bh) {
391 [ # # ][ # # ]: 0 : if (!J_EXPECT_BH(bh, !buffer_revoked(bh),
392 : : "inconsistent data on disk")) {
393 [ # # ]: 0 : if (!bh_in)
394 : : brelse(bh);
395 : : return -EIO;
396 : : }
397 : : set_buffer_revoked(bh);
398 : : set_buffer_revokevalid(bh);
399 [ # # ]: 0 : if (bh_in) {
400 : : BUFFER_TRACE(bh_in, "call journal_forget");
401 : 0 : journal_forget(handle, bh_in);
402 : : } else {
403 : : BUFFER_TRACE(bh, "call brelse");
404 : 0 : __brelse(bh);
405 : : }
406 : : }
407 : :
408 : : jbd_debug(2, "insert revoke for block %u, bh_in=%p\n", blocknr, bh_in);
409 : 0 : err = insert_revoke_hash(journal, blocknr,
410 : 0 : handle->h_transaction->t_tid);
411 : : BUFFER_TRACE(bh_in, "exit");
412 : 0 : return err;
413 : : }
414 : :
415 : : /*
416 : : * Cancel an outstanding revoke. For use only internally by the
417 : : * journaling code (called from journal_get_write_access).
418 : : *
419 : : * We trust buffer_revoked() on the buffer if the buffer is already
420 : : * being journaled: if there is no revoke pending on the buffer, then we
421 : : * don't do anything here.
422 : : *
423 : : * This would break if it were possible for a buffer to be revoked and
424 : : * discarded, and then reallocated within the same transaction. In such
425 : : * a case we would have lost the revoked bit, but when we arrived here
426 : : * the second time we would still have a pending revoke to cancel. So,
427 : : * do not trust the Revoked bit on buffers unless RevokeValid is also
428 : : * set.
429 : : */
430 : 0 : int journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
431 : : {
432 : : struct jbd_revoke_record_s *record;
433 : 0 : journal_t *journal = handle->h_transaction->t_journal;
434 : : int need_cancel;
435 : : int did_revoke = 0; /* akpm: debug */
436 : : struct buffer_head *bh = jh2bh(jh);
437 : :
438 : : jbd_debug(4, "journal_head %p, cancelling revoke\n", jh);
439 : :
440 : : /* Is the existing Revoke bit valid? If so, we trust it, and
441 : : * only perform the full cancel if the revoke bit is set. If
442 : : * not, we can't trust the revoke bit, and we need to do the
443 : : * full search for a revoke record. */
444 [ # # ]: 0 : if (test_set_buffer_revokevalid(bh)) {
445 : : need_cancel = test_clear_buffer_revoked(bh);
446 : : } else {
447 : : need_cancel = 1;
448 : : clear_buffer_revoked(bh);
449 : : }
450 : :
451 [ # # ]: 0 : if (need_cancel) {
452 : 0 : record = find_revoke_record(journal, bh->b_blocknr);
453 [ # # ]: 0 : if (record) {
454 : : jbd_debug(4, "cancelled existing revoke on "
455 : : "blocknr %llu\n", (unsigned long long)bh->b_blocknr);
456 : : spin_lock(&journal->j_revoke_lock);
457 : : list_del(&record->hash);
458 : : spin_unlock(&journal->j_revoke_lock);
459 : 0 : kmem_cache_free(revoke_record_cache, record);
460 : : did_revoke = 1;
461 : : }
462 : : }
463 : :
464 : : #ifdef JBD_EXPENSIVE_CHECKING
465 : : /* There better not be one left behind by now! */
466 : : record = find_revoke_record(journal, bh->b_blocknr);
467 : : J_ASSERT_JH(jh, record == NULL);
468 : : #endif
469 : :
470 : : /* Finally, have we just cleared revoke on an unhashed
471 : : * buffer_head? If so, we'd better make sure we clear the
472 : : * revoked status on any hashed alias too, otherwise the revoke
473 : : * state machine will get very upset later on. */
474 [ # # ]: 0 : if (need_cancel) {
475 : : struct buffer_head *bh2;
476 : 0 : bh2 = __find_get_block(bh->b_bdev, bh->b_blocknr, bh->b_size);
477 [ # # ]: 0 : if (bh2) {
478 [ # # ]: 0 : if (bh2 != bh)
479 : : clear_buffer_revoked(bh2);
480 : 0 : __brelse(bh2);
481 : : }
482 : : }
483 : 0 : return did_revoke;
484 : : }
485 : :
486 : : /*
487 : : * journal_clear_revoked_flags clears revoked flag of buffers in
488 : : * revoke table to reflect there is no revoked buffer in the next
489 : : * transaction which is going to be started.
490 : : */
491 : 0 : void journal_clear_buffer_revoked_flags(journal_t *journal)
492 : : {
493 : 0 : struct jbd_revoke_table_s *revoke = journal->j_revoke;
494 : : int i = 0;
495 : :
496 [ # # ]: 0 : for (i = 0; i < revoke->hash_size; i++) {
497 : : struct list_head *hash_list;
498 : : struct list_head *list_entry;
499 : 0 : hash_list = &revoke->hash_table[i];
500 : :
501 [ # # ]: 0 : list_for_each(list_entry, hash_list) {
502 : : struct jbd_revoke_record_s *record;
503 : : struct buffer_head *bh;
504 : : record = (struct jbd_revoke_record_s *)list_entry;
505 : 0 : bh = __find_get_block(journal->j_fs_dev,
506 : 0 : record->blocknr,
507 : 0 : journal->j_blocksize);
508 [ # # ]: 0 : if (bh) {
509 : : clear_buffer_revoked(bh);
510 : 0 : __brelse(bh);
511 : : }
512 : : }
513 : : }
514 : 0 : }
515 : :
516 : : /* journal_switch_revoke table select j_revoke for next transaction
517 : : * we do not want to suspend any processing until all revokes are
518 : : * written -bzzz
519 : : */
520 : 0 : void journal_switch_revoke_table(journal_t *journal)
521 : : {
522 : : int i;
523 : :
524 [ # # ]: 0 : if (journal->j_revoke == journal->j_revoke_table[0])
525 : 0 : journal->j_revoke = journal->j_revoke_table[1];
526 : : else
527 : 0 : journal->j_revoke = journal->j_revoke_table[0];
528 : :
529 [ # # ]: 0 : for (i = 0; i < journal->j_revoke->hash_size; i++)
530 : 0 : INIT_LIST_HEAD(&journal->j_revoke->hash_table[i]);
531 : 0 : }
532 : :
533 : : /*
534 : : * Write revoke records to the journal for all entries in the current
535 : : * revoke hash, deleting the entries as we go.
536 : : */
537 : 0 : void journal_write_revoke_records(journal_t *journal,
538 : : transaction_t *transaction, int write_op)
539 : : {
540 : : struct journal_head *descriptor;
541 : : struct jbd_revoke_record_s *record;
542 : : struct jbd_revoke_table_s *revoke;
543 : : struct list_head *hash_list;
544 : : int i, offset, count;
545 : :
546 : 0 : descriptor = NULL;
547 : 0 : offset = 0;
548 : : count = 0;
549 : :
550 : : /* select revoke table for committing transaction */
551 : 0 : revoke = journal->j_revoke == journal->j_revoke_table[0] ?
552 [ # # ]: 0 : journal->j_revoke_table[1] : journal->j_revoke_table[0];
553 : :
554 [ # # ]: 0 : for (i = 0; i < revoke->hash_size; i++) {
555 : 0 : hash_list = &revoke->hash_table[i];
556 : :
557 [ # # ]: 0 : while (!list_empty(hash_list)) {
558 : : record = (struct jbd_revoke_record_s *)
559 : : hash_list->next;
560 : 0 : write_one_revoke_record(journal, transaction,
561 : : &descriptor, &offset,
562 : : record, write_op);
563 : : count++;
564 : : list_del(&record->hash);
565 : 0 : kmem_cache_free(revoke_record_cache, record);
566 : : }
567 : : }
568 [ # # ]: 0 : if (descriptor)
569 : 0 : flush_descriptor(journal, descriptor, offset, write_op);
570 : : jbd_debug(1, "Wrote %d revoke records\n", count);
571 : 0 : }
572 : :
573 : : /*
574 : : * Write out one revoke record. We need to create a new descriptor
575 : : * block if the old one is full or if we have not already created one.
576 : : */
577 : :
578 : 0 : static void write_one_revoke_record(journal_t *journal,
579 : : transaction_t *transaction,
580 : : struct journal_head **descriptorp,
581 : : int *offsetp,
582 : : struct jbd_revoke_record_s *record,
583 : : int write_op)
584 : : {
585 : 0 : struct journal_head *descriptor;
586 : : int offset;
587 : : journal_header_t *header;
588 : :
589 : : /* If we are already aborting, this all becomes a noop. We
590 : : still need to go round the loop in
591 : : journal_write_revoke_records in order to free all of the
592 : : revoke records: only the IO to the journal is omitted. */
593 [ # # ]: 0 : if (is_journal_aborted(journal))
594 : : return;
595 : :
596 : 0 : descriptor = *descriptorp;
597 : 0 : offset = *offsetp;
598 : :
599 : : /* Make sure we have a descriptor with space left for the record */
600 [ # # ]: 0 : if (descriptor) {
601 [ # # ]: 0 : if (offset == journal->j_blocksize) {
602 : 0 : flush_descriptor(journal, descriptor, offset, write_op);
603 : : descriptor = NULL;
604 : : }
605 : : }
606 : :
607 [ # # ]: 0 : if (!descriptor) {
608 : 0 : descriptor = journal_get_descriptor_buffer(journal);
609 [ # # ]: 0 : if (!descriptor)
610 : : return;
611 : 0 : header = (journal_header_t *) &jh2bh(descriptor)->b_data[0];
612 : 0 : header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
613 : 0 : header->h_blocktype = cpu_to_be32(JFS_REVOKE_BLOCK);
614 [ # # ]: 0 : header->h_sequence = cpu_to_be32(transaction->t_tid);
615 : :
616 : : /* Record it so that we can wait for IO completion later */
617 : : JBUFFER_TRACE(descriptor, "file as BJ_LogCtl");
618 : 0 : journal_file_buffer(descriptor, transaction, BJ_LogCtl);
619 : :
620 : : offset = sizeof(journal_revoke_header_t);
621 : 0 : *descriptorp = descriptor;
622 : : }
623 : :
624 : 0 : * ((__be32 *)(&jh2bh(descriptor)->b_data[offset])) =
625 [ # # ]: 0 : cpu_to_be32(record->blocknr);
626 : 0 : offset += 4;
627 : 0 : *offsetp = offset;
628 : : }
629 : :
630 : : /*
631 : : * Flush a revoke descriptor out to the journal. If we are aborting,
632 : : * this is a noop; otherwise we are generating a buffer which needs to
633 : : * be waited for during commit, so it has to go onto the appropriate
634 : : * journal buffer list.
635 : : */
636 : :
637 : 0 : static void flush_descriptor(journal_t *journal,
638 : 0 : struct journal_head *descriptor,
639 : : int offset, int write_op)
640 : : {
641 : : journal_revoke_header_t *header;
642 : : struct buffer_head *bh = jh2bh(descriptor);
643 : :
644 [ # # ]: 0 : if (is_journal_aborted(journal)) {
645 : : put_bh(bh);
646 : 0 : return;
647 : : }
648 : :
649 : 0 : header = (journal_revoke_header_t *) jh2bh(descriptor)->b_data;
650 [ # # ]: 0 : header->r_count = cpu_to_be32(offset);
651 : : set_buffer_jwrite(bh);
652 : : BUFFER_TRACE(bh, "write");
653 : : set_buffer_dirty(bh);
654 : 0 : write_dirty_buffer(bh, write_op);
655 : : }
656 : : #endif
657 : :
658 : : /*
659 : : * Revoke support for recovery.
660 : : *
661 : : * Recovery needs to be able to:
662 : : *
663 : : * record all revoke records, including the tid of the latest instance
664 : : * of each revoke in the journal
665 : : *
666 : : * check whether a given block in a given transaction should be replayed
667 : : * (ie. has not been revoked by a revoke record in that or a subsequent
668 : : * transaction)
669 : : *
670 : : * empty the revoke table after recovery.
671 : : */
672 : :
673 : : /*
674 : : * First, setting revoke records. We create a new revoke record for
675 : : * every block ever revoked in the log as we scan it for recovery, and
676 : : * we update the existing records if we find multiple revokes for a
677 : : * single block.
678 : : */
679 : :
680 : 0 : int journal_set_revoke(journal_t *journal,
681 : : unsigned int blocknr,
682 : : tid_t sequence)
683 : : {
684 : : struct jbd_revoke_record_s *record;
685 : :
686 : 0 : record = find_revoke_record(journal, blocknr);
687 [ # # ]: 0 : if (record) {
688 : : /* If we have multiple occurrences, only record the
689 : : * latest sequence number in the hashed record */
690 [ # # ]: 0 : if (tid_gt(sequence, record->sequence))
691 : 0 : record->sequence = sequence;
692 : : return 0;
693 : : }
694 : 0 : return insert_revoke_hash(journal, blocknr, sequence);
695 : : }
696 : :
697 : : /*
698 : : * Test revoke records. For a given block referenced in the log, has
699 : : * that block been revoked? A revoke record with a given transaction
700 : : * sequence number revokes all blocks in that transaction and earlier
701 : : * ones, but later transactions still need replayed.
702 : : */
703 : :
704 : 0 : int journal_test_revoke(journal_t *journal,
705 : : unsigned int blocknr,
706 : : tid_t sequence)
707 : : {
708 : : struct jbd_revoke_record_s *record;
709 : :
710 : 0 : record = find_revoke_record(journal, blocknr);
711 [ # # ]: 0 : if (!record)
712 : : return 0;
713 [ # # ]: 0 : if (tid_gt(sequence, record->sequence))
714 : : return 0;
715 : 0 : return 1;
716 : : }
717 : :
718 : : /*
719 : : * Finally, once recovery is over, we need to clear the revoke table so
720 : : * that it can be reused by the running filesystem.
721 : : */
722 : :
723 : 0 : void journal_clear_revoke(journal_t *journal)
724 : : {
725 : : int i;
726 : : struct list_head *hash_list;
727 : : struct jbd_revoke_record_s *record;
728 : : struct jbd_revoke_table_s *revoke;
729 : :
730 : 0 : revoke = journal->j_revoke;
731 : :
732 [ # # ]: 0 : for (i = 0; i < revoke->hash_size; i++) {
733 : 0 : hash_list = &revoke->hash_table[i];
734 [ # # ]: 0 : while (!list_empty(hash_list)) {
735 : : record = (struct jbd_revoke_record_s*) hash_list->next;
736 : : list_del(&record->hash);
737 : 0 : kmem_cache_free(revoke_record_cache, record);
738 : : }
739 : : }
740 : 0 : }
|
