~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/jbd2/journal.c

Version: ~ [ linux-4.19-rc5 ] ~ [ linux-4.18.9 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.71 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.128 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.157 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.122 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.57 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0+
  2 /*
  3  * linux/fs/jbd2/journal.c
  4  *
  5  * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
  6  *
  7  * Copyright 1998 Red Hat corp --- All Rights Reserved
  8  *
  9  * Generic filesystem journal-writing code; part of the ext2fs
 10  * journaling system.
 11  *
 12  * This file manages journals: areas of disk reserved for logging
 13  * transactional updates.  This includes the kernel journaling thread
 14  * which is responsible for scheduling updates to the log.
 15  *
 16  * We do not actually manage the physical storage of the journal in this
 17  * file: that is left to a per-journal policy function, which allows us
 18  * to store the journal within a filesystem-specified area for ext2
 19  * journaling (ext2 can use a reserved inode for storing the log).
 20  */
 21 
 22 #include <linux/module.h>
 23 #include <linux/time.h>
 24 #include <linux/fs.h>
 25 #include <linux/jbd2.h>
 26 #include <linux/errno.h>
 27 #include <linux/slab.h>
 28 #include <linux/init.h>
 29 #include <linux/mm.h>
 30 #include <linux/freezer.h>
 31 #include <linux/pagemap.h>
 32 #include <linux/kthread.h>
 33 #include <linux/poison.h>
 34 #include <linux/proc_fs.h>
 35 #include <linux/seq_file.h>
 36 #include <linux/math64.h>
 37 #include <linux/hash.h>
 38 #include <linux/log2.h>
 39 #include <linux/vmalloc.h>
 40 #include <linux/backing-dev.h>
 41 #include <linux/bitops.h>
 42 #include <linux/ratelimit.h>
 43 #include <linux/sched/mm.h>
 44 
 45 #define CREATE_TRACE_POINTS
 46 #include <trace/events/jbd2.h>
 47 
 48 #include <linux/uaccess.h>
 49 #include <asm/page.h>
 50 
 51 #ifdef CONFIG_JBD2_DEBUG
 52 ushort jbd2_journal_enable_debug __read_mostly;
 53 EXPORT_SYMBOL(jbd2_journal_enable_debug);
 54 
 55 module_param_named(jbd2_debug, jbd2_journal_enable_debug, ushort, 0644);
 56 MODULE_PARM_DESC(jbd2_debug, "Debugging level for jbd2");
 57 #endif
 58 
 59 EXPORT_SYMBOL(jbd2_journal_extend);
 60 EXPORT_SYMBOL(jbd2_journal_stop);
 61 EXPORT_SYMBOL(jbd2_journal_lock_updates);
 62 EXPORT_SYMBOL(jbd2_journal_unlock_updates);
 63 EXPORT_SYMBOL(jbd2_journal_get_write_access);
 64 EXPORT_SYMBOL(jbd2_journal_get_create_access);
 65 EXPORT_SYMBOL(jbd2_journal_get_undo_access);
 66 EXPORT_SYMBOL(jbd2_journal_set_triggers);
 67 EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
 68 EXPORT_SYMBOL(jbd2_journal_forget);
 69 #if 0
 70 EXPORT_SYMBOL(journal_sync_buffer);
 71 #endif
 72 EXPORT_SYMBOL(jbd2_journal_flush);
 73 EXPORT_SYMBOL(jbd2_journal_revoke);
 74 
 75 EXPORT_SYMBOL(jbd2_journal_init_dev);
 76 EXPORT_SYMBOL(jbd2_journal_init_inode);
 77 EXPORT_SYMBOL(jbd2_journal_check_used_features);
 78 EXPORT_SYMBOL(jbd2_journal_check_available_features);
 79 EXPORT_SYMBOL(jbd2_journal_set_features);
 80 EXPORT_SYMBOL(jbd2_journal_load);
 81 EXPORT_SYMBOL(jbd2_journal_destroy);
 82 EXPORT_SYMBOL(jbd2_journal_abort);
 83 EXPORT_SYMBOL(jbd2_journal_errno);
 84 EXPORT_SYMBOL(jbd2_journal_ack_err);
 85 EXPORT_SYMBOL(jbd2_journal_clear_err);
 86 EXPORT_SYMBOL(jbd2_log_wait_commit);
 87 EXPORT_SYMBOL(jbd2_log_start_commit);
 88 EXPORT_SYMBOL(jbd2_journal_start_commit);
 89 EXPORT_SYMBOL(jbd2_journal_force_commit_nested);
 90 EXPORT_SYMBOL(jbd2_journal_wipe);
 91 EXPORT_SYMBOL(jbd2_journal_blocks_per_page);
 92 EXPORT_SYMBOL(jbd2_journal_invalidatepage);
 93 EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
 94 EXPORT_SYMBOL(jbd2_journal_force_commit);
 95 EXPORT_SYMBOL(jbd2_journal_inode_add_write);
 96 EXPORT_SYMBOL(jbd2_journal_inode_add_wait);
 97 EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
 98 EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
 99 EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
100 EXPORT_SYMBOL(jbd2_inode_cache);
101 
102 static void __journal_abort_soft (journal_t *journal, int errno);
103 static int jbd2_journal_create_slab(size_t slab_size);
104 
105 #ifdef CONFIG_JBD2_DEBUG
106 void __jbd2_debug(int level, const char *file, const char *func,
107                   unsigned int line, const char *fmt, ...)
108 {
109         struct va_format vaf;
110         va_list args;
111 
112         if (level > jbd2_journal_enable_debug)
113                 return;
114         va_start(args, fmt);
115         vaf.fmt = fmt;
116         vaf.va = &args;
117         printk(KERN_DEBUG "%s: (%s, %u): %pV", file, func, line, &vaf);
118         va_end(args);
119 }
120 EXPORT_SYMBOL(__jbd2_debug);
121 #endif
122 
123 /* Checksumming functions */
124 static int jbd2_verify_csum_type(journal_t *j, journal_superblock_t *sb)
125 {
126         if (!jbd2_journal_has_csum_v2or3_feature(j))
127                 return 1;
128 
129         return sb->s_checksum_type == JBD2_CRC32C_CHKSUM;
130 }
131 
132 static __be32 jbd2_superblock_csum(journal_t *j, journal_superblock_t *sb)
133 {
134         __u32 csum;
135         __be32 old_csum;
136 
137         old_csum = sb->s_checksum;
138         sb->s_checksum = 0;
139         csum = jbd2_chksum(j, ~0, (char *)sb, sizeof(journal_superblock_t));
140         sb->s_checksum = old_csum;
141 
142         return cpu_to_be32(csum);
143 }
144 
145 static int jbd2_superblock_csum_verify(journal_t *j, journal_superblock_t *sb)
146 {
147         if (!jbd2_journal_has_csum_v2or3(j))
148                 return 1;
149 
150         return sb->s_checksum == jbd2_superblock_csum(j, sb);
151 }
152 
153 static void jbd2_superblock_csum_set(journal_t *j, journal_superblock_t *sb)
154 {
155         if (!jbd2_journal_has_csum_v2or3(j))
156                 return;
157 
158         sb->s_checksum = jbd2_superblock_csum(j, sb);
159 }
160 
161 /*
162  * Helper function used to manage commit timeouts
163  */
164 
165 static void commit_timeout(struct timer_list *t)
166 {
167         journal_t *journal = from_timer(journal, t, j_commit_timer);
168 
169         wake_up_process(journal->j_task);
170 }
171 
172 /*
173  * kjournald2: The main thread function used to manage a logging device
174  * journal.
175  *
176  * This kernel thread is responsible for two things:
177  *
178  * 1) COMMIT:  Every so often we need to commit the current state of the
179  *    filesystem to disk.  The journal thread is responsible for writing
180  *    all of the metadata buffers to disk.
181  *
182  * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
183  *    of the data in that part of the log has been rewritten elsewhere on
184  *    the disk.  Flushing these old buffers to reclaim space in the log is
185  *    known as checkpointing, and this thread is responsible for that job.
186  */
187 
188 static int kjournald2(void *arg)
189 {
190         journal_t *journal = arg;
191         transaction_t *transaction;
192 
193         /*
194          * Set up an interval timer which can be used to trigger a commit wakeup
195          * after the commit interval expires
196          */
197         timer_setup(&journal->j_commit_timer, commit_timeout, 0);
198 
199         set_freezable();
200 
201         /* Record that the journal thread is running */
202         journal->j_task = current;
203         wake_up(&journal->j_wait_done_commit);
204 
205         /*
206          * Make sure that no allocations from this kernel thread will ever
207          * recurse to the fs layer because we are responsible for the
208          * transaction commit and any fs involvement might get stuck waiting for
209          * the trasn. commit.
210          */
211         memalloc_nofs_save();
212 
213         /*
214          * And now, wait forever for commit wakeup events.
215          */
216         write_lock(&journal->j_state_lock);
217 
218 loop:
219         if (journal->j_flags & JBD2_UNMOUNT)
220                 goto end_loop;
221 
222         jbd_debug(1, "commit_sequence=%d, commit_request=%d\n",
223                 journal->j_commit_sequence, journal->j_commit_request);
224 
225         if (journal->j_commit_sequence != journal->j_commit_request) {
226                 jbd_debug(1, "OK, requests differ\n");
227                 write_unlock(&journal->j_state_lock);
228                 del_timer_sync(&journal->j_commit_timer);
229                 jbd2_journal_commit_transaction(journal);
230                 write_lock(&journal->j_state_lock);
231                 goto loop;
232         }
233 
234         wake_up(&journal->j_wait_done_commit);
235         if (freezing(current)) {
236                 /*
237                  * The simpler the better. Flushing journal isn't a
238                  * good idea, because that depends on threads that may
239                  * be already stopped.
240                  */
241                 jbd_debug(1, "Now suspending kjournald2\n");
242                 write_unlock(&journal->j_state_lock);
243                 try_to_freeze();
244                 write_lock(&journal->j_state_lock);
245         } else {
246                 /*
247                  * We assume on resume that commits are already there,
248                  * so we don't sleep
249                  */
250                 DEFINE_WAIT(wait);
251                 int should_sleep = 1;
252 
253                 prepare_to_wait(&journal->j_wait_commit, &wait,
254                                 TASK_INTERRUPTIBLE);
255                 if (journal->j_commit_sequence != journal->j_commit_request)
256                         should_sleep = 0;
257                 transaction = journal->j_running_transaction;
258                 if (transaction && time_after_eq(jiffies,
259                                                 transaction->t_expires))
260                         should_sleep = 0;
261                 if (journal->j_flags & JBD2_UNMOUNT)
262                         should_sleep = 0;
263                 if (should_sleep) {
264                         write_unlock(&journal->j_state_lock);
265                         schedule();
266                         write_lock(&journal->j_state_lock);
267                 }
268                 finish_wait(&journal->j_wait_commit, &wait);
269         }
270 
271         jbd_debug(1, "kjournald2 wakes\n");
272 
273         /*
274          * Were we woken up by a commit wakeup event?
275          */
276         transaction = journal->j_running_transaction;
277         if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
278                 journal->j_commit_request = transaction->t_tid;
279                 jbd_debug(1, "woke because of timeout\n");
280         }
281         goto loop;
282 
283 end_loop:
284         del_timer_sync(&journal->j_commit_timer);
285         journal->j_task = NULL;
286         wake_up(&journal->j_wait_done_commit);
287         jbd_debug(1, "Journal thread exiting.\n");
288         write_unlock(&journal->j_state_lock);
289         return 0;
290 }
291 
292 static int jbd2_journal_start_thread(journal_t *journal)
293 {
294         struct task_struct *t;
295 
296         t = kthread_run(kjournald2, journal, "jbd2/%s",
297                         journal->j_devname);
298         if (IS_ERR(t))
299                 return PTR_ERR(t);
300 
301         wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
302         return 0;
303 }
304 
305 static void journal_kill_thread(journal_t *journal)
306 {
307         write_lock(&journal->j_state_lock);
308         journal->j_flags |= JBD2_UNMOUNT;
309 
310         while (journal->j_task) {
311                 write_unlock(&journal->j_state_lock);
312                 wake_up(&journal->j_wait_commit);
313                 wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
314                 write_lock(&journal->j_state_lock);
315         }
316         write_unlock(&journal->j_state_lock);
317 }
318 
319 /*
320  * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal.
321  *
322  * Writes a metadata buffer to a given disk block.  The actual IO is not
323  * performed but a new buffer_head is constructed which labels the data
324  * to be written with the correct destination disk block.
325  *
326  * Any magic-number escaping which needs to be done will cause a
327  * copy-out here.  If the buffer happens to start with the
328  * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the
329  * magic number is only written to the log for descripter blocks.  In
330  * this case, we copy the data and replace the first word with 0, and we
331  * return a result code which indicates that this buffer needs to be
332  * marked as an escaped buffer in the corresponding log descriptor
333  * block.  The missing word can then be restored when the block is read
334  * during recovery.
335  *
336  * If the source buffer has already been modified by a new transaction
337  * since we took the last commit snapshot, we use the frozen copy of
338  * that data for IO. If we end up using the existing buffer_head's data
339  * for the write, then we have to make sure nobody modifies it while the
340  * IO is in progress. do_get_write_access() handles this.
341  *
342  * The function returns a pointer to the buffer_head to be used for IO.
343  * 
344  *
345  * Return value:
346  *  <0: Error
347  * >=0: Finished OK
348  *
349  * On success:
350  * Bit 0 set == escape performed on the data
351  * Bit 1 set == buffer copy-out performed (kfree the data after IO)
352  */
353 
354 int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
355                                   struct journal_head  *jh_in,
356                                   struct buffer_head **bh_out,
357                                   sector_t blocknr)
358 {
359         int need_copy_out = 0;
360         int done_copy_out = 0;
361         int do_escape = 0;
362         char *mapped_data;
363         struct buffer_head *new_bh;
364         struct page *new_page;
365         unsigned int new_offset;
366         struct buffer_head *bh_in = jh2bh(jh_in);
367         journal_t *journal = transaction->t_journal;
368 
369         /*
370          * The buffer really shouldn't be locked: only the current committing
371          * transaction is allowed to write it, so nobody else is allowed
372          * to do any IO.
373          *
374          * akpm: except if we're journalling data, and write() output is
375          * also part of a shared mapping, and another thread has
376          * decided to launch a writepage() against this buffer.
377          */
378         J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
379 
380         new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL);
381 
382         /* keep subsequent assertions sane */
383         atomic_set(&new_bh->b_count, 1);
384 
385         jbd_lock_bh_state(bh_in);
386 repeat:
387         /*
388          * If a new transaction has already done a buffer copy-out, then
389          * we use that version of the data for the commit.
390          */
391         if (jh_in->b_frozen_data) {
392                 done_copy_out = 1;
393                 new_page = virt_to_page(jh_in->b_frozen_data);
394                 new_offset = offset_in_page(jh_in->b_frozen_data);
395         } else {
396                 new_page = jh2bh(jh_in)->b_page;
397                 new_offset = offset_in_page(jh2bh(jh_in)->b_data);
398         }
399 
400         mapped_data = kmap_atomic(new_page);
401         /*
402          * Fire data frozen trigger if data already wasn't frozen.  Do this
403          * before checking for escaping, as the trigger may modify the magic
404          * offset.  If a copy-out happens afterwards, it will have the correct
405          * data in the buffer.
406          */
407         if (!done_copy_out)
408                 jbd2_buffer_frozen_trigger(jh_in, mapped_data + new_offset,
409                                            jh_in->b_triggers);
410 
411         /*
412          * Check for escaping
413          */
414         if (*((__be32 *)(mapped_data + new_offset)) ==
415                                 cpu_to_be32(JBD2_MAGIC_NUMBER)) {
416                 need_copy_out = 1;
417                 do_escape = 1;
418         }
419         kunmap_atomic(mapped_data);
420 
421         /*
422          * Do we need to do a data copy?
423          */
424         if (need_copy_out && !done_copy_out) {
425                 char *tmp;
426 
427                 jbd_unlock_bh_state(bh_in);
428                 tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
429                 if (!tmp) {
430                         brelse(new_bh);
431                         return -ENOMEM;
432                 }
433                 jbd_lock_bh_state(bh_in);
434                 if (jh_in->b_frozen_data) {
435                         jbd2_free(tmp, bh_in->b_size);
436                         goto repeat;
437                 }
438 
439                 jh_in->b_frozen_data = tmp;
440                 mapped_data = kmap_atomic(new_page);
441                 memcpy(tmp, mapped_data + new_offset, bh_in->b_size);
442                 kunmap_atomic(mapped_data);
443 
444                 new_page = virt_to_page(tmp);
445                 new_offset = offset_in_page(tmp);
446                 done_copy_out = 1;
447 
448                 /*
449                  * This isn't strictly necessary, as we're using frozen
450                  * data for the escaping, but it keeps consistency with
451                  * b_frozen_data usage.
452                  */
453                 jh_in->b_frozen_triggers = jh_in->b_triggers;
454         }
455 
456         /*
457          * Did we need to do an escaping?  Now we've done all the
458          * copying, we can finally do so.
459          */
460         if (do_escape) {
461                 mapped_data = kmap_atomic(new_page);
462                 *((unsigned int *)(mapped_data + new_offset)) = 0;
463                 kunmap_atomic(mapped_data);
464         }
465 
466         set_bh_page(new_bh, new_page, new_offset);
467         new_bh->b_size = bh_in->b_size;
468         new_bh->b_bdev = journal->j_dev;
469         new_bh->b_blocknr = blocknr;
470         new_bh->b_private = bh_in;
471         set_buffer_mapped(new_bh);
472         set_buffer_dirty(new_bh);
473 
474         *bh_out = new_bh;
475 
476         /*
477          * The to-be-written buffer needs to get moved to the io queue,
478          * and the original buffer whose contents we are shadowing or
479          * copying is moved to the transaction's shadow queue.
480          */
481         JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
482         spin_lock(&journal->j_list_lock);
483         __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
484         spin_unlock(&journal->j_list_lock);
485         set_buffer_shadow(bh_in);
486         jbd_unlock_bh_state(bh_in);
487 
488         return do_escape | (done_copy_out << 1);
489 }
490 
491 /*
492  * Allocation code for the journal file.  Manage the space left in the
493  * journal, so that we can begin checkpointing when appropriate.
494  */
495 
496 /*
497  * Called with j_state_lock locked for writing.
498  * Returns true if a transaction commit was started.
499  */
500 int __jbd2_log_start_commit(journal_t *journal, tid_t target)
501 {
502         /* Return if the txn has already requested to be committed */
503         if (journal->j_commit_request == target)
504                 return 0;
505 
506         /*
507          * The only transaction we can possibly wait upon is the
508          * currently running transaction (if it exists).  Otherwise,
509          * the target tid must be an old one.
510          */
511         if (journal->j_running_transaction &&
512             journal->j_running_transaction->t_tid == target) {
513                 /*
514                  * We want a new commit: OK, mark the request and wakeup the
515                  * commit thread.  We do _not_ do the commit ourselves.
516                  */
517 
518                 journal->j_commit_request = target;
519                 jbd_debug(1, "JBD2: requesting commit %d/%d\n",
520                           journal->j_commit_request,
521                           journal->j_commit_sequence);
522                 journal->j_running_transaction->t_requested = jiffies;
523                 wake_up(&journal->j_wait_commit);
524                 return 1;
525         } else if (!tid_geq(journal->j_commit_request, target))
526                 /* This should never happen, but if it does, preserve
527                    the evidence before kjournald goes into a loop and
528                    increments j_commit_sequence beyond all recognition. */
529                 WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n",
530                           journal->j_commit_request,
531                           journal->j_commit_sequence,
532                           target, journal->j_running_transaction ? 
533                           journal->j_running_transaction->t_tid : 0);
534         return 0;
535 }
536 
537 int jbd2_log_start_commit(journal_t *journal, tid_t tid)
538 {
539         int ret;
540 
541         write_lock(&journal->j_state_lock);
542         ret = __jbd2_log_start_commit(journal, tid);
543         write_unlock(&journal->j_state_lock);
544         return ret;
545 }
546 
547 /*
548  * Force and wait any uncommitted transactions.  We can only force the running
549  * transaction if we don't have an active handle, otherwise, we will deadlock.
550  * Returns: <0 in case of error,
551  *           0 if nothing to commit,
552  *           1 if transaction was successfully committed.
553  */
554 static int __jbd2_journal_force_commit(journal_t *journal)
555 {
556         transaction_t *transaction = NULL;
557         tid_t tid;
558         int need_to_start = 0, ret = 0;
559 
560         read_lock(&journal->j_state_lock);
561         if (journal->j_running_transaction && !current->journal_info) {
562                 transaction = journal->j_running_transaction;
563                 if (!tid_geq(journal->j_commit_request, transaction->t_tid))
564                         need_to_start = 1;
565         } else if (journal->j_committing_transaction)
566                 transaction = journal->j_committing_transaction;
567 
568         if (!transaction) {
569                 /* Nothing to commit */
570                 read_unlock(&journal->j_state_lock);
571                 return 0;
572         }
573         tid = transaction->t_tid;
574         read_unlock(&journal->j_state_lock);
575         if (need_to_start)
576                 jbd2_log_start_commit(journal, tid);
577         ret = jbd2_log_wait_commit(journal, tid);
578         if (!ret)
579                 ret = 1;
580 
581         return ret;
582 }
583 
584 /**
585  * Force and wait upon a commit if the calling process is not within
586  * transaction.  This is used for forcing out undo-protected data which contains
587  * bitmaps, when the fs is running out of space.
588  *
589  * @journal: journal to force
590  * Returns true if progress was made.
591  */
592 int jbd2_journal_force_commit_nested(journal_t *journal)
593 {
594         int ret;
595 
596         ret = __jbd2_journal_force_commit(journal);
597         return ret > 0;
598 }
599 
600 /**
601  * int journal_force_commit() - force any uncommitted transactions
602  * @journal: journal to force
603  *
604  * Caller want unconditional commit. We can only force the running transaction
605  * if we don't have an active handle, otherwise, we will deadlock.
606  */
607 int jbd2_journal_force_commit(journal_t *journal)
608 {
609         int ret;
610 
611         J_ASSERT(!current->journal_info);
612         ret = __jbd2_journal_force_commit(journal);
613         if (ret > 0)
614                 ret = 0;
615         return ret;
616 }
617 
618 /*
619  * Start a commit of the current running transaction (if any).  Returns true
620  * if a transaction is going to be committed (or is currently already
621  * committing), and fills its tid in at *ptid
622  */
623 int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
624 {
625         int ret = 0;
626 
627         write_lock(&journal->j_state_lock);
628         if (journal->j_running_transaction) {
629                 tid_t tid = journal->j_running_transaction->t_tid;
630 
631                 __jbd2_log_start_commit(journal, tid);
632                 /* There's a running transaction and we've just made sure
633                  * it's commit has been scheduled. */
634                 if (ptid)
635                         *ptid = tid;
636                 ret = 1;
637         } else if (journal->j_committing_transaction) {
638                 /*
639                  * If commit has been started, then we have to wait for
640                  * completion of that transaction.
641                  */
642                 if (ptid)
643                         *ptid = journal->j_committing_transaction->t_tid;
644                 ret = 1;
645         }
646         write_unlock(&journal->j_state_lock);
647         return ret;
648 }
649 
650 /*
651  * Return 1 if a given transaction has not yet sent barrier request
652  * connected with a transaction commit. If 0 is returned, transaction
653  * may or may not have sent the barrier. Used to avoid sending barrier
654  * twice in common cases.
655  */
656 int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid)
657 {
658         int ret = 0;
659         transaction_t *commit_trans;
660 
661         if (!(journal->j_flags & JBD2_BARRIER))
662                 return 0;
663         read_lock(&journal->j_state_lock);
664         /* Transaction already committed? */
665         if (tid_geq(journal->j_commit_sequence, tid))
666                 goto out;
667         commit_trans = journal->j_committing_transaction;
668         if (!commit_trans || commit_trans->t_tid != tid) {
669                 ret = 1;
670                 goto out;
671         }
672         /*
673          * Transaction is being committed and we already proceeded to
674          * submitting a flush to fs partition?
675          */
676         if (journal->j_fs_dev != journal->j_dev) {
677                 if (!commit_trans->t_need_data_flush ||
678                     commit_trans->t_state >= T_COMMIT_DFLUSH)
679                         goto out;
680         } else {
681                 if (commit_trans->t_state >= T_COMMIT_JFLUSH)
682                         goto out;
683         }
684         ret = 1;
685 out:
686         read_unlock(&journal->j_state_lock);
687         return ret;
688 }
689 EXPORT_SYMBOL(jbd2_trans_will_send_data_barrier);
690 
691 /*
692  * Wait for a specified commit to complete.
693  * The caller may not hold the journal lock.
694  */
695 int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
696 {
697         int err = 0;
698 
699         read_lock(&journal->j_state_lock);
700 #ifdef CONFIG_PROVE_LOCKING
701         /*
702          * Some callers make sure transaction is already committing and in that
703          * case we cannot block on open handles anymore. So don't warn in that
704          * case.
705          */
706         if (tid_gt(tid, journal->j_commit_sequence) &&
707             (!journal->j_committing_transaction ||
708              journal->j_committing_transaction->t_tid != tid)) {
709                 read_unlock(&journal->j_state_lock);
710                 jbd2_might_wait_for_commit(journal);
711                 read_lock(&journal->j_state_lock);
712         }
713 #endif
714 #ifdef CONFIG_JBD2_DEBUG
715         if (!tid_geq(journal->j_commit_request, tid)) {
716                 printk(KERN_ERR
717                        "%s: error: j_commit_request=%d, tid=%d\n",
718                        __func__, journal->j_commit_request, tid);
719         }
720 #endif
721         while (tid_gt(tid, journal->j_commit_sequence)) {
722                 jbd_debug(1, "JBD2: want %d, j_commit_sequence=%d\n",
723                                   tid, journal->j_commit_sequence);
724                 read_unlock(&journal->j_state_lock);
725                 wake_up(&journal->j_wait_commit);
726                 wait_event(journal->j_wait_done_commit,
727                                 !tid_gt(tid, journal->j_commit_sequence));
728                 read_lock(&journal->j_state_lock);
729         }
730         read_unlock(&journal->j_state_lock);
731 
732         if (unlikely(is_journal_aborted(journal)))
733                 err = -EIO;
734         return err;
735 }
736 
737 /* Return 1 when transaction with given tid has already committed. */
738 int jbd2_transaction_committed(journal_t *journal, tid_t tid)
739 {
740         int ret = 1;
741 
742         read_lock(&journal->j_state_lock);
743         if (journal->j_running_transaction &&
744             journal->j_running_transaction->t_tid == tid)
745                 ret = 0;
746         if (journal->j_committing_transaction &&
747             journal->j_committing_transaction->t_tid == tid)
748                 ret = 0;
749         read_unlock(&journal->j_state_lock);
750         return ret;
751 }
752 EXPORT_SYMBOL(jbd2_transaction_committed);
753 
754 /*
755  * When this function returns the transaction corresponding to tid
756  * will be completed.  If the transaction has currently running, start
757  * committing that transaction before waiting for it to complete.  If
758  * the transaction id is stale, it is by definition already completed,
759  * so just return SUCCESS.
760  */
761 int jbd2_complete_transaction(journal_t *journal, tid_t tid)
762 {
763         int     need_to_wait = 1;
764 
765         read_lock(&journal->j_state_lock);
766         if (journal->j_running_transaction &&
767             journal->j_running_transaction->t_tid == tid) {
768                 if (journal->j_commit_request != tid) {
769                         /* transaction not yet started, so request it */
770                         read_unlock(&journal->j_state_lock);
771                         jbd2_log_start_commit(journal, tid);
772                         goto wait_commit;
773                 }
774         } else if (!(journal->j_committing_transaction &&
775                      journal->j_committing_transaction->t_tid == tid))
776                 need_to_wait = 0;
777         read_unlock(&journal->j_state_lock);
778         if (!need_to_wait)
779                 return 0;
780 wait_commit:
781         return jbd2_log_wait_commit(journal, tid);
782 }
783 EXPORT_SYMBOL(jbd2_complete_transaction);
784 
785 /*
786  * Log buffer allocation routines:
787  */
788 
789 int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
790 {
791         unsigned long blocknr;
792 
793         write_lock(&journal->j_state_lock);
794         J_ASSERT(journal->j_free > 1);
795 
796         blocknr = journal->j_head;
797         journal->j_head++;
798         journal->j_free--;
799         if (journal->j_head == journal->j_last)
800                 journal->j_head = journal->j_first;
801         write_unlock(&journal->j_state_lock);
802         return jbd2_journal_bmap(journal, blocknr, retp);
803 }
804 
805 /*
806  * Conversion of logical to physical block numbers for the journal
807  *
808  * On external journals the journal blocks are identity-mapped, so
809  * this is a no-op.  If needed, we can use j_blk_offset - everything is
810  * ready.
811  */
812 int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
813                  unsigned long long *retp)
814 {
815         int err = 0;
816         unsigned long long ret;
817 
818         if (journal->j_inode) {
819                 ret = bmap(journal->j_inode, blocknr);
820                 if (ret)
821                         *retp = ret;
822                 else {
823                         printk(KERN_ALERT "%s: journal block not found "
824                                         "at offset %lu on %s\n",
825                                __func__, blocknr, journal->j_devname);
826                         err = -EIO;
827                         __journal_abort_soft(journal, err);
828                 }
829         } else {
830                 *retp = blocknr; /* +journal->j_blk_offset */
831         }
832         return err;
833 }
834 
835 /*
836  * We play buffer_head aliasing tricks to write data/metadata blocks to
837  * the journal without copying their contents, but for journal
838  * descriptor blocks we do need to generate bona fide buffers.
839  *
840  * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying
841  * the buffer's contents they really should run flush_dcache_page(bh->b_page).
842  * But we don't bother doing that, so there will be coherency problems with
843  * mmaps of blockdevs which hold live JBD-controlled filesystems.
844  */
845 struct buffer_head *
846 jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type)
847 {
848         journal_t *journal = transaction->t_journal;
849         struct buffer_head *bh;
850         unsigned long long blocknr;
851         journal_header_t *header;
852         int err;
853 
854         err = jbd2_journal_next_log_block(journal, &blocknr);
855 
856         if (err)
857                 return NULL;
858 
859         bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
860         if (!bh)
861                 return NULL;
862         lock_buffer(bh);
863         memset(bh->b_data, 0, journal->j_blocksize);
864         header = (journal_header_t *)bh->b_data;
865         header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
866         header->h_blocktype = cpu_to_be32(type);
867         header->h_sequence = cpu_to_be32(transaction->t_tid);
868         set_buffer_uptodate(bh);
869         unlock_buffer(bh);
870         BUFFER_TRACE(bh, "return this buffer");
871         return bh;
872 }
873 
874 void jbd2_descriptor_block_csum_set(journal_t *j, struct buffer_head *bh)
875 {
876         struct jbd2_journal_block_tail *tail;
877         __u32 csum;
878 
879         if (!jbd2_journal_has_csum_v2or3(j))
880                 return;
881 
882         tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize -
883                         sizeof(struct jbd2_journal_block_tail));
884         tail->t_checksum = 0;
885         csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
886         tail->t_checksum = cpu_to_be32(csum);
887 }
888 
889 /*
890  * Return tid of the oldest transaction in the journal and block in the journal
891  * where the transaction starts.
892  *
893  * If the journal is now empty, return which will be the next transaction ID
894  * we will write and where will that transaction start.
895  *
896  * The return value is 0 if journal tail cannot be pushed any further, 1 if
897  * it can.
898  */
899 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
900                               unsigned long *block)
901 {
902         transaction_t *transaction;
903         int ret;
904 
905         read_lock(&journal->j_state_lock);
906         spin_lock(&journal->j_list_lock);
907         transaction = journal->j_checkpoint_transactions;
908         if (transaction) {
909                 *tid = transaction->t_tid;
910                 *block = transaction->t_log_start;
911         } else if ((transaction = journal->j_committing_transaction) != NULL) {
912                 *tid = transaction->t_tid;
913                 *block = transaction->t_log_start;
914         } else if ((transaction = journal->j_running_transaction) != NULL) {
915                 *tid = transaction->t_tid;
916                 *block = journal->j_head;
917         } else {
918                 *tid = journal->j_transaction_sequence;
919                 *block = journal->j_head;
920         }
921         ret = tid_gt(*tid, journal->j_tail_sequence);
922         spin_unlock(&journal->j_list_lock);
923         read_unlock(&journal->j_state_lock);
924 
925         return ret;
926 }
927 
928 /*
929  * Update information in journal structure and in on disk journal superblock
930  * about log tail. This function does not check whether information passed in
931  * really pushes log tail further. It's responsibility of the caller to make
932  * sure provided log tail information is valid (e.g. by holding
933  * j_checkpoint_mutex all the time between computing log tail and calling this
934  * function as is the case with jbd2_cleanup_journal_tail()).
935  *
936  * Requires j_checkpoint_mutex
937  */
938 int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
939 {
940         unsigned long freed;
941         int ret;
942 
943         BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
944 
945         /*
946          * We cannot afford for write to remain in drive's caches since as
947          * soon as we update j_tail, next transaction can start reusing journal
948          * space and if we lose sb update during power failure we'd replay
949          * old transaction with possibly newly overwritten data.
950          */
951         ret = jbd2_journal_update_sb_log_tail(journal, tid, block,
952                                               REQ_SYNC | REQ_FUA);
953         if (ret)
954                 goto out;
955 
956         write_lock(&journal->j_state_lock);
957         freed = block - journal->j_tail;
958         if (block < journal->j_tail)
959                 freed += journal->j_last - journal->j_first;
960 
961         trace_jbd2_update_log_tail(journal, tid, block, freed);
962         jbd_debug(1,
963                   "Cleaning journal tail from %d to %d (offset %lu), "
964                   "freeing %lu\n",
965                   journal->j_tail_sequence, tid, block, freed);
966 
967         journal->j_free += freed;
968         journal->j_tail_sequence = tid;
969         journal->j_tail = block;
970         write_unlock(&journal->j_state_lock);
971 
972 out:
973         return ret;
974 }
975 
976 /*
977  * This is a variation of __jbd2_update_log_tail which checks for validity of
978  * provided log tail and locks j_checkpoint_mutex. So it is safe against races
979  * with other threads updating log tail.
980  */
981 void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
982 {
983         mutex_lock_io(&journal->j_checkpoint_mutex);
984         if (tid_gt(tid, journal->j_tail_sequence))
985                 __jbd2_update_log_tail(journal, tid, block);
986         mutex_unlock(&journal->j_checkpoint_mutex);
987 }
988 
989 struct jbd2_stats_proc_session {
990         journal_t *journal;
991         struct transaction_stats_s *stats;
992         int start;
993         int max;
994 };
995 
996 static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
997 {
998         return *pos ? NULL : SEQ_START_TOKEN;
999 }
1000 
1001 static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos)
1002 {
1003         return NULL;
1004 }
1005 
1006 static int jbd2_seq_info_show(struct seq_file *seq, void *v)
1007 {
1008         struct jbd2_stats_proc_session *s = seq->private;
1009 
1010         if (v != SEQ_START_TOKEN)
1011                 return 0;
1012         seq_printf(seq, "%lu transactions (%lu requested), "
1013                    "each up to %u blocks\n",
1014                    s->stats->ts_tid, s->stats->ts_requested,
1015                    s->journal->j_max_transaction_buffers);
1016         if (s->stats->ts_tid == 0)
1017                 return 0;
1018         seq_printf(seq, "average: \n  %ums waiting for transaction\n",
1019             jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
1020         seq_printf(seq, "  %ums request delay\n",
1021             (s->stats->ts_requested == 0) ? 0 :
1022             jiffies_to_msecs(s->stats->run.rs_request_delay /
1023                              s->stats->ts_requested));
1024         seq_printf(seq, "  %ums running transaction\n",
1025             jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
1026         seq_printf(seq, "  %ums transaction was being locked\n",
1027             jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
1028         seq_printf(seq, "  %ums flushing data (in ordered mode)\n",
1029             jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
1030         seq_printf(seq, "  %ums logging transaction\n",
1031             jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
1032         seq_printf(seq, "  %lluus average transaction commit time\n",
1033                    div_u64(s->journal->j_average_commit_time, 1000));
1034         seq_printf(seq, "  %lu handles per transaction\n",
1035             s->stats->run.rs_handle_count / s->stats->ts_tid);
1036         seq_printf(seq, "  %lu blocks per transaction\n",
1037             s->stats->run.rs_blocks / s->stats->ts_tid);
1038         seq_printf(seq, "  %lu logged blocks per transaction\n",
1039             s->stats->run.rs_blocks_logged / s->stats->ts_tid);
1040         return 0;
1041 }
1042 
1043 static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
1044 {
1045 }
1046 
1047 static const struct seq_operations jbd2_seq_info_ops = {
1048         .start  = jbd2_seq_info_start,
1049         .next   = jbd2_seq_info_next,
1050         .stop   = jbd2_seq_info_stop,
1051         .show   = jbd2_seq_info_show,
1052 };
1053 
1054 static int jbd2_seq_info_open(struct inode *inode, struct file *file)
1055 {
1056         journal_t *journal = PDE_DATA(inode);
1057         struct jbd2_stats_proc_session *s;
1058         int rc, size;
1059 
1060         s = kmalloc(sizeof(*s), GFP_KERNEL);
1061         if (s == NULL)
1062                 return -ENOMEM;
1063         size = sizeof(struct transaction_stats_s);
1064         s->stats = kmalloc(size, GFP_KERNEL);
1065         if (s->stats == NULL) {
1066                 kfree(s);
1067                 return -ENOMEM;
1068         }
1069         spin_lock(&journal->j_history_lock);
1070         memcpy(s->stats, &journal->j_stats, size);
1071         s->journal = journal;
1072         spin_unlock(&journal->j_history_lock);
1073 
1074         rc = seq_open(file, &jbd2_seq_info_ops);
1075         if (rc == 0) {
1076                 struct seq_file *m = file->private_data;
1077                 m->private = s;
1078         } else {
1079                 kfree(s->stats);
1080                 kfree(s);
1081         }
1082         return rc;
1083 
1084 }
1085 
1086 static int jbd2_seq_info_release(struct inode *inode, struct file *file)
1087 {
1088         struct seq_file *seq = file->private_data;
1089         struct jbd2_stats_proc_session *s = seq->private;
1090         kfree(s->stats);
1091         kfree(s);
1092         return seq_release(inode, file);
1093 }
1094 
1095 static const struct file_operations jbd2_seq_info_fops = {
1096         .owner          = THIS_MODULE,
1097         .open           = jbd2_seq_info_open,
1098         .read           = seq_read,
1099         .llseek         = seq_lseek,
1100         .release        = jbd2_seq_info_release,
1101 };
1102 
1103 static struct proc_dir_entry *proc_jbd2_stats;
1104 
1105 static void jbd2_stats_proc_init(journal_t *journal)
1106 {
1107         journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
1108         if (journal->j_proc_entry) {
1109                 proc_create_data("info", S_IRUGO, journal->j_proc_entry,
1110                                  &jbd2_seq_info_fops, journal);
1111         }
1112 }
1113 
1114 static void jbd2_stats_proc_exit(journal_t *journal)
1115 {
1116         remove_proc_entry("info", journal->j_proc_entry);
1117         remove_proc_entry(journal->j_devname, proc_jbd2_stats);
1118 }
1119 
1120 /*
1121  * Management for journal control blocks: functions to create and
1122  * destroy journal_t structures, and to initialise and read existing
1123  * journal blocks from disk.  */
1124 
1125 /* First: create and setup a journal_t object in memory.  We initialise
1126  * very few fields yet: that has to wait until we have created the
1127  * journal structures from from scratch, or loaded them from disk. */
1128 
1129 static journal_t *journal_init_common(struct block_device *bdev,
1130                         struct block_device *fs_dev,
1131                         unsigned long long start, int len, int blocksize)
1132 {
1133         static struct lock_class_key jbd2_trans_commit_key;
1134         journal_t *journal;
1135         int err;
1136         struct buffer_head *bh;
1137         int n;
1138 
1139         journal = kzalloc(sizeof(*journal), GFP_KERNEL);
1140         if (!journal)
1141                 return NULL;
1142 
1143         init_waitqueue_head(&journal->j_wait_transaction_locked);
1144         init_waitqueue_head(&journal->j_wait_done_commit);
1145         init_waitqueue_head(&journal->j_wait_commit);
1146         init_waitqueue_head(&journal->j_wait_updates);
1147         init_waitqueue_head(&journal->j_wait_reserved);
1148         mutex_init(&journal->j_barrier);
1149         mutex_init(&journal->j_checkpoint_mutex);
1150         spin_lock_init(&journal->j_revoke_lock);
1151         spin_lock_init(&journal->j_list_lock);
1152         rwlock_init(&journal->j_state_lock);
1153 
1154         journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
1155         journal->j_min_batch_time = 0;
1156         journal->j_max_batch_time = 15000; /* 15ms */
1157         atomic_set(&journal->j_reserved_credits, 0);
1158 
1159         /* The journal is marked for error until we succeed with recovery! */
1160         journal->j_flags = JBD2_ABORT;
1161 
1162         /* Set up a default-sized revoke table for the new mount. */
1163         err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
1164         if (err)
1165                 goto err_cleanup;
1166 
1167         spin_lock_init(&journal->j_history_lock);
1168 
1169         lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle",
1170                          &jbd2_trans_commit_key, 0);
1171 
1172         /* journal descriptor can store up to n blocks -bzzz */
1173         journal->j_blocksize = blocksize;
1174         journal->j_dev = bdev;
1175         journal->j_fs_dev = fs_dev;
1176         journal->j_blk_offset = start;
1177         journal->j_maxlen = len;
1178         n = journal->j_blocksize / sizeof(journal_block_tag_t);
1179         journal->j_wbufsize = n;
1180         journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *),
1181                                         GFP_KERNEL);
1182         if (!journal->j_wbuf)
1183                 goto err_cleanup;
1184 
1185         bh = getblk_unmovable(journal->j_dev, start, journal->j_blocksize);
1186         if (!bh) {
1187                 pr_err("%s: Cannot get buffer for journal superblock\n",
1188                         __func__);
1189                 goto err_cleanup;
1190         }
1191         journal->j_sb_buffer = bh;
1192         journal->j_superblock = (journal_superblock_t *)bh->b_data;
1193 
1194         return journal;
1195 
1196 err_cleanup:
1197         kfree(journal->j_wbuf);
1198         jbd2_journal_destroy_revoke(journal);
1199         kfree(journal);
1200         return NULL;
1201 }
1202 
1203 /* jbd2_journal_init_dev and jbd2_journal_init_inode:
1204  *
1205  * Create a journal structure assigned some fixed set of disk blocks to
1206  * the journal.  We don't actually touch those disk blocks yet, but we
1207  * need to set up all of the mapping information to tell the journaling
1208  * system where the journal blocks are.
1209  *
1210  */
1211 
1212 /**
1213  *  journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure
1214  *  @bdev: Block device on which to create the journal
1215  *  @fs_dev: Device which hold journalled filesystem for this journal.
1216  *  @start: Block nr Start of journal.
1217  *  @len:  Length of the journal in blocks.
1218  *  @blocksize: blocksize of journalling device
1219  *
1220  *  Returns: a newly created journal_t *
1221  *
1222  *  jbd2_journal_init_dev creates a journal which maps a fixed contiguous
1223  *  range of blocks on an arbitrary block device.
1224  *
1225  */
1226 journal_t *jbd2_journal_init_dev(struct block_device *bdev,
1227                         struct block_device *fs_dev,
1228                         unsigned long long start, int len, int blocksize)
1229 {
1230         journal_t *journal;
1231 
1232         journal = journal_init_common(bdev, fs_dev, start, len, blocksize);
1233         if (!journal)
1234                 return NULL;
1235 
1236         bdevname(journal->j_dev, journal->j_devname);
1237         strreplace(journal->j_devname, '/', '!');
1238         jbd2_stats_proc_init(journal);
1239 
1240         return journal;
1241 }
1242 
1243 /**
1244  *  journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode.
1245  *  @inode: An inode to create the journal in
1246  *
1247  * jbd2_journal_init_inode creates a journal which maps an on-disk inode as
1248  * the journal.  The inode must exist already, must support bmap() and
1249  * must have all data blocks preallocated.
1250  */
1251 journal_t *jbd2_journal_init_inode(struct inode *inode)
1252 {
1253         journal_t *journal;
1254         char *p;
1255         unsigned long long blocknr;
1256 
1257         blocknr = bmap(inode, 0);
1258         if (!blocknr) {
1259                 pr_err("%s: Cannot locate journal superblock\n",
1260                         __func__);
1261                 return NULL;
1262         }
1263 
1264         jbd_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n",
1265                   inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size,
1266                   inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
1267 
1268         journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev,
1269                         blocknr, inode->i_size >> inode->i_sb->s_blocksize_bits,
1270                         inode->i_sb->s_blocksize);
1271         if (!journal)
1272                 return NULL;
1273 
1274         journal->j_inode = inode;
1275         bdevname(journal->j_dev, journal->j_devname);
1276         p = strreplace(journal->j_devname, '/', '!');
1277         sprintf(p, "-%lu", journal->j_inode->i_ino);
1278         jbd2_stats_proc_init(journal);
1279 
1280         return journal;
1281 }
1282 
1283 /*
1284  * If the journal init or create aborts, we need to mark the journal
1285  * superblock as being NULL to prevent the journal destroy from writing
1286  * back a bogus superblock.
1287  */
1288 static void journal_fail_superblock (journal_t *journal)
1289 {
1290         struct buffer_head *bh = journal->j_sb_buffer;
1291         brelse(bh);
1292         journal->j_sb_buffer = NULL;
1293 }
1294 
1295 /*
1296  * Given a journal_t structure, initialise the various fields for
1297  * startup of a new journaling session.  We use this both when creating
1298  * a journal, and after recovering an old journal to reset it for
1299  * subsequent use.
1300  */
1301 
1302 static int journal_reset(journal_t *journal)
1303 {
1304         journal_superblock_t *sb = journal->j_superblock;
1305         unsigned long long first, last;
1306 
1307         first = be32_to_cpu(sb->s_first);
1308         last = be32_to_cpu(sb->s_maxlen);
1309         if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
1310                 printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n",
1311                        first, last);
1312                 journal_fail_superblock(journal);
1313                 return -EINVAL;
1314         }
1315 
1316         journal->j_first = first;
1317         journal->j_last = last;
1318 
1319         journal->j_head = first;
1320         journal->j_tail = first;
1321         journal->j_free = last - first;
1322 
1323         journal->j_tail_sequence = journal->j_transaction_sequence;
1324         journal->j_commit_sequence = journal->j_transaction_sequence - 1;
1325         journal->j_commit_request = journal->j_commit_sequence;
1326 
1327         journal->j_max_transaction_buffers = journal->j_maxlen / 4;
1328 
1329         /*
1330          * As a special case, if the on-disk copy is already marked as needing
1331          * no recovery (s_start == 0), then we can safely defer the superblock
1332          * update until the next commit by setting JBD2_FLUSHED.  This avoids
1333          * attempting a write to a potential-readonly device.
1334          */
1335         if (sb->s_start == 0) {
1336                 jbd_debug(1, "JBD2: Skipping superblock update on recovered sb "
1337                         "(start %ld, seq %d, errno %d)\n",
1338                         journal->j_tail, journal->j_tail_sequence,
1339                         journal->j_errno);
1340                 journal->j_flags |= JBD2_FLUSHED;
1341         } else {
1342                 /* Lock here to make assertions happy... */
1343                 mutex_lock_io(&journal->j_checkpoint_mutex);
1344                 /*
1345                  * Update log tail information. We use REQ_FUA since new
1346                  * transaction will start reusing journal space and so we
1347                  * must make sure information about current log tail is on
1348                  * disk before that.
1349                  */
1350                 jbd2_journal_update_sb_log_tail(journal,
1351                                                 journal->j_tail_sequence,
1352                                                 journal->j_tail,
1353                                                 REQ_SYNC | REQ_FUA);
1354                 mutex_unlock(&journal->j_checkpoint_mutex);
1355         }
1356         return jbd2_journal_start_thread(journal);
1357 }
1358 
1359 static int jbd2_write_superblock(journal_t *journal, int write_flags)
1360 {
1361         struct buffer_head *bh = journal->j_sb_buffer;
1362         journal_superblock_t *sb = journal->j_superblock;
1363         int ret;
1364 
1365         trace_jbd2_write_superblock(journal, write_flags);
1366         if (!(journal->j_flags & JBD2_BARRIER))
1367                 write_flags &= ~(REQ_FUA | REQ_PREFLUSH);
1368         lock_buffer(bh);
1369         if (buffer_write_io_error(bh)) {
1370                 /*
1371                  * Oh, dear.  A previous attempt to write the journal
1372                  * superblock failed.  This could happen because the
1373                  * USB device was yanked out.  Or it could happen to
1374                  * be a transient write error and maybe the block will
1375                  * be remapped.  Nothing we can do but to retry the
1376                  * write and hope for the best.
1377                  */
1378                 printk(KERN_ERR "JBD2: previous I/O error detected "
1379                        "for journal superblock update for %s.\n",
1380                        journal->j_devname);
1381                 clear_buffer_write_io_error(bh);
1382                 set_buffer_uptodate(bh);
1383         }
1384         jbd2_superblock_csum_set(journal, sb);
1385         get_bh(bh);
1386         bh->b_end_io = end_buffer_write_sync;
1387         ret = submit_bh(REQ_OP_WRITE, write_flags, bh);
1388         wait_on_buffer(bh);
1389         if (buffer_write_io_error(bh)) {
1390                 clear_buffer_write_io_error(bh);
1391                 set_buffer_uptodate(bh);
1392                 ret = -EIO;
1393         }
1394         if (ret) {
1395                 printk(KERN_ERR "JBD2: Error %d detected when updating "
1396                        "journal superblock for %s.\n", ret,
1397                        journal->j_devname);
1398                 jbd2_journal_abort(journal, ret);
1399         }
1400 
1401         return ret;
1402 }
1403 
1404 /**
1405  * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk.
1406  * @journal: The journal to update.
1407  * @tail_tid: TID of the new transaction at the tail of the log
1408  * @tail_block: The first block of the transaction at the tail of the log
1409  * @write_op: With which operation should we write the journal sb
1410  *
1411  * Update a journal's superblock information about log tail and write it to
1412  * disk, waiting for the IO to complete.
1413  */
1414 int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
1415                                      unsigned long tail_block, int write_op)
1416 {
1417         journal_superblock_t *sb = journal->j_superblock;
1418         int ret;
1419 
1420         if (is_journal_aborted(journal))
1421                 return -EIO;
1422 
1423         BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1424         jbd_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n",
1425                   tail_block, tail_tid);
1426 
1427         sb->s_sequence = cpu_to_be32(tail_tid);
1428         sb->s_start    = cpu_to_be32(tail_block);
1429 
1430         ret = jbd2_write_superblock(journal, write_op);
1431         if (ret)
1432                 goto out;
1433 
1434         /* Log is no longer empty */
1435         write_lock(&journal->j_state_lock);
1436         WARN_ON(!sb->s_sequence);
1437         journal->j_flags &= ~JBD2_FLUSHED;
1438         write_unlock(&journal->j_state_lock);
1439 
1440 out:
1441         return ret;
1442 }
1443 
1444 /**
1445  * jbd2_mark_journal_empty() - Mark on disk journal as empty.
1446  * @journal: The journal to update.
1447  * @write_op: With which operation should we write the journal sb
1448  *
1449  * Update a journal's dynamic superblock fields to show that journal is empty.
1450  * Write updated superblock to disk waiting for IO to complete.
1451  */
1452 static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
1453 {
1454         journal_superblock_t *sb = journal->j_superblock;
1455 
1456         BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1457         read_lock(&journal->j_state_lock);
1458         /* Is it already empty? */
1459         if (sb->s_start == 0) {
1460                 read_unlock(&journal->j_state_lock);
1461                 return;
1462         }
1463         jbd_debug(1, "JBD2: Marking journal as empty (seq %d)\n",
1464                   journal->j_tail_sequence);
1465 
1466         sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
1467         sb->s_start    = cpu_to_be32(0);
1468         read_unlock(&journal->j_state_lock);
1469 
1470         jbd2_write_superblock(journal, write_op);
1471 
1472         /* Log is no longer empty */
1473         write_lock(&journal->j_state_lock);
1474         journal->j_flags |= JBD2_FLUSHED;
1475         write_unlock(&journal->j_state_lock);
1476 }
1477 
1478 
1479 /**
1480  * jbd2_journal_update_sb_errno() - Update error in the journal.
1481  * @journal: The journal to update.
1482  *
1483  * Update a journal's errno.  Write updated superblock to disk waiting for IO
1484  * to complete.
1485  */
1486 void jbd2_journal_update_sb_errno(journal_t *journal)
1487 {
1488         journal_superblock_t *sb = journal->j_superblock;
1489         int errcode;
1490 
1491         read_lock(&journal->j_state_lock);
1492         errcode = journal->j_errno;
1493         read_unlock(&journal->j_state_lock);
1494         if (errcode == -ESHUTDOWN)
1495                 errcode = 0;
1496         jbd_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode);
1497         sb->s_errno    = cpu_to_be32(errcode);
1498 
1499         jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA);
1500 }
1501 EXPORT_SYMBOL(jbd2_journal_update_sb_errno);
1502 
1503 /*
1504  * Read the superblock for a given journal, performing initial
1505  * validation of the format.
1506  */
1507 static int journal_get_superblock(journal_t *journal)
1508 {
1509         struct buffer_head *bh;
1510         journal_superblock_t *sb;
1511         int err = -EIO;
1512 
1513         bh = journal->j_sb_buffer;
1514 
1515         J_ASSERT(bh != NULL);
1516         if (!buffer_uptodate(bh)) {
1517                 ll_rw_block(REQ_OP_READ, 0, 1, &bh);
1518                 wait_on_buffer(bh);
1519                 if (!buffer_uptodate(bh)) {
1520                         printk(KERN_ERR
1521                                 "JBD2: IO error reading journal superblock\n");
1522                         goto out;
1523                 }
1524         }
1525 
1526         if (buffer_verified(bh))
1527                 return 0;
1528 
1529         sb = journal->j_superblock;
1530 
1531         err = -EINVAL;
1532 
1533         if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
1534             sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
1535                 printk(KERN_WARNING "JBD2: no valid journal superblock found\n");
1536                 goto out;
1537         }
1538 
1539         switch(be32_to_cpu(sb->s_header.h_blocktype)) {
1540         case JBD2_SUPERBLOCK_V1:
1541                 journal->j_format_version = 1;
1542                 break;
1543         case JBD2_SUPERBLOCK_V2:
1544                 journal->j_format_version = 2;
1545                 break;
1546         default:
1547                 printk(KERN_WARNING "JBD2: unrecognised superblock format ID\n");
1548                 goto out;
1549         }
1550 
1551         if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
1552                 journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
1553         else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
1554                 printk(KERN_WARNING "JBD2: journal file too short\n");
1555                 goto out;
1556         }
1557 
1558         if (be32_to_cpu(sb->s_first) == 0 ||
1559             be32_to_cpu(sb->s_first) >= journal->j_maxlen) {
1560                 printk(KERN_WARNING
1561                         "JBD2: Invalid start block of journal: %u\n",
1562                         be32_to_cpu(sb->s_first));
1563                 goto out;
1564         }
1565 
1566         if (jbd2_has_feature_csum2(journal) &&
1567             jbd2_has_feature_csum3(journal)) {
1568                 /* Can't have checksum v2 and v3 at the same time! */
1569                 printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 "
1570                        "at the same time!\n");
1571                 goto out;
1572         }
1573 
1574         if (jbd2_journal_has_csum_v2or3_feature(journal) &&
1575             jbd2_has_feature_checksum(journal)) {
1576                 /* Can't have checksum v1 and v2 on at the same time! */
1577                 printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 "
1578                        "at the same time!\n");
1579                 goto out;
1580         }
1581 
1582         if (!jbd2_verify_csum_type(journal, sb)) {
1583                 printk(KERN_ERR "JBD2: Unknown checksum type\n");
1584                 goto out;
1585         }
1586 
1587         /* Load the checksum driver */
1588         if (jbd2_journal_has_csum_v2or3_feature(journal)) {
1589                 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
1590                 if (IS_ERR(journal->j_chksum_driver)) {
1591                         printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
1592                         err = PTR_ERR(journal->j_chksum_driver);
1593                         journal->j_chksum_driver = NULL;
1594                         goto out;
1595                 }
1596         }
1597 
1598         /* Check superblock checksum */
1599         if (!jbd2_superblock_csum_verify(journal, sb)) {
1600                 printk(KERN_ERR "JBD2: journal checksum error\n");
1601                 err = -EFSBADCRC;
1602                 goto out;
1603         }
1604 
1605         /* Precompute checksum seed for all metadata */
1606         if (jbd2_journal_has_csum_v2or3(journal))
1607                 journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
1608                                                    sizeof(sb->s_uuid));
1609 
1610         set_buffer_verified(bh);
1611 
1612         return 0;
1613 
1614 out:
1615         journal_fail_superblock(journal);
1616         return err;
1617 }
1618 
1619 /*
1620  * Load the on-disk journal superblock and read the key fields into the
1621  * journal_t.
1622  */
1623 
1624 static int load_superblock(journal_t *journal)
1625 {
1626         int err;
1627         journal_superblock_t *sb;
1628 
1629         err = journal_get_superblock(journal);
1630         if (err)
1631                 return err;
1632 
1633         sb = journal->j_superblock;
1634 
1635         journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
1636         journal->j_tail = be32_to_cpu(sb->s_start);
1637         journal->j_first = be32_to_cpu(sb->s_first);
1638         journal->j_last = be32_to_cpu(sb->s_maxlen);
1639         journal->j_errno = be32_to_cpu(sb->s_errno);
1640 
1641         return 0;
1642 }
1643 
1644 
1645 /**
1646  * int jbd2_journal_load() - Read journal from disk.
1647  * @journal: Journal to act on.
1648  *
1649  * Given a journal_t structure which tells us which disk blocks contain
1650  * a journal, read the journal from disk to initialise the in-memory
1651  * structures.
1652  */
1653 int jbd2_journal_load(journal_t *journal)
1654 {
1655         int err;
1656         journal_superblock_t *sb;
1657 
1658         err = load_superblock(journal);
1659         if (err)
1660                 return err;
1661 
1662         sb = journal->j_superblock;
1663         /* If this is a V2 superblock, then we have to check the
1664          * features flags on it. */
1665 
1666         if (journal->j_format_version >= 2) {
1667                 if ((sb->s_feature_ro_compat &
1668                      ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
1669                     (sb->s_feature_incompat &
1670                      ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
1671                         printk(KERN_WARNING
1672                                 "JBD2: Unrecognised features on journal\n");
1673                         return -EINVAL;
1674                 }
1675         }
1676 
1677         /*
1678          * Create a slab for this blocksize
1679          */
1680         err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize));
1681         if (err)
1682                 return err;
1683 
1684         /* Let the recovery code check whether it needs to recover any
1685          * data from the journal. */
1686         if (jbd2_journal_recover(journal))
1687                 goto recovery_error;
1688 
1689         if (journal->j_failed_commit) {
1690                 printk(KERN_ERR "JBD2: journal transaction %u on %s "
1691                        "is corrupt.\n", journal->j_failed_commit,
1692                        journal->j_devname);
1693                 return -EFSCORRUPTED;
1694         }
1695 
1696         /* OK, we've finished with the dynamic journal bits:
1697          * reinitialise the dynamic contents of the superblock in memory
1698          * and reset them on disk. */
1699         if (journal_reset(journal))
1700                 goto recovery_error;
1701 
1702         journal->j_flags &= ~JBD2_ABORT;
1703         journal->j_flags |= JBD2_LOADED;
1704         return 0;
1705 
1706 recovery_error:
1707         printk(KERN_WARNING "JBD2: recovery failed\n");
1708         return -EIO;
1709 }
1710 
1711 /**
1712  * void jbd2_journal_destroy() - Release a journal_t structure.
1713  * @journal: Journal to act on.
1714  *
1715  * Release a journal_t structure once it is no longer in use by the
1716  * journaled object.
1717  * Return <0 if we couldn't clean up the journal.
1718  */
1719 int jbd2_journal_destroy(journal_t *journal)
1720 {
1721         int err = 0;
1722 
1723         /* Wait for the commit thread to wake up and die. */
1724         journal_kill_thread(journal);
1725 
1726         /* Force a final log commit */
1727         if (journal->j_running_transaction)
1728                 jbd2_journal_commit_transaction(journal);
1729 
1730         /* Force any old transactions to disk */
1731 
1732         /* Totally anal locking here... */
1733         spin_lock(&journal->j_list_lock);
1734         while (journal->j_checkpoint_transactions != NULL) {
1735                 spin_unlock(&journal->j_list_lock);
1736                 mutex_lock_io(&journal->j_checkpoint_mutex);
1737                 err = jbd2_log_do_checkpoint(journal);
1738                 mutex_unlock(&journal->j_checkpoint_mutex);
1739                 /*
1740                  * If checkpointing failed, just free the buffers to avoid
1741                  * looping forever
1742                  */
1743                 if (err) {
1744                         jbd2_journal_destroy_checkpoint(journal);
1745                         spin_lock(&journal->j_list_lock);
1746                         break;
1747                 }
1748                 spin_lock(&journal->j_list_lock);
1749         }
1750 
1751         J_ASSERT(journal->j_running_transaction == NULL);
1752         J_ASSERT(journal->j_committing_transaction == NULL);
1753         J_ASSERT(journal->j_checkpoint_transactions == NULL);
1754         spin_unlock(&journal->j_list_lock);
1755 
1756         if (journal->j_sb_buffer) {
1757                 if (!is_journal_aborted(journal)) {
1758                         mutex_lock_io(&journal->j_checkpoint_mutex);
1759 
1760                         write_lock(&journal->j_state_lock);
1761                         journal->j_tail_sequence =
1762                                 ++journal->j_transaction_sequence;
1763                         write_unlock(&journal->j_state_lock);
1764 
1765                         jbd2_mark_journal_empty(journal,
1766                                         REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
1767                         mutex_unlock(&journal->j_checkpoint_mutex);
1768                 } else
1769                         err = -EIO;
1770                 brelse(journal->j_sb_buffer);
1771         }
1772 
1773         if (journal->j_proc_entry)
1774                 jbd2_stats_proc_exit(journal);
1775         iput(journal->j_inode);
1776         if (journal->j_revoke)
1777                 jbd2_journal_destroy_revoke(journal);
1778         if (journal->j_chksum_driver)
1779                 crypto_free_shash(journal->j_chksum_driver);
1780         kfree(journal->j_wbuf);
1781         kfree(journal);
1782 
1783         return err;
1784 }
1785 
1786 
1787 /**
1788  *int jbd2_journal_check_used_features () - Check if features specified are used.
1789  * @journal: Journal to check.
1790  * @compat: bitmask of compatible features
1791  * @ro: bitmask of features that force read-only mount
1792  * @incompat: bitmask of incompatible features
1793  *
1794  * Check whether the journal uses all of a given set of
1795  * features.  Return true (non-zero) if it does.
1796  **/
1797 
1798 int jbd2_journal_check_used_features (journal_t *journal, unsigned long compat,
1799                                  unsigned long ro, unsigned long incompat)
1800 {
1801         journal_superblock_t *sb;
1802 
1803         if (!compat && !ro && !incompat)
1804                 return 1;
1805         /* Load journal superblock if it is not loaded yet. */
1806         if (journal->j_format_version == 0 &&
1807             journal_get_superblock(journal) != 0)
1808                 return 0;
1809         if (journal->j_format_version == 1)
1810                 return 0;
1811 
1812         sb = journal->j_superblock;
1813 
1814         if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
1815             ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
1816             ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
1817                 return 1;
1818 
1819         return 0;
1820 }
1821 
1822 /**
1823  * int jbd2_journal_check_available_features() - Check feature set in journalling layer
1824  * @journal: Journal to check.
1825  * @compat: bitmask of compatible features
1826  * @ro: bitmask of features that force read-only mount
1827  * @incompat: bitmask of incompatible features
1828  *
1829  * Check whether the journaling code supports the use of
1830  * all of a given set of features on this journal.  Return true
1831  * (non-zero) if it can. */
1832 
1833 int jbd2_journal_check_available_features (journal_t *journal, unsigned long compat,
1834                                       unsigned long ro, unsigned long incompat)
1835 {
1836         if (!compat && !ro && !incompat)
1837                 return 1;
1838 
1839         /* We can support any known requested features iff the
1840          * superblock is in version 2.  Otherwise we fail to support any
1841          * extended sb features. */
1842 
1843         if (journal->j_format_version != 2)
1844                 return 0;
1845 
1846         if ((compat   & JBD2_KNOWN_COMPAT_FEATURES) == compat &&
1847             (ro       & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro &&
1848             (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat)
1849                 return 1;
1850 
1851         return 0;
1852 }
1853 
1854 /**
1855  * int jbd2_journal_set_features () - Mark a given journal feature in the superblock
1856  * @journal: Journal to act on.
1857  * @compat: bitmask of compatible features
1858  * @ro: bitmask of features that force read-only mount
1859  * @incompat: bitmask of incompatible features
1860  *
1861  * Mark a given journal feature as present on the
1862  * superblock.  Returns true if the requested features could be set.
1863  *
1864  */
1865 
1866 int jbd2_journal_set_features (journal_t *journal, unsigned long compat,
1867                           unsigned long ro, unsigned long incompat)
1868 {
1869 #define INCOMPAT_FEATURE_ON(f) \
1870                 ((incompat & (f)) && !(sb->s_feature_incompat & cpu_to_be32(f)))
1871 #define COMPAT_FEATURE_ON(f) \
1872                 ((compat & (f)) && !(sb->s_feature_compat & cpu_to_be32(f)))
1873         journal_superblock_t *sb;
1874 
1875         if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
1876                 return 1;
1877 
1878         if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
1879                 return 0;
1880 
1881         /* If enabling v2 checksums, turn on v3 instead */
1882         if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V2) {
1883                 incompat &= ~JBD2_FEATURE_INCOMPAT_CSUM_V2;
1884                 incompat |= JBD2_FEATURE_INCOMPAT_CSUM_V3;
1885         }
1886 
1887         /* Asking for checksumming v3 and v1?  Only give them v3. */
1888         if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V3 &&
1889             compat & JBD2_FEATURE_COMPAT_CHECKSUM)
1890                 compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM;
1891 
1892         jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
1893                   compat, ro, incompat);
1894 
1895         sb = journal->j_superblock;
1896 
1897         /* If enabling v3 checksums, update superblock */
1898         if (INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) {
1899                 sb->s_checksum_type = JBD2_CRC32C_CHKSUM;
1900                 sb->s_feature_compat &=
1901                         ~cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM);
1902 
1903                 /* Load the checksum driver */
1904                 if (journal->j_chksum_driver == NULL) {
1905                         journal->j_chksum_driver = crypto_alloc_shash("crc32c",
1906                                                                       0, 0);
1907                         if (IS_ERR(journal->j_chksum_driver)) {
1908                                 printk(KERN_ERR "JBD2: Cannot load crc32c "
1909                                        "driver.\n");
1910                                 journal->j_chksum_driver = NULL;
1911                                 return 0;
1912                         }
1913 
1914                         /* Precompute checksum seed for all metadata */
1915                         journal->j_csum_seed = jbd2_chksum(journal, ~0,
1916                                                            sb->s_uuid,
1917                                                            sizeof(sb->s_uuid));
1918                 }
1919         }
1920 
1921         /* If enabling v1 checksums, downgrade superblock */
1922         if (COMPAT_FEATURE_ON(JBD2_FEATURE_COMPAT_CHECKSUM))
1923                 sb->s_feature_incompat &=
1924                         ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_CSUM_V2 |
1925                                      JBD2_FEATURE_INCOMPAT_CSUM_V3);
1926 
1927         sb->s_feature_compat    |= cpu_to_be32(compat);
1928         sb->s_feature_ro_compat |= cpu_to_be32(ro);
1929         sb->s_feature_incompat  |= cpu_to_be32(incompat);
1930 
1931         return 1;
1932 #undef COMPAT_FEATURE_ON
1933 #undef INCOMPAT_FEATURE_ON
1934 }
1935 
1936 /*
1937  * jbd2_journal_clear_features () - Clear a given journal feature in the
1938  *                                  superblock
1939  * @journal: Journal to act on.
1940  * @compat: bitmask of compatible features
1941  * @ro: bitmask of features that force read-only mount
1942  * @incompat: bitmask of incompatible features
1943  *
1944  * Clear a given journal feature as present on the
1945  * superblock.
1946  */
1947 void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
1948                                 unsigned long ro, unsigned long incompat)
1949 {
1950         journal_superblock_t *sb;
1951 
1952         jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
1953                   compat, ro, incompat);
1954 
1955         sb = journal->j_superblock;
1956 
1957         sb->s_feature_compat    &= ~cpu_to_be32(compat);
1958         sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
1959         sb->s_feature_incompat  &= ~cpu_to_be32(incompat);
1960 }
1961 EXPORT_SYMBOL(jbd2_journal_clear_features);
1962 
1963 /**
1964  * int jbd2_journal_flush () - Flush journal
1965  * @journal: Journal to act on.
1966  *
1967  * Flush all data for a given journal to disk and empty the journal.
1968  * Filesystems can use this when remounting readonly to ensure that
1969  * recovery does not need to happen on remount.
1970  */
1971 
1972 int jbd2_journal_flush(journal_t *journal)
1973 {
1974         int err = 0;
1975         transaction_t *transaction = NULL;
1976 
1977         write_lock(&journal->j_state_lock);
1978 
1979         /* Force everything buffered to the log... */
1980         if (journal->j_running_transaction) {
1981                 transaction = journal->j_running_transaction;
1982                 __jbd2_log_start_commit(journal, transaction->t_tid);
1983         } else if (journal->j_committing_transaction)
1984                 transaction = journal->j_committing_transaction;
1985 
1986         /* Wait for the log commit to complete... */
1987         if (transaction) {
1988                 tid_t tid = transaction->t_tid;
1989 
1990                 write_unlock(&journal->j_state_lock);
1991                 jbd2_log_wait_commit(journal, tid);
1992         } else {
1993                 write_unlock(&journal->j_state_lock);
1994         }
1995 
1996         /* ...and flush everything in the log out to disk. */
1997         spin_lock(&journal->j_list_lock);
1998         while (!err && journal->j_checkpoint_transactions != NULL) {
1999                 spin_unlock(&journal->j_list_lock);
2000                 mutex_lock_io(&journal->j_checkpoint_mutex);
2001                 err = jbd2_log_do_checkpoint(journal);
2002                 mutex_unlock(&journal->j_checkpoint_mutex);
2003                 spin_lock(&journal->j_list_lock);
2004         }
2005         spin_unlock(&journal->j_list_lock);
2006 
2007         if (is_journal_aborted(journal))
2008                 return -EIO;
2009 
2010         mutex_lock_io(&journal->j_checkpoint_mutex);
2011         if (!err) {
2012                 err = jbd2_cleanup_journal_tail(journal);
2013                 if (err < 0) {
2014                         mutex_unlock(&journal->j_checkpoint_mutex);
2015                         goto out;
2016                 }
2017                 err = 0;
2018         }
2019 
2020         /* Finally, mark the journal as really needing no recovery.
2021          * This sets s_start==0 in the underlying superblock, which is
2022          * the magic code for a fully-recovered superblock.  Any future
2023          * commits of data to the journal will restore the current
2024          * s_start value. */
2025         jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
2026         mutex_unlock(&journal->j_checkpoint_mutex);
2027         write_lock(&journal->j_state_lock);
2028         J_ASSERT(!journal->j_running_transaction);
2029         J_ASSERT(!journal->j_committing_transaction);
2030         J_ASSERT(!journal->j_checkpoint_transactions);
2031         J_ASSERT(journal->j_head == journal->j_tail);
2032         J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
2033         write_unlock(&journal->j_state_lock);
2034 out:
2035         return err;
2036 }
2037 
2038 /**
2039  * int jbd2_journal_wipe() - Wipe journal contents
2040  * @journal: Journal to act on.
2041  * @write: flag (see below)
2042  *
2043  * Wipe out all of the contents of a journal, safely.  This will produce
2044  * a warning if the journal contains any valid recovery information.
2045  * Must be called between journal_init_*() and jbd2_journal_load().
2046  *
2047  * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
2048  * we merely suppress recovery.
2049  */
2050 
2051 int jbd2_journal_wipe(journal_t *journal, int write)
2052 {
2053         int err = 0;
2054 
2055         J_ASSERT (!(journal->j_flags & JBD2_LOADED));
2056 
2057         err = load_superblock(journal);
2058         if (err)
2059                 return err;
2060 
2061         if (!journal->j_tail)
2062                 goto no_recovery;
2063 
2064         printk(KERN_WARNING "JBD2: %s recovery information on journal\n",
2065                 write ? "Clearing" : "Ignoring");
2066 
2067         err = jbd2_journal_skip_recovery(journal);
2068         if (write) {
2069                 /* Lock to make assertions happy... */
2070                 mutex_lock(&journal->j_checkpoint_mutex);
2071                 jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
2072                 mutex_unlock(&journal->j_checkpoint_mutex);
2073         }
2074 
2075  no_recovery:
2076         return err;
2077 }
2078 
2079 /*
2080  * Journal abort has very specific semantics, which we describe
2081  * for journal abort.
2082  *
2083  * Two internal functions, which provide abort to the jbd layer
2084  * itself are here.
2085  */
2086 
2087 /*
2088  * Quick version for internal journal use (doesn't lock the journal).
2089  * Aborts hard --- we mark the abort as occurred, but do _nothing_ else,
2090  * and don't attempt to make any other journal updates.
2091  */
2092 void __jbd2_journal_abort_hard(journal_t *journal)
2093 {
2094         transaction_t *transaction;
2095 
2096         if (journal->j_flags & JBD2_ABORT)
2097                 return;
2098 
2099         printk(KERN_ERR "Aborting journal on device %s.\n",
2100                journal->j_devname);
2101 
2102         write_lock(&journal->j_state_lock);
2103         journal->j_flags |= JBD2_ABORT;
2104         transaction = journal->j_running_transaction;
2105         if (transaction)
2106                 __jbd2_log_start_commit(journal, transaction->t_tid);
2107         write_unlock(&journal->j_state_lock);
2108 }
2109 
2110 /* Soft abort: record the abort error status in the journal superblock,
2111  * but don't do any other IO. */
2112 static void __journal_abort_soft (journal_t *journal, int errno)
2113 {
2114         int old_errno;
2115 
2116         write_lock(&journal->j_state_lock);
2117         old_errno = journal->j_errno;
2118         if (!journal->j_errno || errno == -ESHUTDOWN)
2119                 journal->j_errno = errno;
2120 
2121         if (journal->j_flags & JBD2_ABORT) {
2122                 write_unlock(&journal->j_state_lock);
2123                 if (!old_errno && old_errno != -ESHUTDOWN &&
2124                     errno == -ESHUTDOWN)
2125                         jbd2_journal_update_sb_errno(journal);
2126                 return;
2127         }
2128         write_unlock(&journal->j_state_lock);
2129 
2130         __jbd2_journal_abort_hard(journal);
2131 
2132         if (errno) {
2133                 jbd2_journal_update_sb_errno(journal);
2134                 write_lock(&journal->j_state_lock);
2135                 journal->j_flags |= JBD2_REC_ERR;
2136                 write_unlock(&journal->j_state_lock);
2137         }
2138 }
2139 
2140 /**
2141  * void jbd2_journal_abort () - Shutdown the journal immediately.
2142  * @journal: the journal to shutdown.
2143  * @errno:   an error number to record in the journal indicating
2144  *           the reason for the shutdown.
2145  *
2146  * Perform a complete, immediate shutdown of the ENTIRE
2147  * journal (not of a single transaction).  This operation cannot be
2148  * undone without closing and reopening the journal.
2149  *
2150  * The jbd2_journal_abort function is intended to support higher level error
2151  * recovery mechanisms such as the ext2/ext3 remount-readonly error
2152  * mode.
2153  *
2154  * Journal abort has very specific semantics.  Any existing dirty,
2155  * unjournaled buffers in the main filesystem will still be written to
2156  * disk by bdflush, but the journaling mechanism will be suspended
2157  * immediately and no further transaction commits will be honoured.
2158  *
2159  * Any dirty, journaled buffers will be written back to disk without
2160  * hitting the journal.  Atomicity cannot be guaranteed on an aborted
2161  * filesystem, but we _do_ attempt to leave as much data as possible
2162  * behind for fsck to use for cleanup.
2163  *
2164  * Any attempt to get a new transaction handle on a journal which is in
2165  * ABORT state will just result in an -EROFS error return.  A
2166  * jbd2_journal_stop on an existing handle will return -EIO if we have
2167  * entered abort state during the update.
2168  *
2169  * Recursive transactions are not disturbed by journal abort until the
2170  * final jbd2_journal_stop, which will receive the -EIO error.
2171  *
2172  * Finally, the jbd2_journal_abort call allows the caller to supply an errno
2173  * which will be recorded (if possible) in the journal superblock.  This
2174  * allows a client to record failure conditions in the middle of a
2175  * transaction without having to complete the transaction to record the
2176  * failure to disk.  ext3_error, for example, now uses this
2177  * functionality.
2178  *
2179  * Errors which originate from within the journaling layer will NOT
2180  * supply an errno; a null errno implies that absolutely no further
2181  * writes are done to the journal (unless there are any already in
2182  * progress).
2183  *
2184  */
2185 
2186 void jbd2_journal_abort(journal_t *journal, int errno)
2187 {
2188         __journal_abort_soft(journal, errno);
2189 }
2190 
2191 /**
2192  * int jbd2_journal_errno () - returns the journal's error state.
2193  * @journal: journal to examine.
2194  *
2195  * This is the errno number set with jbd2_journal_abort(), the last
2196  * time the journal was mounted - if the journal was stopped
2197  * without calling abort this will be 0.
2198  *
2199  * If the journal has been aborted on this mount time -EROFS will
2200  * be returned.
2201  */
2202 int jbd2_journal_errno(journal_t *journal)
2203 {
2204         int err;
2205 
2206         read_lock(&journal->j_state_lock);
2207         if (journal->j_flags & JBD2_ABORT)
2208                 err = -EROFS;
2209         else
2210                 err = journal->j_errno;
2211         read_unlock(&journal->j_state_lock);
2212         return err;
2213 }
2214 
2215 /**
2216  * int jbd2_journal_clear_err () - clears the journal's error state
2217  * @journal: journal to act on.
2218  *
2219  * An error must be cleared or acked to take a FS out of readonly
2220  * mode.
2221  */
2222 int jbd2_journal_clear_err(journal_t *journal)
2223 {
2224         int err = 0;
2225 
2226         write_lock(&journal->j_state_lock);
2227         if (journal->j_flags & JBD2_ABORT)
2228                 err = -EROFS;
2229         else
2230                 journal->j_errno = 0;
2231         write_unlock(&journal->j_state_lock);
2232         return err;
2233 }
2234 
2235 /**
2236  * void jbd2_journal_ack_err() - Ack journal err.
2237  * @journal: journal to act on.
2238  *
2239  * An error must be cleared or acked to take a FS out of readonly
2240  * mode.
2241  */
2242 void jbd2_journal_ack_err(journal_t *journal)
2243 {
2244         write_lock(&journal->j_state_lock);
2245         if (journal->j_errno)
2246                 journal->j_flags |= JBD2_ACK_ERR;
2247         write_unlock(&journal->j_state_lock);
2248 }
2249 
2250 int jbd2_journal_blocks_per_page(struct inode *inode)
2251 {
2252         return 1 << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
2253 }
2254 
2255 /*
2256  * helper functions to deal with 32 or 64bit block numbers.
2257  */
2258 size_t journal_tag_bytes(journal_t *journal)
2259 {
2260         size_t sz;
2261 
2262         if (jbd2_has_feature_csum3(journal))
2263                 return sizeof(journal_block_tag3_t);
2264 
2265         sz = sizeof(journal_block_tag_t);
2266 
2267         if (jbd2_has_feature_csum2(journal))
2268                 sz += sizeof(__u16);
2269 
2270         if (jbd2_has_feature_64bit(journal))
2271                 return sz;
2272         else
2273                 return sz - sizeof(__u32);
2274 }
2275 
2276 /*
2277  * JBD memory management
2278  *
2279  * These functions are used to allocate block-sized chunks of memory
2280  * used for making copies of buffer_head data.  Very often it will be
2281  * page-sized chunks of data, but sometimes it will be in
2282  * sub-page-size chunks.  (For example, 16k pages on Power systems
2283  * with a 4k block file system.)  For blocks smaller than a page, we
2284  * use a SLAB allocator.  There are slab caches for each block size,
2285  * which are allocated at mount time, if necessary, and we only free
2286  * (all of) the slab caches when/if the jbd2 module is unloaded.  For
2287  * this reason we don't need to a mutex to protect access to
2288  * jbd2_slab[] allocating or releasing memory; only in
2289  * jbd2_journal_create_slab().
2290  */
2291 #define JBD2_MAX_SLABS 8
2292 static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS];
2293 
2294 static const char *jbd2_slab_names[JBD2_MAX_SLABS] = {
2295         "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k",
2296         "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k"
2297 };
2298 
2299 
2300 static void jbd2_journal_destroy_slabs(void)
2301 {
2302         int i;
2303 
2304         for (i = 0; i < JBD2_MAX_SLABS; i++) {
2305                 kmem_cache_destroy(jbd2_slab[i]);
2306                 jbd2_slab[i] = NULL;
2307         }
2308 }
2309 
2310 static int jbd2_journal_create_slab(size_t size)
2311 {
2312         static DEFINE_MUTEX(jbd2_slab_create_mutex);
2313         int i = order_base_2(size) - 10;
2314         size_t slab_size;
2315 
2316         if (size == PAGE_SIZE)
2317                 return 0;
2318 
2319         if (i >= JBD2_MAX_SLABS)
2320                 return -EINVAL;
2321 
2322         if (unlikely(i < 0))
2323                 i = 0;
2324         mutex_lock(&jbd2_slab_create_mutex);
2325         if (jbd2_slab[i]) {
2326                 mutex_unlock(&jbd2_slab_create_mutex);
2327                 return 0;       /* Already created */
2328         }
2329 
2330         slab_size = 1 << (i+10);
2331         jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size,
2332                                          slab_size, 0, NULL);
2333         mutex_unlock(&jbd2_slab_create_mutex);
2334         if (!jbd2_slab[i]) {
2335                 printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n");
2336                 return -ENOMEM;
2337         }
2338         return 0;
2339 }
2340 
2341 static struct kmem_cache *get_slab(size_t size)
2342 {
2343         int i = order_base_2(size) - 10;
2344 
2345         BUG_ON(i >= JBD2_MAX_SLABS);
2346         if (unlikely(i < 0))
2347                 i = 0;
2348         BUG_ON(jbd2_slab[i] == NULL);
2349         return jbd2_slab[i];
2350 }
2351 
2352 void *jbd2_alloc(size_t size, gfp_t flags)
2353 {
2354         void *ptr;
2355 
2356         BUG_ON(size & (size-1)); /* Must be a power of 2 */
2357 
2358         if (size < PAGE_SIZE)
2359                 ptr = kmem_cache_alloc(get_slab(size), flags);
2360         else
2361                 ptr = (void *)__get_free_pages(flags, get_order(size));
2362 
2363         /* Check alignment; SLUB has gotten this wrong in the past,
2364          * and this can lead to user data corruption! */
2365         BUG_ON(((unsigned long) ptr) & (size-1));
2366 
2367         return ptr;
2368 }
2369 
2370 void jbd2_free(void *ptr, size_t size)
2371 {
2372         if (size < PAGE_SIZE)
2373                 kmem_cache_free(get_slab(size), ptr);
2374         else
2375                 free_pages((unsigned long)ptr, get_order(size));
2376 };
2377 
2378 /*
2379  * Journal_head storage management
2380  */
2381 static struct kmem_cache *jbd2_journal_head_cache;
2382 #ifdef CONFIG_JBD2_DEBUG
2383 static atomic_t nr_journal_heads = ATOMIC_INIT(0);
2384 #endif
2385 
2386 static int jbd2_journal_init_journal_head_cache(void)
2387 {
2388         int retval;
2389 
2390         J_ASSERT(jbd2_journal_head_cache == NULL);
2391         jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
2392                                 sizeof(struct journal_head),
2393                                 0,              /* offset */
2394                                 SLAB_TEMPORARY | SLAB_TYPESAFE_BY_RCU,
2395                                 NULL);          /* ctor */
2396         retval = 0;
2397         if (!jbd2_journal_head_cache) {
2398                 retval = -ENOMEM;
2399                 printk(KERN_EMERG "JBD2: no memory for journal_head cache\n");
2400         }
2401         return retval;
2402 }
2403 
2404 static void jbd2_journal_destroy_journal_head_cache(void)
2405 {
2406         kmem_cache_destroy(jbd2_journal_head_cache);
2407         jbd2_journal_head_cache = NULL;
2408 }
2409 
2410 /*
2411  * journal_head splicing and dicing
2412  */
2413 static struct journal_head *journal_alloc_journal_head(void)
2414 {
2415         struct journal_head *ret;
2416 
2417 #ifdef CONFIG_JBD2_DEBUG
2418         atomic_inc(&nr_journal_heads);
2419 #endif
2420         ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS);
2421         if (!ret) {
2422                 jbd_debug(1, "out of memory for journal_head\n");
2423                 pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__);
2424                 ret = kmem_cache_zalloc(jbd2_journal_head_cache,
2425                                 GFP_NOFS | __GFP_NOFAIL);
2426         }
2427         return ret;
2428 }
2429 
2430 static void journal_free_journal_head(struct journal_head *jh)
2431 {
2432 #ifdef CONFIG_JBD2_DEBUG
2433         atomic_dec(&nr_journal_heads);
2434         memset(jh, JBD2_POISON_FREE, sizeof(*jh));
2435 #endif
2436         kmem_cache_free(jbd2_journal_head_cache, jh);
2437 }
2438 
2439 /*
2440  * A journal_head is attached to a buffer_head whenever JBD has an
2441  * interest in the buffer.
2442  *
2443  * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
2444  * is set.  This bit is tested in core kernel code where we need to take
2445  * JBD-specific actions.  Testing the zeroness of ->b_private is not reliable
2446  * there.
2447  *
2448  * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
2449  *
2450  * When a buffer has its BH_JBD bit set it is immune from being released by
2451  * core kernel code, mainly via ->b_count.
2452  *
2453  * A journal_head is detached from its buffer_head when the journal_head's
2454  * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint
2455  * transaction (b_cp_transaction) hold their references to b_jcount.
2456  *
2457  * Various places in the kernel want to attach a journal_head to a buffer_head
2458  * _before_ attaching the journal_head to a transaction.  To protect the
2459  * journal_head in this situation, jbd2_journal_add_journal_head elevates the
2460  * journal_head's b_jcount refcount by one.  The caller must call
2461  * jbd2_journal_put_journal_head() to undo this.
2462  *
2463  * So the typical usage would be:
2464  *
2465  *      (Attach a journal_head if needed.  Increments b_jcount)
2466  *      struct journal_head *jh = jbd2_journal_add_journal_head(bh);
2467  *      ...
2468  *      (Get another reference for transaction)
2469  *      jbd2_journal_grab_journal_head(bh);
2470  *      jh->b_transaction = xxx;
2471  *      (Put original reference)
2472  *      jbd2_journal_put_journal_head(jh);
2473  */
2474 
2475 /*
2476  * Give a buffer_head a journal_head.
2477  *
2478  * May sleep.
2479  */
2480 struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh)
2481 {
2482         struct journal_head *jh;
2483         struct journal_head *new_jh = NULL;
2484 
2485 repeat:
2486         if (!buffer_jbd(bh))
2487                 new_jh = journal_alloc_journal_head();
2488 
2489         jbd_lock_bh_journal_head(bh);
2490         if (buffer_jbd(bh)) {
2491                 jh = bh2jh(bh);
2492         } else {
2493                 J_ASSERT_BH(bh,
2494                         (atomic_read(&bh->b_count) > 0) ||
2495                         (bh->b_page && bh->b_page->mapping));
2496 
2497                 if (!new_jh) {
2498                         jbd_unlock_bh_journal_head(bh);
2499                         goto repeat;
2500                 }
2501 
2502                 jh = new_jh;
2503                 new_jh = NULL;          /* We consumed it */
2504                 set_buffer_jbd(bh);
2505                 bh->b_private = jh;
2506                 jh->b_bh = bh;
2507                 get_bh(bh);
2508                 BUFFER_TRACE(bh, "added journal_head");
2509         }
2510         jh->b_jcount++;
2511         jbd_unlock_bh_journal_head(bh);
2512         if (new_jh)
2513                 journal_free_journal_head(new_jh);
2514         return bh->b_private;
2515 }
2516 
2517 /*
2518  * Grab a ref against this buffer_head's journal_head.  If it ended up not
2519  * having a journal_head, return NULL
2520  */
2521 struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh)
2522 {
2523         struct journal_head *jh = NULL;
2524 
2525         jbd_lock_bh_journal_head(bh);
2526         if (buffer_jbd(bh)) {
2527                 jh = bh2jh(bh);
2528                 jh->b_jcount++;
2529         }
2530         jbd_unlock_bh_journal_head(bh);
2531         return jh;
2532 }
2533 
2534 static void __journal_remove_journal_head(struct buffer_head *bh)
2535 {
2536         struct journal_head *jh = bh2jh(bh);
2537 
2538         J_ASSERT_JH(jh, jh->b_jcount >= 0);
2539         J_ASSERT_JH(jh, jh->b_transaction == NULL);
2540         J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2541         J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
2542         J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
2543         J_ASSERT_BH(bh, buffer_jbd(bh));
2544         J_ASSERT_BH(bh, jh2bh(jh) == bh);
2545         BUFFER_TRACE(bh, "remove journal_head");
2546         if (jh->b_frozen_data) {
2547                 printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
2548                 jbd2_free(jh->b_frozen_data, bh->b_size);
2549         }
2550         if (jh->b_committed_data) {
2551                 printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
2552                 jbd2_free(jh->b_committed_data, bh->b_size);
2553         }
2554         bh->b_private = NULL;
2555         jh->b_bh = NULL;        /* debug, really */
2556         clear_buffer_jbd(bh);
2557         journal_free_journal_head(jh);
2558 }
2559 
2560 /*
2561  * Drop a reference on the passed journal_head.  If it fell to zero then
2562  * release the journal_head from the buffer_head.
2563  */
2564 void jbd2_journal_put_journal_head(struct journal_head *jh)
2565 {
2566         struct buffer_head *bh = jh2bh(jh);
2567 
2568         jbd_lock_bh_journal_head(bh);
2569         J_ASSERT_JH(jh, jh->b_jcount > 0);
2570         --jh->b_jcount;
2571         if (!jh->b_jcount) {
2572                 __journal_remove_journal_head(bh);
2573                 jbd_unlock_bh_journal_head(bh);
2574                 __brelse(bh);
2575         } else
2576                 jbd_unlock_bh_journal_head(bh);
2577 }
2578 
2579 /*
2580  * Initialize jbd inode head
2581  */
2582 void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode)
2583 {
2584         jinode->i_transaction = NULL;
2585         jinode->i_next_transaction = NULL;
2586         jinode->i_vfs_inode = inode;
2587         jinode->i_flags = 0;
2588         INIT_LIST_HEAD(&jinode->i_list);
2589 }
2590 
2591 /*
2592  * Function to be called before we start removing inode from memory (i.e.,
2593  * clear_inode() is a fine place to be called from). It removes inode from
2594  * transaction's lists.
2595  */
2596 void jbd2_journal_release_jbd_inode(journal_t *journal,
2597                                     struct jbd2_inode *jinode)
2598 {
2599         if (!journal)
2600                 return;
2601 restart:
2602         spin_lock(&journal->j_list_lock);
2603         /* Is commit writing out inode - we have to wait */
2604         if (jinode->i_flags & JI_COMMIT_RUNNING) {
2605                 wait_queue_head_t *wq;
2606                 DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
2607                 wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
2608                 prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
2609                 spin_unlock(&journal->j_list_lock);
2610                 schedule();
2611                 finish_wait(wq, &wait.wq_entry);
2612                 goto restart;
2613         }
2614 
2615         if (jinode->i_transaction) {
2616                 list_del(&jinode->i_list);
2617                 jinode->i_transaction = NULL;
2618         }
2619         spin_unlock(&journal->j_list_lock);
2620 }
2621 
2622 
2623 #ifdef CONFIG_PROC_FS
2624 
2625 #define JBD2_STATS_PROC_NAME "fs/jbd2"
2626 
2627 static void __init jbd2_create_jbd_stats_proc_entry(void)
2628 {
2629         proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL);
2630 }
2631 
2632 static void __exit jbd2_remove_jbd_stats_proc_entry(void)
2633 {
2634         if (proc_jbd2_stats)
2635                 remove_proc_entry(JBD2_STATS_PROC_NAME, NULL);
2636 }
2637 
2638 #else
2639 
2640 #define jbd2_create_jbd_stats_proc_entry() do {} while (0)
2641 #define jbd2_remove_jbd_stats_proc_entry() do {} while (0)
2642 
2643 #endif
2644 
2645 struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache;
2646 
2647 static int __init jbd2_journal_init_handle_cache(void)
2648 {
2649         jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY);
2650         if (jbd2_handle_cache == NULL) {
2651                 printk(KERN_EMERG "JBD2: failed to create handle cache\n");
2652                 return -ENOMEM;
2653         }
2654         jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0);
2655         if (jbd2_inode_cache == NULL) {
2656                 printk(KERN_EMERG "JBD2: failed to create inode cache\n");
2657                 kmem_cache_destroy(jbd2_handle_cache);
2658                 return -ENOMEM;
2659         }
2660         return 0;
2661 }
2662 
2663 static void jbd2_journal_destroy_handle_cache(void)
2664 {
2665         kmem_cache_destroy(jbd2_handle_cache);
2666         jbd2_handle_cache = NULL;
2667         kmem_cache_destroy(jbd2_inode_cache);
2668         jbd2_inode_cache = NULL;
2669 }
2670 
2671 /*
2672  * Module startup and shutdown
2673  */
2674 
2675 static int __init journal_init_caches(void)
2676 {
2677         int ret;
2678 
2679         ret = jbd2_journal_init_revoke_caches();
2680         if (ret == 0)
2681                 ret = jbd2_journal_init_journal_head_cache();
2682         if (ret == 0)
2683                 ret = jbd2_journal_init_handle_cache();
2684         if (ret == 0)
2685                 ret = jbd2_journal_init_transaction_cache();
2686         return ret;
2687 }
2688 
2689 static void jbd2_journal_destroy_caches(void)
2690 {
2691         jbd2_journal_destroy_revoke_caches();
2692         jbd2_journal_destroy_journal_head_cache();
2693         jbd2_journal_destroy_handle_cache();
2694         jbd2_journal_destroy_transaction_cache();
2695         jbd2_journal_destroy_slabs();
2696 }
2697 
2698 static int __init journal_init(void)
2699 {
2700         int ret;
2701 
2702         BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
2703 
2704         ret = journal_init_caches();
2705         if (ret == 0) {
2706                 jbd2_create_jbd_stats_proc_entry();
2707         } else {
2708                 jbd2_journal_destroy_caches();
2709         }
2710         return ret;
2711 }
2712 
2713 static void __exit journal_exit(void)
2714 {
2715 #ifdef CONFIG_JBD2_DEBUG
2716         int n = atomic_read(&nr_journal_heads);
2717         if (n)
2718                 printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n);
2719 #endif
2720         jbd2_remove_jbd_stats_proc_entry();
2721         jbd2_journal_destroy_caches();
2722 }
2723 
2724 MODULE_LICENSE("GPL");
2725 module_init(journal_init);
2726 module_exit(journal_exit);
2727 
2728 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp