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