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