linux/fs/reiserfs/journal.c
<<
>>
Prefs
   1/*
   2** Write ahead logging implementation copyright Chris Mason 2000
   3**
   4** The background commits make this code very interrelated, and
   5** overly complex.  I need to rethink things a bit....The major players:
   6**
   7** journal_begin -- call with the number of blocks you expect to log.
   8**                  If the current transaction is too
   9**                  old, it will block until the current transaction is
  10**                  finished, and then start a new one.
  11**                  Usually, your transaction will get joined in with
  12**                  previous ones for speed.
  13**
  14** journal_join  -- same as journal_begin, but won't block on the current
  15**                  transaction regardless of age.  Don't ever call
  16**                  this.  Ever.  There are only two places it should be
  17**                  called from, and they are both inside this file.
  18**
  19** journal_mark_dirty -- adds blocks into this transaction.  clears any flags
  20**                       that might make them get sent to disk
  21**                       and then marks them BH_JDirty.  Puts the buffer head
  22**                       into the current transaction hash.
  23**
  24** journal_end -- if the current transaction is batchable, it does nothing
  25**                   otherwise, it could do an async/synchronous commit, or
  26**                   a full flush of all log and real blocks in the
  27**                   transaction.
  28**
  29** flush_old_commits -- if the current transaction is too old, it is ended and
  30**                      commit blocks are sent to disk.  Forces commit blocks
  31**                      to disk for all backgrounded commits that have been
  32**                      around too long.
  33**                   -- Note, if you call this as an immediate flush from
  34**                      from within kupdate, it will ignore the immediate flag
  35*/
  36
  37#include <linux/time.h>
  38#include <linux/semaphore.h>
  39#include <linux/vmalloc.h>
  40#include "reiserfs.h"
  41#include <linux/kernel.h>
  42#include <linux/errno.h>
  43#include <linux/fcntl.h>
  44#include <linux/stat.h>
  45#include <linux/string.h>
  46#include <linux/buffer_head.h>
  47#include <linux/workqueue.h>
  48#include <linux/writeback.h>
  49#include <linux/blkdev.h>
  50#include <linux/backing-dev.h>
  51#include <linux/uaccess.h>
  52#include <linux/slab.h>
  53
  54
  55/* gets a struct reiserfs_journal_list * from a list head */
  56#define JOURNAL_LIST_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \
  57                               j_list))
  58#define JOURNAL_WORK_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \
  59                               j_working_list))
  60
  61/* the number of mounted filesystems.  This is used to decide when to
  62** start and kill the commit workqueue
  63*/
  64static int reiserfs_mounted_fs_count;
  65
  66static struct workqueue_struct *commit_wq;
  67
  68#define JOURNAL_TRANS_HALF 1018 /* must be correct to keep the desc and commit
  69                                   structs at 4k */
  70#define BUFNR 64                /*read ahead */
  71
  72/* cnode stat bits.  Move these into reiserfs_fs.h */
  73
  74#define BLOCK_FREED 2           /* this block was freed, and can't be written.  */
  75#define BLOCK_FREED_HOLDER 3    /* this block was freed during this transaction, and can't be written */
  76
  77#define BLOCK_NEEDS_FLUSH 4     /* used in flush_journal_list */
  78#define BLOCK_DIRTIED 5
  79
  80/* journal list state bits */
  81#define LIST_TOUCHED 1
  82#define LIST_DIRTY   2
  83#define LIST_COMMIT_PENDING  4  /* someone will commit this list */
  84
  85/* flags for do_journal_end */
  86#define FLUSH_ALL   1           /* flush commit and real blocks */
  87#define COMMIT_NOW  2           /* end and commit this transaction */
  88#define WAIT        4           /* wait for the log blocks to hit the disk */
  89
  90static int do_journal_end(struct reiserfs_transaction_handle *,
  91                          struct super_block *, unsigned long nblocks,
  92                          int flags);
  93static int flush_journal_list(struct super_block *s,
  94                              struct reiserfs_journal_list *jl, int flushall);
  95static int flush_commit_list(struct super_block *s,
  96                             struct reiserfs_journal_list *jl, int flushall);
  97static int can_dirty(struct reiserfs_journal_cnode *cn);
  98static int journal_join(struct reiserfs_transaction_handle *th,
  99                        struct super_block *sb, unsigned long nblocks);
 100static int release_journal_dev(struct super_block *super,
 101                               struct reiserfs_journal *journal);
 102static int dirty_one_transaction(struct super_block *s,
 103                                 struct reiserfs_journal_list *jl);
 104static void flush_async_commits(struct work_struct *work);
 105static void queue_log_writer(struct super_block *s);
 106
 107/* values for join in do_journal_begin_r */
 108enum {
 109        JBEGIN_REG = 0,         /* regular journal begin */
 110        JBEGIN_JOIN = 1,        /* join the running transaction if at all possible */
 111        JBEGIN_ABORT = 2,       /* called from cleanup code, ignores aborted flag */
 112};
 113
 114static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
 115                              struct super_block *sb,
 116                              unsigned long nblocks, int join);
 117
 118static void init_journal_hash(struct super_block *sb)
 119{
 120        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 121        memset(journal->j_hash_table, 0,
 122               JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *));
 123}
 124
 125/*
 126** clears BH_Dirty and sticks the buffer on the clean list.  Called because I can't allow refile_buffer to
 127** make schedule happen after I've freed a block.  Look at remove_from_transaction and journal_mark_freed for
 128** more details.
 129*/
 130static int reiserfs_clean_and_file_buffer(struct buffer_head *bh)
 131{
 132        if (bh) {
 133                clear_buffer_dirty(bh);
 134                clear_buffer_journal_test(bh);
 135        }
 136        return 0;
 137}
 138
 139static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block
 140                                                         *sb)
 141{
 142        struct reiserfs_bitmap_node *bn;
 143        static int id;
 144
 145        bn = kmalloc(sizeof(struct reiserfs_bitmap_node), GFP_NOFS);
 146        if (!bn) {
 147                return NULL;
 148        }
 149        bn->data = kzalloc(sb->s_blocksize, GFP_NOFS);
 150        if (!bn->data) {
 151                kfree(bn);
 152                return NULL;
 153        }
 154        bn->id = id++;
 155        INIT_LIST_HEAD(&bn->list);
 156        return bn;
 157}
 158
 159static struct reiserfs_bitmap_node *get_bitmap_node(struct super_block *sb)
 160{
 161        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 162        struct reiserfs_bitmap_node *bn = NULL;
 163        struct list_head *entry = journal->j_bitmap_nodes.next;
 164
 165        journal->j_used_bitmap_nodes++;
 166      repeat:
 167
 168        if (entry != &journal->j_bitmap_nodes) {
 169                bn = list_entry(entry, struct reiserfs_bitmap_node, list);
 170                list_del(entry);
 171                memset(bn->data, 0, sb->s_blocksize);
 172                journal->j_free_bitmap_nodes--;
 173                return bn;
 174        }
 175        bn = allocate_bitmap_node(sb);
 176        if (!bn) {
 177                yield();
 178                goto repeat;
 179        }
 180        return bn;
 181}
 182static inline void free_bitmap_node(struct super_block *sb,
 183                                    struct reiserfs_bitmap_node *bn)
 184{
 185        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 186        journal->j_used_bitmap_nodes--;
 187        if (journal->j_free_bitmap_nodes > REISERFS_MAX_BITMAP_NODES) {
 188                kfree(bn->data);
 189                kfree(bn);
 190        } else {
 191                list_add(&bn->list, &journal->j_bitmap_nodes);
 192                journal->j_free_bitmap_nodes++;
 193        }
 194}
 195
 196static void allocate_bitmap_nodes(struct super_block *sb)
 197{
 198        int i;
 199        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 200        struct reiserfs_bitmap_node *bn = NULL;
 201        for (i = 0; i < REISERFS_MIN_BITMAP_NODES; i++) {
 202                bn = allocate_bitmap_node(sb);
 203                if (bn) {
 204                        list_add(&bn->list, &journal->j_bitmap_nodes);
 205                        journal->j_free_bitmap_nodes++;
 206                } else {
 207                        break;  /* this is ok, we'll try again when more are needed */
 208                }
 209        }
 210}
 211
 212static int set_bit_in_list_bitmap(struct super_block *sb,
 213                                  b_blocknr_t block,
 214                                  struct reiserfs_list_bitmap *jb)
 215{
 216        unsigned int bmap_nr = block / (sb->s_blocksize << 3);
 217        unsigned int bit_nr = block % (sb->s_blocksize << 3);
 218
 219        if (!jb->bitmaps[bmap_nr]) {
 220                jb->bitmaps[bmap_nr] = get_bitmap_node(sb);
 221        }
 222        set_bit(bit_nr, (unsigned long *)jb->bitmaps[bmap_nr]->data);
 223        return 0;
 224}
 225
 226static void cleanup_bitmap_list(struct super_block *sb,
 227                                struct reiserfs_list_bitmap *jb)
 228{
 229        int i;
 230        if (jb->bitmaps == NULL)
 231                return;
 232
 233        for (i = 0; i < reiserfs_bmap_count(sb); i++) {
 234                if (jb->bitmaps[i]) {
 235                        free_bitmap_node(sb, jb->bitmaps[i]);
 236                        jb->bitmaps[i] = NULL;
 237                }
 238        }
 239}
 240
 241/*
 242** only call this on FS unmount.
 243*/
 244static int free_list_bitmaps(struct super_block *sb,
 245                             struct reiserfs_list_bitmap *jb_array)
 246{
 247        int i;
 248        struct reiserfs_list_bitmap *jb;
 249        for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
 250                jb = jb_array + i;
 251                jb->journal_list = NULL;
 252                cleanup_bitmap_list(sb, jb);
 253                vfree(jb->bitmaps);
 254                jb->bitmaps = NULL;
 255        }
 256        return 0;
 257}
 258
 259static int free_bitmap_nodes(struct super_block *sb)
 260{
 261        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 262        struct list_head *next = journal->j_bitmap_nodes.next;
 263        struct reiserfs_bitmap_node *bn;
 264
 265        while (next != &journal->j_bitmap_nodes) {
 266                bn = list_entry(next, struct reiserfs_bitmap_node, list);
 267                list_del(next);
 268                kfree(bn->data);
 269                kfree(bn);
 270                next = journal->j_bitmap_nodes.next;
 271                journal->j_free_bitmap_nodes--;
 272        }
 273
 274        return 0;
 275}
 276
 277/*
 278** get memory for JOURNAL_NUM_BITMAPS worth of bitmaps.
 279** jb_array is the array to be filled in.
 280*/
 281int reiserfs_allocate_list_bitmaps(struct super_block *sb,
 282                                   struct reiserfs_list_bitmap *jb_array,
 283                                   unsigned int bmap_nr)
 284{
 285        int i;
 286        int failed = 0;
 287        struct reiserfs_list_bitmap *jb;
 288        int mem = bmap_nr * sizeof(struct reiserfs_bitmap_node *);
 289
 290        for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
 291                jb = jb_array + i;
 292                jb->journal_list = NULL;
 293                jb->bitmaps = vzalloc(mem);
 294                if (!jb->bitmaps) {
 295                        reiserfs_warning(sb, "clm-2000", "unable to "
 296                                         "allocate bitmaps for journal lists");
 297                        failed = 1;
 298                        break;
 299                }
 300        }
 301        if (failed) {
 302                free_list_bitmaps(sb, jb_array);
 303                return -1;
 304        }
 305        return 0;
 306}
 307
 308/*
 309** find an available list bitmap.  If you can't find one, flush a commit list
 310** and try again
 311*/
 312static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *sb,
 313                                                    struct reiserfs_journal_list
 314                                                    *jl)
 315{
 316        int i, j;
 317        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 318        struct reiserfs_list_bitmap *jb = NULL;
 319
 320        for (j = 0; j < (JOURNAL_NUM_BITMAPS * 3); j++) {
 321                i = journal->j_list_bitmap_index;
 322                journal->j_list_bitmap_index = (i + 1) % JOURNAL_NUM_BITMAPS;
 323                jb = journal->j_list_bitmap + i;
 324                if (journal->j_list_bitmap[i].journal_list) {
 325                        flush_commit_list(sb,
 326                                          journal->j_list_bitmap[i].
 327                                          journal_list, 1);
 328                        if (!journal->j_list_bitmap[i].journal_list) {
 329                                break;
 330                        }
 331                } else {
 332                        break;
 333                }
 334        }
 335        if (jb->journal_list) { /* double check to make sure if flushed correctly */
 336                return NULL;
 337        }
 338        jb->journal_list = jl;
 339        return jb;
 340}
 341
 342/*
 343** allocates a new chunk of X nodes, and links them all together as a list.
 344** Uses the cnode->next and cnode->prev pointers
 345** returns NULL on failure
 346*/
 347static struct reiserfs_journal_cnode *allocate_cnodes(int num_cnodes)
 348{
 349        struct reiserfs_journal_cnode *head;
 350        int i;
 351        if (num_cnodes <= 0) {
 352                return NULL;
 353        }
 354        head = vzalloc(num_cnodes * sizeof(struct reiserfs_journal_cnode));
 355        if (!head) {
 356                return NULL;
 357        }
 358        head[0].prev = NULL;
 359        head[0].next = head + 1;
 360        for (i = 1; i < num_cnodes; i++) {
 361                head[i].prev = head + (i - 1);
 362                head[i].next = head + (i + 1);  /* if last one, overwrite it after the if */
 363        }
 364        head[num_cnodes - 1].next = NULL;
 365        return head;
 366}
 367
 368/*
 369** pulls a cnode off the free list, or returns NULL on failure
 370*/
 371static struct reiserfs_journal_cnode *get_cnode(struct super_block *sb)
 372{
 373        struct reiserfs_journal_cnode *cn;
 374        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 375
 376        reiserfs_check_lock_depth(sb, "get_cnode");
 377
 378        if (journal->j_cnode_free <= 0) {
 379                return NULL;
 380        }
 381        journal->j_cnode_used++;
 382        journal->j_cnode_free--;
 383        cn = journal->j_cnode_free_list;
 384        if (!cn) {
 385                return cn;
 386        }
 387        if (cn->next) {
 388                cn->next->prev = NULL;
 389        }
 390        journal->j_cnode_free_list = cn->next;
 391        memset(cn, 0, sizeof(struct reiserfs_journal_cnode));
 392        return cn;
 393}
 394
 395/*
 396** returns a cnode to the free list
 397*/
 398static void free_cnode(struct super_block *sb,
 399                       struct reiserfs_journal_cnode *cn)
 400{
 401        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 402
 403        reiserfs_check_lock_depth(sb, "free_cnode");
 404
 405        journal->j_cnode_used--;
 406        journal->j_cnode_free++;
 407        /* memset(cn, 0, sizeof(struct reiserfs_journal_cnode)) ; */
 408        cn->next = journal->j_cnode_free_list;
 409        if (journal->j_cnode_free_list) {
 410                journal->j_cnode_free_list->prev = cn;
 411        }
 412        cn->prev = NULL;        /* not needed with the memset, but I might kill the memset, and forget to do this */
 413        journal->j_cnode_free_list = cn;
 414}
 415
 416static void clear_prepared_bits(struct buffer_head *bh)
 417{
 418        clear_buffer_journal_prepared(bh);
 419        clear_buffer_journal_restore_dirty(bh);
 420}
 421
 422/* return a cnode with same dev, block number and size in table, or null if not found */
 423static inline struct reiserfs_journal_cnode *get_journal_hash_dev(struct
 424                                                                  super_block
 425                                                                  *sb,
 426                                                                  struct
 427                                                                  reiserfs_journal_cnode
 428                                                                  **table,
 429                                                                  long bl)
 430{
 431        struct reiserfs_journal_cnode *cn;
 432        cn = journal_hash(table, sb, bl);
 433        while (cn) {
 434                if (cn->blocknr == bl && cn->sb == sb)
 435                        return cn;
 436                cn = cn->hnext;
 437        }
 438        return (struct reiserfs_journal_cnode *)0;
 439}
 440
 441/*
 442** this actually means 'can this block be reallocated yet?'.  If you set search_all, a block can only be allocated
 443** if it is not in the current transaction, was not freed by the current transaction, and has no chance of ever
 444** being overwritten by a replay after crashing.
 445**
 446** If you don't set search_all, a block can only be allocated if it is not in the current transaction.  Since deleting
 447** a block removes it from the current transaction, this case should never happen.  If you don't set search_all, make
 448** sure you never write the block without logging it.
 449**
 450** next_zero_bit is a suggestion about the next block to try for find_forward.
 451** when bl is rejected because it is set in a journal list bitmap, we search
 452** for the next zero bit in the bitmap that rejected bl.  Then, we return that
 453** through next_zero_bit for find_forward to try.
 454**
 455** Just because we return something in next_zero_bit does not mean we won't
 456** reject it on the next call to reiserfs_in_journal
 457**
 458*/
 459int reiserfs_in_journal(struct super_block *sb,
 460                        unsigned int bmap_nr, int bit_nr, int search_all,
 461                        b_blocknr_t * next_zero_bit)
 462{
 463        struct reiserfs_journal *journal = SB_JOURNAL(sb);
 464        struct reiserfs_journal_cnode *cn;
 465        struct reiserfs_list_bitmap *jb;
 466        int i;
 467        unsigned long bl;
 468
 469        *next_zero_bit = 0;     /* always start this at zero. */
 470
 471        PROC_INFO_INC(sb, journal.in_journal);
 472        /* If we aren't doing a search_all, this is a metablock, and it will be logged before use.
 473         ** if we crash before the transaction that freed it commits,  this transaction won't
 474         ** have committed either, and the block will never be written
 475         */
 476        if (search_all) {
 477                for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
 478                        PROC_INFO_INC(sb, journal.in_journal_bitmap);
 479                        jb = journal->j_list_bitmap + i;
 480                        if (jb->journal_list && jb->bitmaps[bmap_nr] &&
 481                            test_bit(bit_nr,
 482                                     (unsigned long *)jb->bitmaps[bmap_nr]->
 483                                     data)) {
 484                                *next_zero_bit =
 485                                    find_next_zero_bit((unsigned long *)
 486                                                       (jb->bitmaps[bmap_nr]->
 487                                                        data),
 488                                                       sb->s_blocksize << 3,
 489                                                       bit_nr + 1);
 490                                return 1;
 491                        }
 492                }
 493        }
 494
 495        bl = bmap_nr * (sb->s_blocksize << 3) + bit_nr;
 496        /* is it in any old transactions? */
 497        if (search_all
 498            && (cn =
 499                get_journal_hash_dev(sb, journal->j_list_hash_table, bl))) {
 500                return 1;
 501        }
 502
 503        /* is it in the current transaction.  This should never happen */
 504        if ((cn = get_journal_hash_dev(sb, journal->j_hash_table, bl))) {
 505                BUG();
 506                return 1;
 507        }
 508
 509        PROC_INFO_INC(sb, journal.in_journal_reusable);
 510        /* safe for reuse */
 511        return 0;
 512}
 513
 514/* insert cn into table
 515*/
 516static inline void insert_journal_hash(struct reiserfs_journal_cnode **table,
 517                                       struct reiserfs_journal_cnode *cn)
 518{
 519        struct reiserfs_journal_cnode *cn_orig;
 520
 521        cn_orig = journal_hash(table, cn->sb, cn->blocknr);
 522        cn->hnext = cn_orig;
 523        cn->hprev = NULL;
 524        if (cn_orig) {
 525                cn_orig->hprev = cn;
 526        }
 527        journal_hash(table, cn->sb, cn->blocknr) = cn;
 528}
 529
 530/* lock the current transaction */
 531static inline void lock_journal(struct super_block *sb)
 532{
 533        PROC_INFO_INC(sb, journal.lock_journal);
 534
 535        reiserfs_mutex_lock_safe(&SB_JOURNAL(sb)->j_mutex, sb);
 536}
 537
 538/* unlock the current transaction */
 539static inline void unlock_journal(struct super_block *sb)
 540{
 541        mutex_unlock(&SB_JOURNAL(sb)->j_mutex);
 542}
 543
 544static inline void get_journal_list(struct reiserfs_journal_list *jl)
 545{
 546        jl->j_refcount++;
 547}
 548
 549static inline void put_journal_list(struct super_block *s,
 550                                    struct reiserfs_journal_list *jl)
 551{
 552        if (jl->j_refcount < 1) {
 553                reiserfs_panic(s, "journal-2", "trans id %u, refcount at %d",
 554                               jl->j_trans_id, jl->j_refcount);
 555        }
 556        if (--jl->j_refcount == 0)
 557                kfree(jl);
 558}
 559
 560/*
 561** this used to be much more involved, and I'm keeping it just in case things get ugly again.
 562** it gets called by flush_commit_list, and cleans up any data stored about blocks freed during a
 563** transaction.
 564*/
 565static void cleanup_freed_for_journal_list(struct super_block *sb,
 566                                           struct reiserfs_journal_list *jl)
 567{
 568
 569        struct reiserfs_list_bitmap *jb = jl->j_list_bitmap;
 570        if (jb) {
 571                cleanup_bitmap_list(sb, jb);
 572        }
 573        jl->j_list_bitmap->journal_list = NULL;
 574        jl->j_list_bitmap = NULL;
 575}
 576
 577static int journal_list_still_alive(struct super_block *s,
 578                                    unsigned int trans_id)
 579{
 580        struct reiserfs_journal *journal = SB_JOURNAL(s);
 581        struct list_head *entry = &journal->j_journal_list;
 582        struct reiserfs_journal_list *jl;
 583
 584        if (!list_empty(entry)) {
 585                jl = JOURNAL_LIST_ENTRY(entry->next);
 586                if (jl->j_trans_id <= trans_id) {
 587                        return 1;
 588                }
 589        }
 590        return 0;
 591}
 592
 593/*
 594 * If page->mapping was null, we failed to truncate this page for
 595 * some reason.  Most likely because it was truncated after being
 596 * logged via data=journal.
 597 *
 598 * This does a check to see if the buffer belongs to one of these
 599 * lost pages before doing the final put_bh.  If page->mapping was
 600 * null, it tries to free buffers on the page, which should make the
 601 * final page_cache_release drop the page from the lru.
 602 */
 603static void release_buffer_page(struct buffer_head *bh)
 604{
 605        struct page *page = bh->b_page;
 606        if (!page->mapping && trylock_page(page)) {
 607                page_cache_get(page);
 608                put_bh(bh);
 609                if (!page->mapping)
 610                        try_to_free_buffers(page);
 611                unlock_page(page);
 612                page_cache_release(page);
 613        } else {
 614                put_bh(bh);
 615        }
 616}
 617
 618static void reiserfs_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
 619{
 620        char b[BDEVNAME_SIZE];
 621
 622        if (buffer_journaled(bh)) {
 623                reiserfs_warning(NULL, "clm-2084",
 624                                 "pinned buffer %lu:%s sent to disk",
 625                                 bh->b_blocknr, bdevname(bh->b_bdev, b));
 626        }
 627        if (uptodate)
 628                set_buffer_uptodate(bh);
 629        else
 630                clear_buffer_uptodate(bh);
 631
 632        unlock_buffer(bh);
 633        release_buffer_page(bh);
 634}
 635
 636static void reiserfs_end_ordered_io(struct buffer_head *bh, int uptodate)
 637{
 638        if (uptodate)
 639                set_buffer_uptodate(bh);
 640        else
 641                clear_buffer_uptodate(bh);
 642        unlock_buffer(bh);
 643        put_bh(bh);
 644}
 645
 646static void submit_logged_buffer(struct buffer_head *bh)
 647{
 648        get_bh(bh);
 649        bh->b_end_io = reiserfs_end_buffer_io_sync;
 650        clear_buffer_journal_new(bh);
 651        clear_buffer_dirty(bh);
 652        if (!test_clear_buffer_journal_test(bh))
 653                BUG();
 654        if (!buffer_uptodate(bh))
 655                BUG();
 656        submit_bh(WRITE, bh);
 657}
 658
 659static void submit_ordered_buffer(struct buffer_head *bh)
 660{
 661        get_bh(bh);
 662        bh->b_end_io = reiserfs_end_ordered_io;
 663        clear_buffer_dirty(bh);
 664        if (!buffer_uptodate(bh))
 665                BUG();
 666        submit_bh(WRITE, bh);
 667}
 668
 669#define CHUNK_SIZE 32
 670struct buffer_chunk {
 671        struct buffer_head *bh[CHUNK_SIZE];
 672        int nr;
 673};
 674
 675static void write_chunk(struct buffer_chunk *chunk)
 676{
 677        int i;
 678        for (i = 0; i < chunk->nr; i++) {
 679                submit_logged_buffer(chunk->bh[i]);
 680        }
 681        chunk->nr = 0;
 682}
 683
 684static void write_ordered_chunk(struct buffer_chunk *chunk)
 685{
 686        int i;
 687        for (i = 0; i < chunk->nr; i++) {
 688                submit_ordered_buffer(chunk->bh[i]);
 689        }
 690        chunk->nr = 0;
 691}
 692
 693static int add_to_chunk(struct buffer_chunk *chunk, struct buffer_head *bh,
 694                        spinlock_t * lock, void (fn) (struct buffer_chunk *))
 695{
 696        int ret = 0;
 697        BUG_ON(chunk->nr >= CHUNK_SIZE);
 698        chunk->bh[chunk->nr++] = bh;
 699        if (chunk->nr >= CHUNK_SIZE) {
 700                ret = 1;
 701                if (lock)
 702                        spin_unlock(lock);
 703                fn(chunk);
 704                if (lock)
 705                        spin_lock(lock);
 706        }
 707        return ret;
 708}
 709
 710static atomic_t nr_reiserfs_jh = ATOMIC_INIT(0);
 711static struct reiserfs_jh *alloc_jh(void)
 712{
 713        struct reiserfs_jh *jh;
 714        while (1) {
 715                jh = kmalloc(sizeof(*jh), GFP_NOFS);
 716                if (jh) {
 717                        atomic_inc(&nr_reiserfs_jh);
 718                        return jh;
 719                }
 720                yield();
 721        }
 722}
 723
 724/*
 725 * we want to free the jh when the buffer has been written
 726 * and waited on
 727 */
 728void reiserfs_free_jh(struct buffer_head *bh)
 729{
 730        struct reiserfs_jh *jh;
 731
 732        jh = bh->b_private;
 733        if (jh) {
 734                bh->b_private = NULL;
 735                jh->bh = NULL;
 736                list_del_init(&jh->list);
 737                kfree(jh);
 738                if (atomic_read(&nr_reiserfs_jh) <= 0)
 739                        BUG();
 740                atomic_dec(&nr_reiserfs_jh);
 741                put_bh(bh);
 742        }
 743}
 744
 745static inline int __add_jh(struct reiserfs_journal *j, struct buffer_head *bh,
 746                           int tail)
 747{
 748        struct reiserfs_jh *jh;
 749
 750        if (bh->b_private) {
 751                spin_lock(&j->j_dirty_buffers_lock);
 752                if (!bh->b_private) {
 753                        spin_unlock(&j->j_dirty_buffers_lock);
 754                        goto no_jh;
 755                }
 756                jh = bh->b_private;
 757                list_del_init(&jh->list);
 758        } else {
 759              no_jh:
 760                get_bh(bh);
 761                jh = alloc_jh();
 762                spin_lock(&j->j_dirty_buffers_lock);
 763                /* buffer must be locked for __add_jh, should be able to have
 764                 * two adds at the same time
 765                 */
 766                BUG_ON(bh->b_private);
 767                jh->bh = bh;
 768                bh->b_private = jh;
 769        }
 770        jh->jl = j->j_current_jl;
 771        if (tail)
 772                list_add_tail(&jh->list, &jh->jl->j_tail_bh_list);
 773        else {
 774                list_add_tail(&jh->list, &jh->jl->j_bh_list);
 775        }
 776        spin_unlock(&j->j_dirty_buffers_lock);
 777        return 0;
 778}
 779
 780int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh)
 781{
 782        return __add_jh(SB_JOURNAL(inode->i_sb), bh, 1);
 783}
 784int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh)
 785{
 786        return __add_jh(SB_JOURNAL(inode->i_sb), bh, 0);
 787}
 788
 789#define JH_ENTRY(l) list_entry((l), struct reiserfs_jh, list)
 790static int write_ordered_buffers(spinlock_t * lock,
 791                                 struct reiserfs_journal *j,
 792                                 struct reiserfs_journal_list *jl,
 793                                 struct list_head *list)
 794{
 795        struct buffer_head *bh;
 796        struct reiserfs_jh *jh;
 797        int ret = j->j_errno;
 798        struct buffer_chunk chunk;
 799        struct list_head tmp;
 800        INIT_LIST_HEAD(&tmp);
 801
 802        chunk.nr = 0;
 803        spin_lock(lock);
 804        while (!list_empty(list)) {
 805                jh = JH_ENTRY(list->next);
 806                bh = jh->bh;
 807                get_bh(bh);
 808                if (!trylock_buffer(bh)) {
 809                        if (!buffer_dirty(bh)) {
 810                                list_move(&jh->list, &tmp);
 811                                goto loop_next;
 812                        }
 813                        spin_unlock(lock);
 814                        if (chunk.nr)
 815                                write_ordered_chunk(&chunk);
 816                        wait_on_buffer(bh);
 817                        cond_resched();
 818                        spin_lock(lock);
 819                        goto loop_next;
 820                }
 821                /* in theory, dirty non-uptodate buffers should never get here,
 822                 * but the upper layer io error paths still have a few quirks.
 823                 * Handle them here as gracefully as we can
 824                 */
 825                if (!buffer_uptodate(bh) && buffer_dirty(bh)) {
 826                        clear_buffer_dirty(bh);
 827                        ret = -EIO;
 828                }
 829                if (buffer_dirty(bh)) {
 830                        list_move(&jh->list, &tmp);
 831                        add_to_chunk(&chunk, bh, lock, write_ordered_chunk);
 832                } else {
 833                        reiserfs_free_jh(bh);
 834                        unlock_buffer(bh);
 835                }
 836              loop_next:
 837                put_bh(bh);
 838                cond_resched_lock(lock);
 839        }
 840        if (chunk.nr) {
 841                spin_unlock(lock);
 842                write_ordered_chunk(&chunk);
 843                spin_lock(lock);
 844        }
 845        while (!list_empty(&tmp)) {
 846                jh = JH_ENTRY(tmp.prev);
 847                bh = jh->bh;
 848                get_bh(bh);
 849                reiserfs_free_jh(bh);
 850
 851                if (buffer_locked(bh)) {
 852                        spin_unlock(lock);
 853                        wait_on_buffer(bh);
 854                        spin_lock(lock);
 855                }
 856                if (!buffer_uptodate(bh)) {
 857                        ret = -EIO;
 858                }
 859                /* ugly interaction with invalidatepage here.
 860                 * reiserfs_invalidate_page will pin any buffer that has a valid
 861                 * journal head from an older transaction.  If someone else sets
 862                 * our buffer dirty after we write it in the first loop, and
 863                 * then someone truncates the page away, nobody will ever write
 864                 * the buffer. We're safe if we write the page one last time
 865                 * after freeing the journal header.
 866                 */
 867                if (buffer_dirty(bh) && unlikely(bh->b_page->mapping == NULL)) {
 868                        spin_unlock(lock);
 869                        ll_rw_block(WRITE, 1, &bh);
 870                        spin_lock(lock);
 871                }
 872                put_bh(bh);
 873                cond_resched_lock(lock);
 874        }
 875        spin_unlock(lock);
 876        return ret;
 877}
 878
 879static int flush_older_commits(struct super_block *s,
 880                               struct reiserfs_journal_list *jl)
 881{
 882        struct reiserfs_journal *journal = SB_JOURNAL(s);
 883        struct reiserfs_journal_list *other_jl;
 884        struct reiserfs_journal_list *first_jl;
 885        struct list_head *entry;
 886        unsigned int trans_id = jl->j_trans_id;
 887        unsigned int other_trans_id;
 888        unsigned int first_trans_id;
 889
 890      find_first:
 891        /*
 892         * first we walk backwards to find the oldest uncommitted transation
 893         */
 894        first_jl = jl;
 895        entry = jl->j_list.prev;
 896        while (1) {
 897                other_jl = JOURNAL_LIST_ENTRY(entry);
 898                if (entry == &journal->j_journal_list ||
 899                    atomic_read(&other_jl->j_older_commits_done))
 900                        break;
 901
 902                first_jl = other_jl;
 903                entry = other_jl->j_list.prev;
 904        }
 905
 906        /* if we didn't find any older uncommitted transactions, return now */
 907        if (first_jl == jl) {
 908                return 0;
 909        }
 910
 911        first_trans_id = first_jl->j_trans_id;
 912
 913        entry = &first_jl->j_list;
 914        while (1) {
 915                other_jl = JOURNAL_LIST_ENTRY(entry);
 916                other_trans_id = other_jl->j_trans_id;
 917
 918                if (other_trans_id < trans_id) {
 919                        if (atomic_read(&other_jl->j_commit_left) != 0) {
 920                                flush_commit_list(s, other_jl, 0);
 921
 922                                /* list we were called with is gone, return */
 923                                if (!journal_list_still_alive(s, trans_id))
 924                                        return 1;
 925
 926                                /* the one we just flushed is gone, this means all
 927                                 * older lists are also gone, so first_jl is no longer
 928                                 * valid either.  Go back to the beginning.
 929                                 */
 930                                if (!journal_list_still_alive
 931                                    (s, other_trans_id)) {
 932                                        goto find_first;
 933                                }
 934                        }
 935                        entry = entry->next;
 936                        if (entry == &journal->j_journal_list)
 937                                return 0;
 938                } else {
 939                        return 0;
 940                }
 941        }
 942        return 0;
 943}
 944
 945static int reiserfs_async_progress_wait(struct super_block *s)
 946{
 947        struct reiserfs_journal *j = SB_JOURNAL(s);
 948
 949        if (atomic_read(&j->j_async_throttle)) {
 950                reiserfs_write_unlock(s);
 951                congestion_wait(BLK_RW_ASYNC, HZ / 10);
 952                reiserfs_write_lock(s);
 953        }
 954
 955        return 0;
 956}
 957
 958/*
 959** if this journal list still has commit blocks unflushed, send them to disk.
 960**
 961** log areas must be flushed in order (transaction 2 can't commit before transaction 1)
 962** Before the commit block can by written, every other log block must be safely on disk
 963**
 964*/
 965static int flush_commit_list(struct super_block *s,
 966                             struct reiserfs_journal_list *jl, int flushall)
 967{
 968        int i;
 969        b_blocknr_t bn;
 970        struct buffer_head *tbh = NULL;
 971        unsigned int trans_id = jl->j_trans_id;
 972        struct reiserfs_journal *journal = SB_JOURNAL(s);
 973        int retval = 0;
 974        int write_len;
 975
 976        reiserfs_check_lock_depth(s, "flush_commit_list");
 977
 978        if (atomic_read(&jl->j_older_commits_done)) {
 979                return 0;
 980        }
 981
 982        /* before we can put our commit blocks on disk, we have to make sure everyone older than
 983         ** us is on disk too
 984         */
 985        BUG_ON(jl->j_len <= 0);
 986        BUG_ON(trans_id == journal->j_trans_id);
 987
 988        get_journal_list(jl);
 989        if (flushall) {
 990                if (flush_older_commits(s, jl) == 1) {
 991                        /* list disappeared during flush_older_commits.  return */
 992                        goto put_jl;
 993                }
 994        }
 995
 996        /* make sure nobody is trying to flush this one at the same time */
 997        reiserfs_mutex_lock_safe(&jl->j_commit_mutex, s);
 998
 999        if (!journal_list_still_alive(s, trans_id)) {
1000                mutex_unlock(&jl->j_commit_mutex);
1001                goto put_jl;
1002        }
1003        BUG_ON(jl->j_trans_id == 0);
1004
1005        /* this commit is done, exit */
1006        if (atomic_read(&(jl->j_commit_left)) <= 0) {
1007                if (flushall) {
1008                        atomic_set(&(jl->j_older_commits_done), 1);
1009                }
1010                mutex_unlock(&jl->j_commit_mutex);
1011                goto put_jl;
1012        }
1013
1014        if (!list_empty(&jl->j_bh_list)) {
1015                int ret;
1016
1017                /*
1018                 * We might sleep in numerous places inside
1019                 * write_ordered_buffers. Relax the write lock.
1020                 */
1021                reiserfs_write_unlock(s);
1022                ret = write_ordered_buffers(&journal->j_dirty_buffers_lock,
1023                                            journal, jl, &jl->j_bh_list);
1024                if (ret < 0 && retval == 0)
1025                        retval = ret;
1026                reiserfs_write_lock(s);
1027        }
1028        BUG_ON(!list_empty(&jl->j_bh_list));
1029        /*
1030         * for the description block and all the log blocks, submit any buffers
1031         * that haven't already reached the disk.  Try to write at least 256
1032         * log blocks. later on, we will only wait on blocks that correspond
1033         * to this transaction, but while we're unplugging we might as well
1034         * get a chunk of data on there.
1035         */
1036        atomic_inc(&journal->j_async_throttle);
1037        write_len = jl->j_len + 1;
1038        if (write_len < 256)
1039                write_len = 256;
1040        for (i = 0 ; i < write_len ; i++) {
1041                bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) + (jl->j_start + i) %
1042                    SB_ONDISK_JOURNAL_SIZE(s);
1043                tbh = journal_find_get_block(s, bn);
1044                if (tbh) {
1045                        if (buffer_dirty(tbh)) {
1046                            reiserfs_write_unlock(s);
1047                            ll_rw_block(WRITE, 1, &tbh);
1048                            reiserfs_write_lock(s);
1049                        }
1050                        put_bh(tbh) ;
1051                }
1052        }
1053        atomic_dec(&journal->j_async_throttle);
1054
1055        for (i = 0; i < (jl->j_len + 1); i++) {
1056                bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) +
1057                    (jl->j_start + i) % SB_ONDISK_JOURNAL_SIZE(s);
1058                tbh = journal_find_get_block(s, bn);
1059
1060                reiserfs_write_unlock(s);
1061                wait_on_buffer(tbh);
1062                reiserfs_write_lock(s);
1063                // since we're using ll_rw_blk above, it might have skipped over
1064                // a locked buffer.  Double check here
1065                //
1066                /* redundant, sync_dirty_buffer() checks */
1067                if (buffer_dirty(tbh)) {
1068                        reiserfs_write_unlock(s);
1069                        sync_dirty_buffer(tbh);
1070                        reiserfs_write_lock(s);
1071                }
1072                if (unlikely(!buffer_uptodate(tbh))) {
1073#ifdef CONFIG_REISERFS_CHECK
1074                        reiserfs_warning(s, "journal-601",
1075                                         "buffer write failed");
1076#endif
1077                        retval = -EIO;
1078                }
1079                put_bh(tbh);    /* once for journal_find_get_block */
1080                put_bh(tbh);    /* once due to original getblk in do_journal_end */
1081                atomic_dec(&(jl->j_commit_left));
1082        }
1083
1084        BUG_ON(atomic_read(&(jl->j_commit_left)) != 1);
1085
1086        /* If there was a write error in the journal - we can't commit
1087         * this transaction - it will be invalid and, if successful,
1088         * will just end up propagating the write error out to
1089         * the file system. */
1090        if (likely(!retval && !reiserfs_is_journal_aborted (journal))) {
1091                if (buffer_dirty(jl->j_commit_bh))
1092                        BUG();
1093                mark_buffer_dirty(jl->j_commit_bh) ;
1094                reiserfs_write_unlock(s);
1095                if (reiserfs_barrier_flush(s))
1096                        __sync_dirty_buffer(jl->j_commit_bh, WRITE_FLUSH_FUA);
1097                else
1098                        sync_dirty_buffer(jl->j_commit_bh);
1099                reiserfs_write_lock(s);
1100        }
1101
1102        /* If there was a write error in the journal - we can't commit this
1103         * transaction - it will be invalid and, if successful, will just end
1104         * up propagating the write error out to the filesystem. */
1105        if (unlikely(!buffer_uptodate(jl->j_commit_bh))) {
1106#ifdef CONFIG_REISERFS_CHECK
1107                reiserfs_warning(s, "journal-615", "buffer write failed");
1108#endif
1109                retval = -EIO;
1110        }
1111        bforget(jl->j_commit_bh);
1112        if (journal->j_last_commit_id != 0 &&
1113            (jl->j_trans_id - journal->j_last_commit_id) != 1) {
1114                reiserfs_warning(s, "clm-2200", "last commit %lu, current %lu",
1115                                 journal->j_last_commit_id, jl->j_trans_id);
1116        }
1117        journal->j_last_commit_id = jl->j_trans_id;
1118
1119        /* now, every commit block is on the disk.  It is safe to allow blocks freed during this transaction to be reallocated */
1120        cleanup_freed_for_journal_list(s, jl);
1121
1122        retval = retval ? retval : journal->j_errno;
1123
1124        /* mark the metadata dirty */
1125        if (!retval)
1126                dirty_one_transaction(s, jl);
1127        atomic_dec(&(jl->j_commit_left));
1128
1129        if (flushall) {
1130                atomic_set(&(jl->j_older_commits_done), 1);
1131        }
1132        mutex_unlock(&jl->j_commit_mutex);
1133      put_jl:
1134        put_journal_list(s, jl);
1135
1136        if (retval)
1137                reiserfs_abort(s, retval, "Journal write error in %s",
1138                               __func__);
1139        return retval;
1140}
1141
1142/*
1143** flush_journal_list frequently needs to find a newer transaction for a given block.  This does that, or
1144** returns NULL if it can't find anything
1145*/
1146static struct reiserfs_journal_list *find_newer_jl_for_cn(struct
1147                                                          reiserfs_journal_cnode
1148                                                          *cn)
1149{
1150        struct super_block *sb = cn->sb;
1151        b_blocknr_t blocknr = cn->blocknr;
1152
1153        cn = cn->hprev;
1154        while (cn) {
1155                if (cn->sb == sb && cn->blocknr == blocknr && cn->jlist) {
1156                        return cn->jlist;
1157                }
1158                cn = cn->hprev;
1159        }
1160        return NULL;
1161}
1162
1163static int newer_jl_done(struct reiserfs_journal_cnode *cn)
1164{
1165        struct super_block *sb = cn->sb;
1166        b_blocknr_t blocknr = cn->blocknr;
1167
1168        cn = cn->hprev;
1169        while (cn) {
1170                if (cn->sb == sb && cn->blocknr == blocknr && cn->jlist &&
1171                    atomic_read(&cn->jlist->j_commit_left) != 0)
1172                                    return 0;
1173                cn = cn->hprev;
1174        }
1175        return 1;
1176}
1177
1178static void remove_journal_hash(struct super_block *,
1179                                struct reiserfs_journal_cnode **,
1180                                struct reiserfs_journal_list *, unsigned long,
1181                                int);
1182
1183/*
1184** once all the real blocks have been flushed, it is safe to remove them from the
1185** journal list for this transaction.  Aside from freeing the cnode, this also allows the
1186** block to be reallocated for data blocks if it had been deleted.
1187*/
1188static void remove_all_from_journal_list(struct super_block *sb,
1189                                         struct reiserfs_journal_list *jl,
1190                                         int debug)
1191{
1192        struct reiserfs_journal *journal = SB_JOURNAL(sb);
1193        struct reiserfs_journal_cnode *cn, *last;
1194        cn = jl->j_realblock;
1195
1196        /* which is better, to lock once around the whole loop, or
1197         ** to lock for each call to remove_journal_hash?
1198         */
1199        while (cn) {
1200                if (cn->blocknr != 0) {
1201                        if (debug) {
1202                                reiserfs_warning(sb, "reiserfs-2201",
1203                                                 "block %u, bh is %d, state %ld",
1204                                                 cn->blocknr, cn->bh ? 1 : 0,
1205                                                 cn->state);
1206                        }
1207                        cn->state = 0;
1208                        remove_journal_hash(sb, journal->j_list_hash_table,
1209                                            jl, cn->blocknr, 1);
1210                }
1211                last = cn;
1212                cn = cn->next;
1213                free_cnode(sb, last);
1214        }
1215        jl->j_realblock = NULL;
1216}
1217
1218/*
1219** if this timestamp is greater than the timestamp we wrote last to the header block, write it to the header block.
1220** once this is done, I can safely say the log area for this transaction won't ever be replayed, and I can start
1221** releasing blocks in this transaction for reuse as data blocks.
1222** called by flush_journal_list, before it calls remove_all_from_journal_list
1223**
1224*/
1225static int _update_journal_header_block(struct super_block *sb,
1226                                        unsigned long offset,
1227                                        unsigned int trans_id)
1228{
1229        struct reiserfs_journal_header *jh;
1230        struct reiserfs_journal *journal = SB_JOURNAL(sb);
1231
1232        if (reiserfs_is_journal_aborted(journal))
1233                return -EIO;
1234
1235        if (trans_id >= journal->j_last_flush_trans_id) {
1236                if (buffer_locked((journal->j_header_bh))) {
1237                        reiserfs_write_unlock(sb);
1238                        wait_on_buffer((journal->j_header_bh));
1239                        reiserfs_write_lock(sb);
1240                        if (unlikely(!buffer_uptodate(journal->j_header_bh))) {
1241#ifdef CONFIG_REISERFS_CHECK
1242                                reiserfs_warning(sb, "journal-699",
1243                                                 "buffer write failed");
1244#endif
1245                                return -EIO;
1246                        }
1247                }
1248                journal->j_last_flush_trans_id = trans_id;
1249                journal->j_first_unflushed_offset = offset;
1250                jh = (struct reiserfs_journal_header *)(journal->j_header_bh->
1251                                                        b_data);
1252                jh->j_last_flush_trans_id = cpu_to_le32(trans_id);
1253                jh->j_first_unflushed_offset = cpu_to_le32(offset);
1254                jh->j_mount_id = cpu_to_le32(journal->j_mount_id);
1255
1256                set_buffer_dirty(journal->j_header_bh);
1257                reiserfs_write_unlock(sb);
1258
1259                if (reiserfs_barrier_flush(sb))
1260                        __sync_dirty_buffer(journal->j_header_bh, WRITE_FLUSH_FUA);
1261                else
1262                        sync_dirty_buffer(journal->j_header_bh);
1263
1264                reiserfs_write_lock(sb);
1265                if (!buffer_uptodate(journal->j_header_bh)) {
1266                        reiserfs_warning(sb, "journal-837",
1267                                         "IO error during journal replay");
1268                        return -EIO;
1269                }
1270        }
1271        return 0;
1272}
1273
1274static int update_journal_header_block(struct super_block *sb,
1275                                       unsigned long offset,
1276                                       unsigned int trans_id)
1277{
1278        return _update_journal_header_block(sb, offset, trans_id);
1279}
1280
1281/*
1282** flush any and all journal lists older than you are
1283** can only be called from flush_journal_list
1284*/
1285static int flush_older_journal_lists(struct super_block *sb,
1286                                     struct reiserfs_journal_list *jl)
1287{
1288        struct list_head *entry;
1289        struct reiserfs_journal_list *other_jl;
1290        struct reiserfs_journal *journal = SB_JOURNAL(sb);
1291        unsigned int trans_id = jl->j_trans_id;
1292
1293        /* we know we are the only ones flushing things, no extra race
1294         * protection is required.
1295         */
1296      restart:
1297        entry = journal->j_journal_list.next;
1298        /* Did we wrap? */
1299        if (entry == &journal->j_journal_list)
1300                return 0;
1301        other_jl = JOURNAL_LIST_ENTRY(entry);
1302        if (other_jl->j_trans_id < trans_id) {
1303                BUG_ON(other_jl->j_refcount <= 0);
1304                /* do not flush all */
1305                flush_journal_list(sb, other_jl, 0);
1306
1307                /* other_jl is now deleted from the list */
1308                goto restart;
1309        }
1310        return 0;
1311}
1312
1313static void del_from_work_list(struct super_block *s,
1314                               struct reiserfs_journal_list *jl)
1315{
1316        struct reiserfs_journal *journal = SB_JOURNAL(s);
1317        if (!list_empty(&jl->j_working_list)) {
1318                list_del_init(&jl->j_working_list);
1319                journal->j_num_work_lists--;
1320        }
1321}
1322
1323/* flush a journal list, both commit and real blocks
1324**
1325** always set flushall to 1, unless you are calling from inside
1326** flush_journal_list
1327**
1328** IMPORTANT.  This can only be called while there are no journal writers,
1329** and the journal is locked.  That means it can only be called from
1330** do_journal_end, or by journal_release
1331*/
1332static int flush_journal_list(struct super_block *s,
1333                              struct reiserfs_journal_list *jl, int flushall)
1334{
1335        struct reiserfs_journal_list *pjl;
1336        struct reiserfs_journal_cnode *cn, *last;
1337        int count;
1338        int was_jwait = 0;
1339        int was_dirty = 0;
1340        struct buffer_head *saved_bh;
1341        unsigned long j_len_saved = jl->j_len;
1342        struct reiserfs_journal *journal = SB_JOURNAL(s);
1343        int err = 0;
1344
1345        BUG_ON(j_len_saved <= 0);
1346
1347        if (atomic_read(&journal->j_wcount) != 0) {
1348                reiserfs_warning(s, "clm-2048", "called with wcount %d",
1349                                 atomic_read(&journal->j_wcount));
1350        }
1351        BUG_ON(jl->j_trans_id == 0);
1352
1353        /* if flushall == 0, the lock is already held */
1354        if (flushall) {
1355                reiserfs_mutex_lock_safe(&journal->j_flush_mutex, s);
1356        } else if (mutex_trylock(&journal->j_flush_mutex)) {
1357                BUG();
1358        }
1359
1360        count = 0;
1361        if (j_len_saved > journal->j_trans_max) {
1362                reiserfs_panic(s, "journal-715", "length is %lu, trans id %lu",
1363                               j_len_saved, jl->j_trans_id);
1364                return 0;
1365        }
1366
1367        /* if all the work is already done, get out of here */
1368        if (atomic_read(&(jl->j_nonzerolen)) <= 0 &&
1369            atomic_read(&(jl->j_commit_left)) <= 0) {
1370                goto flush_older_and_return;
1371        }
1372
1373        /* start by putting the commit list on disk.  This will also flush
1374         ** the commit lists of any olders transactions
1375         */
1376        flush_commit_list(s, jl, 1);
1377
1378        if (!(jl->j_state & LIST_DIRTY)
1379            && !reiserfs_is_journal_aborted(journal))
1380                BUG();
1381
1382        /* are we done now? */
1383        if (atomic_read(&(jl->j_nonzerolen)) <= 0 &&
1384            atomic_read(&(jl->j_commit_left)) <= 0) {
1385                goto flush_older_and_return;
1386        }
1387
1388        /* loop through each cnode, see if we need to write it,
1389         ** or wait on a more recent transaction, or just ignore it
1390         */
1391        if (atomic_read(&(journal->j_wcount)) != 0) {
1392                reiserfs_panic(s, "journal-844", "journal list is flushing, "
1393                               "wcount is not 0");
1394        }
1395        cn = jl->j_realblock;
1396        while (cn) {
1397                was_jwait = 0;
1398                was_dirty = 0;
1399                saved_bh = NULL;
1400                /* blocknr of 0 is no longer in the hash, ignore it */
1401                if (cn->blocknr == 0) {
1402                        goto free_cnode;
1403                }
1404
1405                /* This transaction failed commit. Don't write out to the disk */
1406                if (!(jl->j_state & LIST_DIRTY))
1407                        goto free_cnode;
1408
1409                pjl = find_newer_jl_for_cn(cn);
1410                /* the order is important here.  We check pjl to make sure we
1411                 ** don't clear BH_JDirty_wait if we aren't the one writing this
1412                 ** block to disk
1413                 */
1414                if (!pjl && cn->bh) {
1415                        saved_bh = cn->bh;
1416
1417                        /* we do this to make sure nobody releases the buffer while
1418                         ** we are working with it
1419                         */
1420                        get_bh(saved_bh);
1421
1422                        if (buffer_journal_dirty(saved_bh)) {
1423                                BUG_ON(!can_dirty(cn));
1424                                was_jwait = 1;
1425                                was_dirty = 1;
1426                        } else if (can_dirty(cn)) {
1427                                /* everything with !pjl && jwait should be writable */
1428                                BUG();
1429                        }
1430                }
1431
1432                /* if someone has this block in a newer transaction, just make
1433                 ** sure they are committed, and don't try writing it to disk
1434                 */
1435                if (pjl) {
1436                        if (atomic_read(&pjl->j_commit_left))
1437                                flush_commit_list(s, pjl, 1);
1438                        goto free_cnode;
1439                }
1440
1441                /* bh == NULL when the block got to disk on its own, OR,
1442                 ** the block got freed in a future transaction
1443                 */
1444                if (saved_bh == NULL) {
1445                        goto free_cnode;
1446                }
1447
1448                /* this should never happen.  kupdate_one_transaction has this list
1449                 ** locked while it works, so we should never see a buffer here that
1450                 ** is not marked JDirty_wait
1451                 */
1452                if ((!was_jwait) && !buffer_locked(saved_bh)) {
1453                        reiserfs_warning(s, "journal-813",
1454                                         "BAD! buffer %llu %cdirty %cjwait, "
1455                                         "not in a newer tranasction",
1456                                         (unsigned long long)saved_bh->
1457                                         b_blocknr, was_dirty ? ' ' : '!',
1458                                         was_jwait ? ' ' : '!');
1459                }
1460                if (was_dirty) {
1461                        /* we inc again because saved_bh gets decremented at free_cnode */
1462                        get_bh(saved_bh);
1463                        set_bit(BLOCK_NEEDS_FLUSH, &cn->state);
1464                        lock_buffer(saved_bh);
1465                        BUG_ON(cn->blocknr != saved_bh->b_blocknr);
1466                        if (buffer_dirty(saved_bh))
1467                                submit_logged_buffer(saved_bh);
1468                        else
1469                                unlock_buffer(saved_bh);
1470                        count++;
1471                } else {
1472                        reiserfs_warning(s, "clm-2082",
1473                                         "Unable to flush buffer %llu in %s",
1474                                         (unsigned long long)saved_bh->
1475                                         b_blocknr, __func__);
1476                }
1477              free_cnode:
1478                last = cn;
1479                cn = cn->next;
1480                if (saved_bh) {
1481                        /* we incremented this to keep others from taking the buffer head away */
1482                        put_bh(saved_bh);
1483                        if (atomic_read(&(saved_bh->b_count)) < 0) {
1484                                reiserfs_warning(s, "journal-945",
1485                                                 "saved_bh->b_count < 0");
1486                        }
1487                }
1488        }
1489        if (count > 0) {
1490                cn = jl->j_realblock;
1491                while (cn) {
1492                        if (test_bit(BLOCK_NEEDS_FLUSH, &cn->state)) {
1493                                if (!cn->bh) {
1494                                        reiserfs_panic(s, "journal-1011",
1495                                                       "cn->bh is NULL");
1496                                }
1497
1498                                reiserfs_write_unlock(s);
1499                                wait_on_buffer(cn->bh);
1500                                reiserfs_write_lock(s);
1501
1502                                if (!cn->bh) {
1503                                        reiserfs_panic(s, "journal-1012",
1504                                                       "cn->bh is NULL");
1505                                }
1506                                if (unlikely(!buffer_uptodate(cn->bh))) {
1507#ifdef CONFIG_REISERFS_CHECK
1508                                        reiserfs_warning(s, "journal-949",
1509                                                         "buffer write failed");
1510#endif
1511                                        err = -EIO;
1512                                }
1513                                /* note, we must clear the JDirty_wait bit after the up to date
1514                                 ** check, otherwise we race against our flushpage routine
1515                                 */
1516                                BUG_ON(!test_clear_buffer_journal_dirty
1517                                       (cn->bh));
1518
1519                                /* drop one ref for us */
1520                                put_bh(cn->bh);
1521                                /* drop one ref for journal_mark_dirty */
1522                                release_buffer_page(cn->bh);
1523                        }
1524                        cn = cn->next;
1525                }
1526        }
1527
1528        if (err)
1529                reiserfs_abort(s, -EIO,
1530                               "Write error while pushing transaction to disk in %s",
1531                               __func__);
1532      flush_older_and_return:
1533
1534        /* before we can update the journal header block, we _must_ flush all
1535         ** real blocks from all older transactions to disk.  This is because
1536         ** once the header block is updated, this transaction will not be
1537         ** replayed after a crash
1538         */
1539        if (flushall) {
1540                flush_older_journal_lists(s, jl);
1541        }
1542
1543        err = journal->j_errno;
1544        /* before we can remove everything from the hash tables for this
1545         ** transaction, we must make sure it can never be replayed
1546         **
1547         ** since we are only called from do_journal_end, we know for sure there
1548         ** are no allocations going on while we are flushing journal lists.  So,
1549         ** we only need to update the journal header block for the last list
1550         ** being flushed
1551         */
1552        if (!err && flushall) {
1553                err =
1554                    update_journal_header_block(s,
1555                                                (jl->j_start + jl->j_len +
1556                                                 2) % SB_ONDISK_JOURNAL_SIZE(s),
1557                                                jl->j_trans_id);
1558                if (err)
1559                        reiserfs_abort(s, -EIO,
1560                                       "Write error while updating journal header in %s",
1561                                       __func__);
1562        }
1563        remove_all_from_journal_list(s, jl, 0);
1564        list_del_init(&jl->j_list);
1565        journal->j_num_lists--;
1566        del_from_work_list(s, jl);
1567
1568        if (journal->j_last_flush_id != 0 &&
1569            (jl->j_trans_id - journal->j_last_flush_id) != 1) {
1570                reiserfs_warning(s, "clm-2201", "last flush %lu, current %lu",
1571                                 journal->j_last_flush_id, jl->j_trans_id);
1572        }
1573        journal->j_last_flush_id = jl->j_trans_id;
1574
1575        /* not strictly required since we are freeing the list, but it should
1576         * help find code using dead lists later on
1577         */
1578        jl->j_len = 0;
1579        atomic_set(&(jl->j_nonzerolen), 0);
1580        jl->j_start = 0;
1581        jl->j_realblock = NULL;
1582        jl->j_commit_bh = NULL;
1583        jl->j_trans_id = 0;
1584        jl->j_state = 0;
1585        put_journal_list(s, jl);
1586        if (flushall)
1587                mutex_unlock(&journal->j_flush_mutex);
1588        return err;
1589}
1590
1591static int test_transaction(struct super_block *s,
1592                            struct reiserfs_journal_list *jl)
1593{
1594        struct reiserfs_journal_cnode *cn;
1595
1596        if (jl->j_len == 0 || atomic_read(&jl->j_nonzerolen) == 0)
1597                return 1;
1598
1599        cn = jl->j_realblock;
1600        while (cn) {
1601                /* if the blocknr == 0, this has been cleared from the hash,
1602                 ** skip it
1603                 */
1604                if (cn->blocknr == 0) {
1605                        goto next;
1606                }
1607                if (cn->bh && !newer_jl_done(cn))
1608                        return 0;
1609              next:
1610                cn = cn->next;
1611                cond_resched();
1612        }
1613        return 0;
1614}
1615
1616static int write_one_transaction(struct super_block *s,
1617                                 struct reiserfs_journal_list *jl,
1618                                 struct buffer_chunk *chunk)
1619{
1620        struct reiserfs_journal_cnode *cn;
1621        int ret = 0;
1622
1623        jl->j_state |= LIST_TOUCHED;
1624        del_from_work_list(s, jl);
1625        if (jl->j_len == 0 || atomic_read(&jl->j_nonzerolen) == 0) {
1626                return 0;
1627        }
1628
1629        cn = jl->j_realblock;
1630        while (cn) {
1631                /* if the blocknr == 0, this has been cleared from the hash,
1632                 ** skip it
1633                 */
1634                if (cn->blocknr == 0) {
1635                        goto next;
1636                }
1637                if (cn->bh && can_dirty(cn) && buffer_dirty(cn->bh)) {
1638                        struct buffer_head *tmp_bh;
1639                        /* we can race against journal_mark_freed when we try
1640                         * to lock_buffer(cn->bh), so we have to inc the buffer
1641                         * count, and recheck things after locking
1642                         */
1643                        tmp_bh = cn->bh;
1644                        get_bh(tmp_bh);
1645                        lock_buffer(tmp_bh);
1646                        if (cn->bh && can_dirty(cn) && buffer_dirty(tmp_bh)) {
1647                                if (!buffer_journal_dirty(tmp_bh) ||
1648                                    buffer_journal_prepared(tmp_bh))
1649                                        BUG();
1650                                add_to_chunk(chunk, tmp_bh, NULL, write_chunk);
1651                                ret++;
1652                        } else {
1653                                /* note, cn->bh might be null now */
1654                                unlock_buffer(tmp_bh);
1655                        }
1656                        put_bh(tmp_bh);
1657                }
1658              next:
1659                cn = cn->next;
1660                cond_resched();
1661        }
1662        return ret;
1663}
1664
1665/* used by flush_commit_list */
1666static int dirty_one_transaction(struct super_block *s,
1667                                 struct reiserfs_journal_list *jl)
1668{
1669        struct reiserfs_journal_cnode *cn;
1670        struct reiserfs_journal_list *pjl;
1671        int ret = 0;
1672
1673        jl->j_state |= LIST_DIRTY;
1674        cn = jl->j_realblock;
1675        while (cn) {
1676                /* look for a more recent transaction that logged this
1677                 ** buffer.  Only the most recent transaction with a buffer in
1678                 ** it is allowed to send that buffer to disk
1679                 */
1680                pjl = find_newer_jl_for_cn(cn);
1681                if (!pjl && cn->blocknr && cn->bh
1682                    && buffer_journal_dirty(cn->bh)) {
1683                        BUG_ON(!can_dirty(cn));
1684                        /* if the buffer is prepared, it will either be logged
1685                         * or restored.  If restored, we need to make sure
1686                         * it actually gets marked dirty
1687                         */
1688                        clear_buffer_journal_new(cn->bh);
1689                        if (buffer_journal_prepared(cn->bh)) {
1690                                set_buffer_journal_restore_dirty(cn->bh);
1691                        } else {
1692                                set_buffer_journal_test(cn->bh);
1693                                mark_buffer_dirty(cn->bh);
1694                        }
1695                }
1696                cn = cn->next;
1697        }
1698        return ret;
1699}
1700
1701static int kupdate_transactions(struct super_block *s,
1702                                struct reiserfs_journal_list *jl,
1703                                struct reiserfs_journal_list **next_jl,
1704                                unsigned int *next_trans_id,
1705                                int num_blocks, int num_trans)
1706{
1707        int ret = 0;
1708        int written = 0;
1709        int transactions_flushed = 0;
1710        unsigned int orig_trans_id = jl->j_trans_id;
1711        struct buffer_chunk chunk;
1712        struct list_head *entry;
1713        struct reiserfs_journal *journal = SB_JOURNAL(s);
1714        chunk.nr = 0;
1715
1716        reiserfs_mutex_lock_safe(&journal->j_flush_mutex, s);
1717        if (!journal_list_still_alive(s, orig_trans_id)) {
1718                goto done;
1719        }
1720
1721        /* we've got j_flush_mutex held, nobody is going to delete any
1722         * of these lists out from underneath us
1723         */
1724        while ((num_trans && transactions_flushed < num_trans) ||
1725               (!num_trans && written < num_blocks)) {
1726
1727                if (jl->j_len == 0 || (jl->j_state & LIST_TOUCHED) ||
1728                    atomic_read(&jl->j_commit_left)
1729                    || !(jl->j_state & LIST_DIRTY)) {
1730                        del_from_work_list(s, jl);
1731                        break;
1732                }
1733                ret = write_one_transaction(s, jl, &chunk);
1734
1735                if (ret < 0)
1736                        goto done;
1737                transactions_flushed++;
1738                written += ret;
1739                entry = jl->j_list.next;
1740
1741                /* did we wrap? */
1742                if (entry == &journal->j_journal_list) {
1743                        break;
1744                }
1745                jl = JOURNAL_LIST_ENTRY(entry);
1746
1747                /* don't bother with older transactions */
1748                if (jl->j_trans_id <= orig_trans_id)
1749                        break;
1750        }
1751        if (chunk.nr) {
1752                write_chunk(&chunk);
1753        }
1754
1755      done:
1756        mutex_unlock(&journal->j_flush_mutex);
1757        return ret;
1758}
1759
1760/* for o_sync and fsync heavy applications, they tend to use
1761** all the journa list slots with tiny transactions.  These
1762** trigger lots and lots of calls to update the header block, which
1763** adds seeks and slows things down.
1764**
1765** This function tries to clear out a large chunk of the journal lists
1766** at once, which makes everything faster since only the newest journal
1767** list updates the header block
1768*/
1769static int flush_used_journal_lists(struct super_block *s,
1770                                    struct reiserfs_journal_list *jl)
1771{
1772        unsigned long len = 0;
1773        unsigned long cur_len;
1774        int ret;
1775        int i;
1776        int limit = 256;
1777        struct reiserfs_journal_list *tjl;
1778        struct reiserfs_journal_list *flush_jl;
1779        unsigned int trans_id;
1780        struct reiserfs_journal *journal = SB_JOURNAL(s);
1781
1782        flush_jl = tjl = jl;
1783
1784        /* in data logging mode, try harder to flush a lot of blocks */
1785        if (reiserfs_data_log(s))
1786                limit = 1024;
1787        /* flush for 256 transactions or limit blocks, whichever comes first */
1788        for (i = 0; i < 256 && len < limit; i++) {
1789                if (atomic_read(&tjl->j_commit_left) ||
1790                    tjl->j_trans_id < jl->j_trans_id) {
1791                        break;
1792                }
1793                cur_len = atomic_read(&tjl->j_nonzerolen);
1794                if (cur_len > 0) {
1795                        tjl->j_state &= ~LIST_TOUCHED;
1796                }
1797                len += cur_len;
1798                flush_jl = tjl;
1799                if (tjl->j_list.next == &journal->j_journal_list)
1800                        break;
1801                tjl = JOURNAL_LIST_ENTRY(tjl->j_list.next);
1802        }
1803        /* try to find a group of blocks we can flush across all the
1804         ** transactions, but only bother if we've actually spanned
1805         ** across multiple lists
1806         */
1807        if (flush_jl != jl) {
1808                ret = kupdate_transactions(s, jl, &tjl, &trans_id, len, i);
1809        }
1810        flush_journal_list(s, flush_jl, 1);
1811        return 0;
1812}
1813
1814/*
1815** removes any nodes in table with name block and dev as bh.
1816** only touchs the hnext and hprev pointers.
1817*/
1818void remove_journal_hash(struct super_block *sb,
1819                         struct reiserfs_journal_cnode **table,
1820                         struct reiserfs_journal_list *jl,
1821                         unsigned long block, int remove_freed)
1822{
1823        struct reiserfs_journal_cnode *cur;
1824        struct reiserfs_journal_cnode **head;
1825
1826        head = &(journal_hash(table, sb, block));
1827        if (!head) {
1828                return;
1829        }
1830        cur = *head;
1831        while (cur) {
1832                if (cur->blocknr == block && cur->sb == sb
1833                    && (jl == NULL || jl == cur->jlist)
1834                    && (!test_bit(BLOCK_FREED, &cur->state) || remove_freed)) {
1835                        if (cur->hnext) {
1836                                cur->hnext->hprev = cur->hprev;
1837                        }
1838                        if (cur->hprev) {
1839                                cur->hprev->hnext = cur->hnext;
1840                        } else {
1841                                *head = cur->hnext;
1842                        }
1843                        cur->blocknr = 0;
1844                        cur->sb = NULL;
1845                        cur->state = 0;
1846                        if (cur->bh && cur->jlist)      /* anybody who clears the cur->bh will also dec the nonzerolen */
1847                                atomic_dec(&(cur->jlist->j_nonzerolen));
1848                        cur->bh = NULL;
1849                        cur->jlist = NULL;
1850                }
1851                cur = cur->hnext;
1852        }
1853}
1854
1855static void free_journal_ram(struct super_block *sb)
1856{
1857        struct reiserfs_journal *journal = SB_JOURNAL(sb);
1858        kfree(journal->j_current_jl);
1859        journal->j_num_lists--;
1860
1861        vfree(journal->j_cnode_free_orig);
1862        free_list_bitmaps(sb, journal->j_list_bitmap);
1863        free_bitmap_nodes(sb);  /* must be after free_list_bitmaps */
1864        if (journal->j_header_bh) {
1865                brelse(journal->j_header_bh);
1866        }
1867        /* j_header_bh is on the journal dev, make sure not to release the journal
1868         * dev until we brelse j_header_bh
1869         */
1870        release_journal_dev(sb, journal);
1871        vfree(journal);
1872}
1873
1874/*
1875** call on unmount.  Only set error to 1 if you haven't made your way out
1876** of read_super() yet.  Any other caller must keep error at 0.
1877*/
1878static int do_journal_release(struct reiserfs_transaction_handle *th,
1879                              struct super_block *sb, int error)
1880{
1881        struct reiserfs_transaction_handle myth;
1882        int flushed = 0;
1883        struct reiserfs_journal *journal = SB_JOURNAL(sb);
1884
1885        /* we only want to flush out transactions if we were called with error == 0
1886         */
1887        if (!error && !(sb->s_flags & MS_RDONLY)) {
1888                /* end the current trans */
1889                BUG_ON(!th->t_trans_id);
1890                do_journal_end(th, sb, 10, FLUSH_ALL);
1891
1892                /* make sure something gets logged to force our way into the flush code */
1893                if (!journal_join(&myth, sb, 1)) {
1894                        reiserfs_prepare_for_journal(sb,
1895                                                     SB_BUFFER_WITH_SB(sb),
1896                                                     1);
1897                        journal_mark_dirty(&myth, sb,
1898                                           SB_BUFFER_WITH_SB(sb));
1899                        do_journal_end(&myth, sb, 1, FLUSH_ALL);
1900                        flushed = 1;
1901                }
1902        }
1903
1904        /* this also catches errors during the do_journal_end above */
1905        if (!error && reiserfs_is_journal_aborted(journal)) {
1906                memset(&myth, 0, sizeof(myth));
1907                if (!journal_join_abort(&myth, sb, 1)) {
1908                        reiserfs_prepare_for_journal(sb,
1909                                                     SB_BUFFER_WITH_SB(sb),
1910                                                     1);
1911                        journal_mark_dirty(&myth, sb,
1912                                           SB_BUFFER_WITH_SB(sb));
1913                        do_journal_end(&myth, sb, 1, FLUSH_ALL);
1914                }
1915        }
1916
1917        reiserfs_mounted_fs_count--;
1918        /* wait for all commits to finish */
1919        cancel_delayed_work(&SB_JOURNAL(sb)->j_work);
1920
1921        /*
1922         * We must release the write lock here because
1923         * the workqueue job (flush_async_commit) needs this lock
1924         */
1925        reiserfs_write_unlock(sb);
1926
1927        cancel_delayed_work_sync(&REISERFS_SB(sb)->old_work);
1928        flush_workqueue(commit_wq);
1929
1930        if (!reiserfs_mounted_fs_count) {
1931                destroy_workqueue(commit_wq);
1932                commit_wq = NULL;
1933        }
1934
1935        free_journal_ram(sb);
1936
1937        reiserfs_write_lock(sb);
1938
1939        return 0;
1940}
1941
1942/*
1943** call on unmount.  flush all journal trans, release all alloc'd ram
1944*/
1945int journal_release(struct reiserfs_transaction_handle *th,
1946                    struct super_block *sb)
1947{
1948        return do_journal_release(th, sb, 0);
1949}
1950
1951/*
1952** only call from an error condition inside reiserfs_read_super!
1953*/
1954int journal_release_error(struct reiserfs_transaction_handle *th,
1955                          struct super_block *sb)
1956{
1957        return do_journal_release(th, sb, 1);
1958}
1959
1960/* compares description block with commit block.  returns 1 if they differ, 0 if they are the same */
1961static int journal_compare_desc_commit(struct super_block *sb,
1962                                       struct reiserfs_journal_desc *desc,
1963                                       struct reiserfs_journal_commit *commit)
1964{
1965        if (get_commit_trans_id(commit) != get_desc_trans_id(desc) ||
1966            get_commit_trans_len(commit) != get_desc_trans_len(desc) ||
1967            get_commit_trans_len(commit) > SB_JOURNAL(sb)->j_trans_max ||
1968            get_commit_trans_len(commit) <= 0) {
1969                return 1;
1970        }
1971        return 0;
1972}
1973
1974/* returns 0 if it did not find a description block
1975** returns -1 if it found a corrupt commit block
1976** returns 1 if both desc and commit were valid
1977*/
1978static int journal_transaction_is_valid(struct super_block *sb,
1979                                        struct buffer_head *d_bh,
1980                                        unsigned int *oldest_invalid_trans_id,
1981                                        unsigned long *newest_mount_id)
1982{
1983        struct reiserfs_journal_desc *desc;
1984        struct reiserfs_journal_commit *commit;
1985        struct buffer_head *c_bh;
1986        unsigned long offset;
1987
1988        if (!d_bh)
1989                return 0;
1990
1991        desc = (struct reiserfs_journal_desc *)d_bh->b_data;
1992        if (get_desc_trans_len(desc) > 0
1993            && !memcmp(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8)) {
1994                if (oldest_invalid_trans_id && *oldest_invalid_trans_id
1995                    && get_desc_trans_id(desc) > *oldest_invalid_trans_id) {
1996                        reiserfs_debug(sb, REISERFS_DEBUG_CODE,
1997                                       "journal-986: transaction "
1998                                       "is valid returning because trans_id %d is greater than "
1999                                       "oldest_invalid %lu",
2000                                       get_desc_trans_id(desc),
2001                                       *oldest_invalid_trans_id);
2002                        return 0;
2003                }
2004                if (newest_mount_id
2005                    && *newest_mount_id > get_desc_mount_id(desc)) {
2006                        reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2007                                       "journal-1087: transaction "
2008                                       "is valid returning because mount_id %d is less than "
2009                                       "newest_mount_id %lu",
2010                                       get_desc_mount_id(desc),
2011                                       *newest_mount_id);
2012                        return -1;
2013                }
2014                if (get_desc_trans_len(desc) > SB_JOURNAL(sb)->j_trans_max) {
2015                        reiserfs_warning(sb, "journal-2018",
2016                                         "Bad transaction length %d "
2017                                         "encountered, ignoring transaction",
2018                                         get_desc_trans_len(desc));
2019                        return -1;
2020                }
2021                offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2022
2023                /* ok, we have a journal description block, lets see if the transaction was valid */
2024                c_bh =
2025                    journal_bread(sb,
2026                                  SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2027                                  ((offset + get_desc_trans_len(desc) +
2028                                    1) % SB_ONDISK_JOURNAL_SIZE(sb)));
2029                if (!c_bh)
2030                        return 0;
2031                commit = (struct reiserfs_journal_commit *)c_bh->b_data;
2032                if (journal_compare_desc_commit(sb, desc, commit)) {
2033                        reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2034                                       "journal_transaction_is_valid, commit offset %ld had bad "
2035                                       "time %d or length %d",
2036                                       c_bh->b_blocknr -
2037                                       SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2038                                       get_commit_trans_id(commit),
2039                                       get_commit_trans_len(commit));
2040                        brelse(c_bh);
2041                        if (oldest_invalid_trans_id) {
2042                                *oldest_invalid_trans_id =
2043                                    get_desc_trans_id(desc);
2044                                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2045                                               "journal-1004: "
2046                                               "transaction_is_valid setting oldest invalid trans_id "
2047                                               "to %d",
2048                                               get_desc_trans_id(desc));
2049                        }
2050                        return -1;
2051                }
2052                brelse(c_bh);
2053                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2054                               "journal-1006: found valid "
2055                               "transaction start offset %llu, len %d id %d",
2056                               d_bh->b_blocknr -
2057                               SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2058                               get_desc_trans_len(desc),
2059                               get_desc_trans_id(desc));
2060                return 1;
2061        } else {
2062                return 0;
2063        }
2064}
2065
2066static void brelse_array(struct buffer_head **heads, int num)
2067{
2068        int i;
2069        for (i = 0; i < num; i++) {
2070                brelse(heads[i]);
2071        }
2072}
2073
2074/*
2075** given the start, and values for the oldest acceptable transactions,
2076** this either reads in a replays a transaction, or returns because the transaction
2077** is invalid, or too old.
2078*/
2079static int journal_read_transaction(struct super_block *sb,
2080                                    unsigned long cur_dblock,
2081                                    unsigned long oldest_start,
2082                                    unsigned int oldest_trans_id,
2083                                    unsigned long newest_mount_id)
2084{
2085        struct reiserfs_journal *journal = SB_JOURNAL(sb);
2086        struct reiserfs_journal_desc *desc;
2087        struct reiserfs_journal_commit *commit;
2088        unsigned int trans_id = 0;
2089        struct buffer_head *c_bh;
2090        struct buffer_head *d_bh;
2091        struct buffer_head **log_blocks = NULL;
2092        struct buffer_head **real_blocks = NULL;
2093        unsigned int trans_offset;
2094        int i;
2095        int trans_half;
2096
2097        d_bh = journal_bread(sb, cur_dblock);
2098        if (!d_bh)
2099                return 1;
2100        desc = (struct reiserfs_journal_desc *)d_bh->b_data;
2101        trans_offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2102        reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1037: "
2103                       "journal_read_transaction, offset %llu, len %d mount_id %d",
2104                       d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2105                       get_desc_trans_len(desc), get_desc_mount_id(desc));
2106        if (get_desc_trans_id(desc) < oldest_trans_id) {
2107                reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1039: "
2108                               "journal_read_trans skipping because %lu is too old",
2109                               cur_dblock -
2110                               SB_ONDISK_JOURNAL_1st_BLOCK(sb));
2111                brelse(d_bh);
2112                return 1;
2113        }
2114        if (get_desc_mount_id(desc) != newest_mount_id) {
2115                reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1146: "
2116                               "journal_read_trans skipping because %d is != "
2117                               "newest_mount_id %lu", get_desc_mount_id(desc),
2118                               newest_mount_id);
2119                brelse(d_bh);
2120                return 1;
2121        }
2122        c_bh = journal_bread(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2123                             ((trans_offset + get_desc_trans_len(desc) + 1) %
2124                              SB_ONDISK_JOURNAL_SIZE(sb)));
2125        if (!c_bh) {
2126                brelse(d_bh);
2127                return 1;
2128        }
2129        commit = (struct reiserfs_journal_commit *)c_bh->b_data;
2130        if (journal_compare_desc_commit(sb, desc, commit)) {
2131                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2132                               "journal_read_transaction, "
2133                               "commit offset %llu had bad time %d or length %d",
2134                               c_bh->b_blocknr -
2135                               SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2136                               get_commit_trans_id(commit),
2137                               get_commit_trans_len(commit));
2138                brelse(c_bh);
2139                brelse(d_bh);
2140                return 1;
2141        }
2142
2143        if (bdev_read_only(sb->s_bdev)) {
2144                reiserfs_warning(sb, "clm-2076",
2145                                 "device is readonly, unable to replay log");
2146                brelse(c_bh);
2147                brelse(d_bh);
2148                return -EROFS;
2149        }
2150
2151        trans_id = get_desc_trans_id(desc);
2152        /* now we know we've got a good transaction, and it was inside the valid time ranges */
2153        log_blocks = kmalloc(get_desc_trans_len(desc) *
2154                             sizeof(struct buffer_head *), GFP_NOFS);
2155        real_blocks = kmalloc(get_desc_trans_len(desc) *
2156                              sizeof(struct buffer_head *), GFP_NOFS);
2157        if (!log_blocks || !real_blocks) {
2158                brelse(c_bh);
2159                brelse(d_bh);
2160                kfree(log_blocks);
2161                kfree(real_blocks);
2162                reiserfs_warning(sb, "journal-1169",
2163                                 "kmalloc failed, unable to mount FS");
2164                return -1;
2165        }
2166        /* get all the buffer heads */
2167        trans_half = journal_trans_half(sb->s_blocksize);
2168        for (i = 0; i < get_desc_trans_len(desc); i++) {
2169                log_blocks[i] =
2170                    journal_getblk(sb,
2171                                   SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2172                                   (trans_offset + 1 +
2173                                    i) % SB_ONDISK_JOURNAL_SIZE(sb));
2174                if (i < trans_half) {
2175                        real_blocks[i] =
2176                            sb_getblk(sb,
2177                                      le32_to_cpu(desc->j_realblock[i]));
2178                } else {
2179                        real_blocks[i] =
2180                            sb_getblk(sb,
2181                                      le32_to_cpu(commit->
2182                                                  j_realblock[i - trans_half]));
2183                }
2184                if (real_blocks[i]->b_blocknr > SB_BLOCK_COUNT(sb)) {
2185                        reiserfs_warning(sb, "journal-1207",
2186                                         "REPLAY FAILURE fsck required! "
2187                                         "Block to replay is outside of "
2188                                         "filesystem");
2189                        goto abort_replay;
2190                }
2191                /* make sure we don't try to replay onto log or reserved area */
2192                if (is_block_in_log_or_reserved_area
2193                    (sb, real_blocks[i]->b_blocknr)) {
2194                        reiserfs_warning(sb, "journal-1204",
2195                                         "REPLAY FAILURE fsck required! "
2196                                         "Trying to replay onto a log block");
2197                      abort_replay:
2198                        brelse_array(log_blocks, i);
2199                        brelse_array(real_blocks, i);
2200                        brelse(c_bh);
2201                        brelse(d_bh);
2202                        kfree(log_blocks);
2203                        kfree(real_blocks);
2204                        return -1;
2205                }
2206        }
2207        /* read in the log blocks, memcpy to the corresponding real block */
2208        ll_rw_block(READ, get_desc_trans_len(desc), log_blocks);
2209        for (i = 0; i < get_desc_trans_len(desc); i++) {
2210
2211                reiserfs_write_unlock(sb);
2212                wait_on_buffer(log_blocks[i]);
2213                reiserfs_write_lock(sb);
2214
2215                if (!buffer_uptodate(log_blocks[i])) {
2216                        reiserfs_warning(sb, "journal-1212",
2217                                         "REPLAY FAILURE fsck required! "
2218                                         "buffer write failed");
2219                        brelse_array(log_blocks + i,
2220                                     get_desc_trans_len(desc) - i);
2221                        brelse_array(real_blocks, get_desc_trans_len(desc));
2222                        brelse(c_bh);
2223                        brelse(d_bh);
2224                        kfree(log_blocks);
2225                        kfree(real_blocks);
2226                        return -1;
2227                }
2228                memcpy(real_blocks[i]->b_data, log_blocks[i]->b_data,
2229                       real_blocks[i]->b_size);
2230                set_buffer_uptodate(real_blocks[i]);
2231                brelse(log_blocks[i]);
2232        }
2233        /* flush out the real blocks */
2234        for (i = 0; i < get_desc_trans_len(desc); i++) {
2235                set_buffer_dirty(real_blocks[i]);
2236                write_dirty_buffer(real_blocks[i], WRITE);
2237        }
2238        for (i = 0; i < get_desc_trans_len(desc); i++) {
2239                wait_on_buffer(real_blocks[i]);
2240                if (!buffer_uptodate(real_blocks[i])) {
2241                        reiserfs_warning(sb, "journal-1226",
2242                                         "REPLAY FAILURE, fsck required! "
2243                                         "buffer write failed");
2244                        brelse_array(real_blocks + i,
2245                                     get_desc_trans_len(desc) - i);
2246                        brelse(c_bh);
2247                        brelse(d_bh);
2248                        kfree(log_blocks);
2249                        kfree(real_blocks);
2250                        return -1;
2251                }
2252                brelse(real_blocks[i]);
2253        }
2254        cur_dblock =
2255            SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2256            ((trans_offset + get_desc_trans_len(desc) +
2257              2) % SB_ONDISK_JOURNAL_SIZE(sb));
2258        reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2259                       "journal-1095: setting journal " "start to offset %ld",
2260                       cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb));
2261
2262        /* init starting values for the first transaction, in case this is the last transaction to be replayed. */
2263        journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2264        journal->j_last_flush_trans_id = trans_id;
2265        journal->j_trans_id = trans_id + 1;
2266        /* check for trans_id overflow */
2267        if (journal->j_trans_id == 0)
2268                journal->j_trans_id = 10;
2269        brelse(c_bh);
2270        brelse(d_bh);
2271        kfree(log_blocks);
2272        kfree(real_blocks);
2273        return 0;
2274}
2275
2276/* This function reads blocks starting from block and to max_block of bufsize
2277   size (but no more than BUFNR blocks at a time). This proved to improve
2278   mounting speed on self-rebuilding raid5 arrays at least.
2279   Right now it is only used from journal code. But later we might use it
2280   from other places.
2281   Note: Do not use journal_getblk/sb_getblk functions here! */
2282static struct buffer_head *reiserfs_breada(struct block_device *dev,
2283                                           b_blocknr_t block, int bufsize,
2284                                           b_blocknr_t max_block)
2285{
2286        struct buffer_head *bhlist[BUFNR];
2287        unsigned int blocks = BUFNR;
2288        struct buffer_head *bh;
2289        int i, j;
2290
2291        bh = __getblk(dev, block, bufsize);
2292        if (buffer_uptodate(bh))
2293                return (bh);
2294
2295        if (block + BUFNR > max_block) {
2296                blocks = max_block - block;
2297        }
2298        bhlist[0] = bh;
2299        j = 1;
2300        for (i = 1; i < blocks; i++) {
2301                bh = __getblk(dev, block + i, bufsize);
2302                if (buffer_uptodate(bh)) {
2303                        brelse(bh);
2304                        break;
2305                } else
2306                        bhlist[j++] = bh;
2307        }
2308        ll_rw_block(READ, j, bhlist);
2309        for (i = 1; i < j; i++)
2310                brelse(bhlist[i]);
2311        bh = bhlist[0];
2312        wait_on_buffer(bh);
2313        if (buffer_uptodate(bh))
2314                return bh;
2315        brelse(bh);
2316        return NULL;
2317}
2318
2319/*
2320** read and replay the log
2321** on a clean unmount, the journal header's next unflushed pointer will be to an invalid
2322** transaction.  This tests that before finding all the transactions in the log, which makes normal mount times fast.
2323**
2324** After a crash, this starts with the next unflushed transaction, and replays until it finds one too old, or invalid.
2325**
2326** On exit, it sets things up so the first transaction will work correctly.
2327*/
2328static int journal_read(struct super_block *sb)
2329{
2330        struct reiserfs_journal *journal = SB_JOURNAL(sb);
2331        struct reiserfs_journal_desc *desc;
2332        unsigned int oldest_trans_id = 0;
2333        unsigned int oldest_invalid_trans_id = 0;
2334        time_t start;
2335        unsigned long oldest_start = 0;
2336        unsigned long cur_dblock = 0;
2337        unsigned long newest_mount_id = 9;
2338        struct buffer_head *d_bh;
2339        struct reiserfs_journal_header *jh;
2340        int valid_journal_header = 0;
2341        int replay_count = 0;
2342        int continue_replay = 1;
2343        int ret;
2344        char b[BDEVNAME_SIZE];
2345
2346        cur_dblock = SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2347        reiserfs_info(sb, "checking transaction log (%s)\n",
2348                      bdevname(journal->j_dev_bd, b));
2349        start = get_seconds();
2350
2351        /* step 1, read in the journal header block.  Check the transaction it says
2352         ** is the first unflushed, and if that transaction is not valid,
2353         ** replay is done
2354         */
2355        journal->j_header_bh = journal_bread(sb,
2356                                             SB_ONDISK_JOURNAL_1st_BLOCK(sb)
2357                                             + SB_ONDISK_JOURNAL_SIZE(sb));
2358        if (!journal->j_header_bh) {
2359                return 1;
2360        }
2361        jh = (struct reiserfs_journal_header *)(journal->j_header_bh->b_data);
2362        if (le32_to_cpu(jh->j_first_unflushed_offset) <
2363            SB_ONDISK_JOURNAL_SIZE(sb)
2364            && le32_to_cpu(jh->j_last_flush_trans_id) > 0) {
2365                oldest_start =
2366                    SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2367                    le32_to_cpu(jh->j_first_unflushed_offset);
2368                oldest_trans_id = le32_to_cpu(jh->j_last_flush_trans_id) + 1;
2369                newest_mount_id = le32_to_cpu(jh->j_mount_id);
2370                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2371                               "journal-1153: found in "
2372                               "header: first_unflushed_offset %d, last_flushed_trans_id "
2373                               "%lu", le32_to_cpu(jh->j_first_unflushed_offset),
2374                               le32_to_cpu(jh->j_last_flush_trans_id));
2375                valid_journal_header = 1;
2376
2377                /* now, we try to read the first unflushed offset.  If it is not valid,
2378                 ** there is nothing more we can do, and it makes no sense to read
2379                 ** through the whole log.
2380                 */
2381                d_bh =
2382                    journal_bread(sb,
2383                                  SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2384                                  le32_to_cpu(jh->j_first_unflushed_offset));
2385                ret = journal_transaction_is_valid(sb, d_bh, NULL, NULL);
2386                if (!ret) {
2387                        continue_replay = 0;
2388                }
2389                brelse(d_bh);
2390                goto start_log_replay;
2391        }
2392
2393        /* ok, there are transactions that need to be replayed.  start with the first log block, find
2394         ** all the valid transactions, and pick out the oldest.
2395         */
2396        while (continue_replay
2397               && cur_dblock <
2398               (SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2399                SB_ONDISK_JOURNAL_SIZE(sb))) {
2400                /* Note that it is required for blocksize of primary fs device and journal
2401                   device to be the same */
2402                d_bh =
2403                    reiserfs_breada(journal->j_dev_bd, cur_dblock,
2404                                    sb->s_blocksize,
2405                                    SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2406                                    SB_ONDISK_JOURNAL_SIZE(sb));
2407                ret =
2408                    journal_transaction_is_valid(sb, d_bh,
2409                                                 &oldest_invalid_trans_id,
2410                                                 &newest_mount_id);
2411                if (ret == 1) {
2412                        desc = (struct reiserfs_journal_desc *)d_bh->b_data;
2413                        if (oldest_start == 0) {        /* init all oldest_ values */
2414                                oldest_trans_id = get_desc_trans_id(desc);
2415                                oldest_start = d_bh->b_blocknr;
2416                                newest_mount_id = get_desc_mount_id(desc);
2417                                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2418                                               "journal-1179: Setting "
2419                                               "oldest_start to offset %llu, trans_id %lu",
2420                                               oldest_start -
2421                                               SB_ONDISK_JOURNAL_1st_BLOCK
2422                                               (sb), oldest_trans_id);
2423                        } else if (oldest_trans_id > get_desc_trans_id(desc)) {
2424                                /* one we just read was older */
2425                                oldest_trans_id = get_desc_trans_id(desc);
2426                                oldest_start = d_bh->b_blocknr;
2427                                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2428                                               "journal-1180: Resetting "
2429                                               "oldest_start to offset %lu, trans_id %lu",
2430                                               oldest_start -
2431                                               SB_ONDISK_JOURNAL_1st_BLOCK
2432                                               (sb), oldest_trans_id);
2433                        }
2434                        if (newest_mount_id < get_desc_mount_id(desc)) {
2435                                newest_mount_id = get_desc_mount_id(desc);
2436                                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2437                                               "journal-1299: Setting "
2438                                               "newest_mount_id to %d",
2439                                               get_desc_mount_id(desc));
2440                        }
2441                        cur_dblock += get_desc_trans_len(desc) + 2;
2442                } else {
2443                        cur_dblock++;
2444                }
2445                brelse(d_bh);
2446        }
2447
2448      start_log_replay:
2449        cur_dblock = oldest_start;
2450        if (oldest_trans_id) {
2451                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2452                               "journal-1206: Starting replay "
2453                               "from offset %llu, trans_id %lu",
2454                               cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2455                               oldest_trans_id);
2456
2457        }
2458        replay_count = 0;
2459        while (continue_replay && oldest_trans_id > 0) {
2460                ret =
2461                    journal_read_transaction(sb, cur_dblock, oldest_start,
2462                                             oldest_trans_id, newest_mount_id);
2463                if (ret < 0) {
2464                        return ret;
2465                } else if (ret != 0) {
2466                        break;
2467                }
2468                cur_dblock =
2469                    SB_ONDISK_JOURNAL_1st_BLOCK(sb) + journal->j_start;
2470                replay_count++;
2471                if (cur_dblock == oldest_start)
2472                        break;
2473        }
2474
2475        if (oldest_trans_id == 0) {
2476                reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2477                               "journal-1225: No valid " "transactions found");
2478        }
2479        /* j_start does not get set correctly if we don't replay any transactions.
2480         ** if we had a valid journal_header, set j_start to the first unflushed transaction value,
2481         ** copy the trans_id from the header
2482         */
2483        if (valid_journal_header && replay_count == 0) {
2484                journal->j_start = le32_to_cpu(jh->j_first_unflushed_offset);
2485                journal->j_trans_id =
2486                    le32_to_cpu(jh->j_last_flush_trans_id) + 1;
2487                /* check for trans_id overflow */
2488                if (journal->j_trans_id == 0)
2489                        journal->j_trans_id = 10;
2490                journal->j_last_flush_trans_id =
2491                    le32_to_cpu(jh->j_last_flush_trans_id);
2492                journal->j_mount_id = le32_to_cpu(jh->j_mount_id) + 1;
2493        } else {
2494                journal->j_mount_id = newest_mount_id + 1;
2495        }
2496        reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1299: Setting "
2497                       "newest_mount_id to %lu", journal->j_mount_id);
2498        journal->j_first_unflushed_offset = journal->j_start;
2499        if (replay_count > 0) {
2500                reiserfs_info(sb,
2501                              "replayed %d transactions in %lu seconds\n",
2502                              replay_count, get_seconds() - start);
2503        }
2504        if (!bdev_read_only(sb->s_bdev) &&
2505            _update_journal_header_block(sb, journal->j_start,
2506                                         journal->j_last_flush_trans_id)) {
2507                /* replay failed, caller must call free_journal_ram and abort
2508                 ** the mount
2509                 */
2510                return -1;
2511        }
2512        return 0;
2513}
2514
2515static struct reiserfs_journal_list *alloc_journal_list(struct super_block *s)
2516{
2517        struct reiserfs_journal_list *jl;
2518        jl = kzalloc(sizeof(struct reiserfs_journal_list),
2519                     GFP_NOFS | __GFP_NOFAIL);
2520        INIT_LIST_HEAD(&jl->j_list);
2521        INIT_LIST_HEAD(&jl->j_working_list);
2522        INIT_LIST_HEAD(&jl->j_tail_bh_list);
2523        INIT_LIST_HEAD(&jl->j_bh_list);
2524        mutex_init(&jl->j_commit_mutex);
2525        SB_JOURNAL(s)->j_num_lists++;
2526        get_journal_list(jl);
2527        return jl;
2528}
2529
2530static void journal_list_init(struct super_block *sb)
2531{
2532        SB_JOURNAL(sb)->j_current_jl = alloc_journal_list(sb);
2533}
2534
2535static int release_journal_dev(struct super_block *super,
2536                               struct reiserfs_journal *journal)
2537{
2538        int result;
2539
2540        result = 0;
2541
2542        if (journal->j_dev_bd != NULL) {
2543                result = blkdev_put(journal->j_dev_bd, journal->j_dev_mode);
2544                journal->j_dev_bd = NULL;
2545        }
2546
2547        if (result != 0) {
2548                reiserfs_warning(super, "sh-457",
2549                                 "Cannot release journal device: %i", result);
2550        }
2551        return result;
2552}
2553
2554static int journal_init_dev(struct super_block *super,
2555                            struct reiserfs_journal *journal,
2556                            const char *jdev_name)
2557{
2558        int result;
2559        dev_t jdev;
2560        fmode_t blkdev_mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
2561        char b[BDEVNAME_SIZE];
2562
2563        result = 0;
2564
2565        journal->j_dev_bd = NULL;
2566        jdev = SB_ONDISK_JOURNAL_DEVICE(super) ?
2567            new_decode_dev(SB_ONDISK_JOURNAL_DEVICE(super)) : super->s_dev;
2568
2569        if (bdev_read_only(super->s_bdev))
2570                blkdev_mode = FMODE_READ;
2571
2572        /* there is no "jdev" option and journal is on separate device */
2573        if ((!jdev_name || !jdev_name[0])) {
2574                if (jdev == super->s_dev)
2575                        blkdev_mode &= ~FMODE_EXCL;
2576                journal->j_dev_bd = blkdev_get_by_dev(jdev, blkdev_mode,
2577                                                      journal);
2578                journal->j_dev_mode = blkdev_mode;
2579                if (IS_ERR(journal->j_dev_bd)) {
2580                        result = PTR_ERR(journal->j_dev_bd);
2581                        journal->j_dev_bd = NULL;
2582                        reiserfs_warning(super, "sh-458",
2583                                         "cannot init journal device '%s': %i",
2584                                         __bdevname(jdev, b), result);
2585                        return result;
2586                } else if (jdev != super->s_dev)
2587                        set_blocksize(journal->j_dev_bd, super->s_blocksize);
2588
2589                return 0;
2590        }
2591
2592        journal->j_dev_mode = blkdev_mode;
2593        journal->j_dev_bd = blkdev_get_by_path(jdev_name, blkdev_mode, journal);
2594        if (IS_ERR(journal->j_dev_bd)) {
2595                result = PTR_ERR(journal->j_dev_bd);
2596                journal->j_dev_bd = NULL;
2597                reiserfs_warning(super,
2598                                 "journal_init_dev: Cannot open '%s': %i",
2599                                 jdev_name, result);
2600                return result;
2601        }
2602
2603        set_blocksize(journal->j_dev_bd, super->s_blocksize);
2604        reiserfs_info(super,
2605                      "journal_init_dev: journal device: %s\n",
2606                      bdevname(journal->j_dev_bd, b));
2607        return 0;
2608}
2609
2610/**
2611 * When creating/tuning a file system user can assign some
2612 * journal params within boundaries which depend on the ratio
2613 * blocksize/standard_blocksize.
2614 *
2615 * For blocks >= standard_blocksize transaction size should
2616 * be not less then JOURNAL_TRANS_MIN_DEFAULT, and not more
2617 * then JOURNAL_TRANS_MAX_DEFAULT.
2618 *
2619 * For blocks < standard_blocksize these boundaries should be
2620 * decreased proportionally.
2621 */
2622#define REISERFS_STANDARD_BLKSIZE (4096)
2623
2624static int check_advise_trans_params(struct super_block *sb,
2625                                     struct reiserfs_journal *journal)
2626{
2627        if (journal->j_trans_max) {
2628                /* Non-default journal params.
2629                   Do sanity check for them. */
2630                int ratio = 1;
2631                if (sb->s_blocksize < REISERFS_STANDARD_BLKSIZE)
2632                        ratio = REISERFS_STANDARD_BLKSIZE / sb->s_blocksize;
2633
2634                if (journal->j_trans_max > JOURNAL_TRANS_MAX_DEFAULT / ratio ||
2635                    journal->j_trans_max < JOURNAL_TRANS_MIN_DEFAULT / ratio ||
2636                    SB_ONDISK_JOURNAL_SIZE(sb) / journal->j_trans_max <
2637                    JOURNAL_MIN_RATIO) {
2638                        reiserfs_warning(sb, "sh-462",
2639                                         "bad transaction max size (%u). "
2640                                         "FSCK?", journal->j_trans_max);
2641                        return 1;
2642                }
2643                if (journal->j_max_batch != (journal->j_trans_max) *
2644                        JOURNAL_MAX_BATCH_DEFAULT/JOURNAL_TRANS_MAX_DEFAULT) {
2645                        reiserfs_warning(sb, "sh-463",
2646                                         "bad transaction max batch (%u). "
2647                                         "FSCK?", journal->j_max_batch);
2648                        return 1;
2649                }
2650        } else {
2651                /* Default journal params.
2652                   The file system was created by old version
2653                   of mkreiserfs, so some fields contain zeros,
2654                   and we need to advise proper values for them */
2655                if (sb->s_blocksize != REISERFS_STANDARD_BLKSIZE) {
2656                        reiserfs_warning(sb, "sh-464", "bad blocksize (%u)",
2657                                         sb->s_blocksize);
2658                        return 1;
2659                }
2660                journal->j_trans_max = JOURNAL_TRANS_MAX_DEFAULT;
2661                journal->j_max_batch = JOURNAL_MAX_BATCH_DEFAULT;
2662                journal->j_max_commit_age = JOURNAL_MAX_COMMIT_AGE;
2663        }
2664        return 0;
2665}
2666
2667/*
2668** must be called once on fs mount.  calls journal_read for you
2669*/
2670int journal_init(struct super_block *sb, const char *j_dev_name,
2671                 int old_format, unsigned int commit_max_age)
2672{
2673        int num_cnodes = SB_ONDISK_JOURNAL_SIZE(sb) * 2;
2674        struct buffer_head *bhjh;
2675        struct reiserfs_super_block *rs;
2676        struct reiserfs_journal_header *jh;
2677        struct reiserfs_journal *journal;
2678        struct reiserfs_journal_list *jl;
2679        char b[BDEVNAME_SIZE];
2680        int ret;
2681
2682        journal = SB_JOURNAL(sb) = vzalloc(sizeof(struct reiserfs_journal));
2683        if (!journal) {
2684                reiserfs_warning(sb, "journal-1256",
2685                                 "unable to get memory for journal structure");
2686                return 1;
2687        }
2688        INIT_LIST_HEAD(&journal->j_bitmap_nodes);
2689        INIT_LIST_HEAD(&journal->j_prealloc_list);
2690        INIT_LIST_HEAD(&journal->j_working_list);
2691        INIT_LIST_HEAD(&journal->j_journal_list);
2692        journal->j_persistent_trans = 0;
2693        if (reiserfs_allocate_list_bitmaps(sb, journal->j_list_bitmap,
2694                                           reiserfs_bmap_count(sb)))
2695                goto free_and_return;
2696
2697        allocate_bitmap_nodes(sb);
2698
2699        /* reserved for journal area support */
2700        SB_JOURNAL_1st_RESERVED_BLOCK(sb) = (old_format ?
2701                                                 REISERFS_OLD_DISK_OFFSET_IN_BYTES
2702                                                 / sb->s_blocksize +
2703                                                 reiserfs_bmap_count(sb) +
2704                                                 1 :
2705                                                 REISERFS_DISK_OFFSET_IN_BYTES /
2706                                                 sb->s_blocksize + 2);
2707
2708        /* Sanity check to see is the standard journal fitting within first bitmap
2709           (actual for small blocksizes) */
2710        if (!SB_ONDISK_JOURNAL_DEVICE(sb) &&
2711            (SB_JOURNAL_1st_RESERVED_BLOCK(sb) +
2712             SB_ONDISK_JOURNAL_SIZE(sb) > sb->s_blocksize * 8)) {
2713                reiserfs_warning(sb, "journal-1393",
2714                                 "journal does not fit for area addressed "
2715                                 "by first of bitmap blocks. It starts at "
2716                                 "%u and its size is %u. Block size %ld",
2717                                 SB_JOURNAL_1st_RESERVED_BLOCK(sb),
2718                                 SB_ONDISK_JOURNAL_SIZE(sb),
2719                                 sb->s_blocksize);
2720                goto free_and_return;
2721        }
2722
2723        if (journal_init_dev(sb, journal, j_dev_name) != 0) {
2724                reiserfs_warning(sb, "sh-462",
2725                                 "unable to initialize jornal device");
2726                goto free_and_return;
2727        }
2728
2729        rs = SB_DISK_SUPER_BLOCK(sb);
2730
2731        /* read journal header */
2732        bhjh = journal_bread(sb,
2733                             SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2734                             SB_ONDISK_JOURNAL_SIZE(sb));
2735        if (!bhjh) {
2736                reiserfs_warning(sb, "sh-459",
2737                                 "unable to read journal header");
2738                goto free_and_return;
2739        }
2740        jh = (struct reiserfs_journal_header *)(bhjh->b_data);
2741
2742        /* make sure that journal matches to the super block */
2743        if (is_reiserfs_jr(rs)
2744            && (le32_to_cpu(jh->jh_journal.jp_journal_magic) !=
2745                sb_jp_journal_magic(rs))) {
2746                reiserfs_warning(sb, "sh-460",
2747                                 "journal header magic %x (device %s) does "
2748                                 "not match to magic found in super block %x",
2749                                 jh->jh_journal.jp_journal_magic,
2750                                 bdevname(journal->j_dev_bd, b),
2751                                 sb_jp_journal_magic(rs));
2752                brelse(bhjh);
2753                goto free_and_return;
2754        }
2755
2756        journal->j_trans_max = le32_to_cpu(jh->jh_journal.jp_journal_trans_max);
2757        journal->j_max_batch = le32_to_cpu(jh->jh_journal.jp_journal_max_batch);
2758        journal->j_max_commit_age =
2759            le32_to_cpu(jh->jh_journal.jp_journal_max_commit_age);
2760        journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
2761
2762        if (check_advise_trans_params(sb, journal) != 0)
2763                goto free_and_return;
2764        journal->j_default_max_commit_age = journal->j_max_commit_age;
2765
2766        if (commit_max_age != 0) {
2767                journal->j_max_commit_age = commit_max_age;
2768                journal->j_max_trans_age = commit_max_age;
2769        }
2770
2771        reiserfs_info(sb, "journal params: device %s, size %u, "
2772                      "journal first block %u, max trans len %u, max batch %u, "
2773                      "max commit age %u, max trans age %u\n",
2774                      bdevname(journal->j_dev_bd, b),
2775                      SB_ONDISK_JOURNAL_SIZE(sb),
2776                      SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2777                      journal->j_trans_max,
2778                      journal->j_max_batch,
2779                      journal->j_max_commit_age, journal->j_max_trans_age);
2780
2781        brelse(bhjh);
2782
2783        journal->j_list_bitmap_index = 0;
2784        journal_list_init(sb);
2785
2786        memset(journal->j_list_hash_table, 0,
2787               JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *));
2788
2789        INIT_LIST_HEAD(&journal->j_dirty_buffers);
2790        spin_lock_init(&journal->j_dirty_buffers_lock);
2791
2792        journal->j_start = 0;
2793        journal->j_len = 0;
2794        journal->j_len_alloc = 0;
2795        atomic_set(&(journal->j_wcount), 0);
2796        atomic_set(&(journal->j_async_throttle), 0);
2797        journal->j_bcount = 0;
2798        journal->j_trans_start_time = 0;
2799        journal->j_last = NULL;
2800        journal->j_first = NULL;
2801        init_waitqueue_head(&(journal->j_join_wait));
2802        mutex_init(&journal->j_mutex);
2803        mutex_init(&journal->j_flush_mutex);
2804
2805        journal->j_trans_id = 10;
2806        journal->j_mount_id = 10;
2807        journal->j_state = 0;
2808        atomic_set(&(journal->j_jlock), 0);
2809        journal->j_cnode_free_list = allocate_cnodes(num_cnodes);
2810        journal->j_cnode_free_orig = journal->j_cnode_free_list;
2811        journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0;
2812        journal->j_cnode_used = 0;
2813        journal->j_must_wait = 0;
2814
2815        if (journal->j_cnode_free == 0) {
2816                reiserfs_warning(sb, "journal-2004", "Journal cnode memory "
2817                                 "allocation failed (%ld bytes). Journal is "
2818                                 "too large for available memory. Usually "
2819                                 "this is due to a journal that is too large.",
2820                                 sizeof (struct reiserfs_journal_cnode) * num_cnodes);
2821                goto free_and_return;
2822        }
2823
2824        init_journal_hash(sb);
2825        jl = journal->j_current_jl;
2826
2827        /*
2828         * get_list_bitmap() may call flush_commit_list() which
2829         * requires the lock. Calling flush_commit_list() shouldn't happen
2830         * this early but I like to be paranoid.
2831         */
2832        reiserfs_write_lock(sb);
2833        jl->j_list_bitmap = get_list_bitmap(sb, jl);
2834        reiserfs_write_unlock(sb);
2835        if (!jl->j_list_bitmap) {
2836                reiserfs_warning(sb, "journal-2005",
2837                                 "get_list_bitmap failed for journal list 0");
2838                goto free_and_return;
2839        }
2840
2841        /*
2842         * Journal_read needs to be inspected in order to push down
2843         * the lock further inside (or even remove it).
2844         */
2845        reiserfs_write_lock(sb);
2846        ret = journal_read(sb);
2847        reiserfs_write_unlock(sb);
2848        if (ret < 0) {
2849                reiserfs_warning(sb, "reiserfs-2006",
2850                                 "Replay Failure, unable to mount");
2851                goto free_and_return;
2852        }
2853
2854        reiserfs_mounted_fs_count++;
2855        if (reiserfs_mounted_fs_count <= 1)
2856                commit_wq = alloc_workqueue("reiserfs", WQ_MEM_RECLAIM, 0);
2857
2858        INIT_DELAYED_WORK(&journal->j_work, flush_async_commits);
2859        journal->j_work_sb = sb;
2860        return 0;
2861      free_and_return:
2862        free_journal_ram(sb);
2863        return 1;
2864}
2865
2866/*
2867** test for a polite end of the current transaction.  Used by file_write, and should
2868** be used by delete to make sure they don't write more than can fit inside a single
2869** transaction
2870*/
2871int journal_transaction_should_end(struct reiserfs_transaction_handle *th,
2872                                   int new_alloc)
2873{
2874        struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
2875        time_t now = get_seconds();
2876        /* cannot restart while nested */
2877        BUG_ON(!th->t_trans_id);
2878        if (th->t_refcount > 1)
2879                return 0;
2880        if (journal->j_must_wait > 0 ||
2881            (journal->j_len_alloc + new_alloc) >= journal->j_max_batch ||
2882            atomic_read(&(journal->j_jlock)) ||
2883            (now - journal->j_trans_start_time) > journal->j_max_trans_age ||
2884            journal->j_cnode_free < (journal->j_trans_max * 3)) {
2885                return 1;
2886        }
2887
2888        journal->j_len_alloc += new_alloc;
2889        th->t_blocks_allocated += new_alloc ;
2890        return 0;
2891}
2892
2893/* this must be called inside a transaction
2894*/
2895void reiserfs_block_writes(struct reiserfs_transaction_handle *th)
2896{
2897        struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
2898        BUG_ON(!th->t_trans_id);
2899        journal->j_must_wait = 1;
2900        set_bit(J_WRITERS_BLOCKED, &journal->j_state);
2901        return;
2902}
2903
2904/* this must be called without a transaction started
2905*/
2906void reiserfs_allow_writes(struct super_block *s)
2907{
2908        struct reiserfs_journal *journal = SB_JOURNAL(s);
2909        clear_bit(J_WRITERS_BLOCKED, &journal->j_state);
2910        wake_up(&journal->j_join_wait);
2911}
2912
2913/* this must be called without a transaction started
2914*/
2915void reiserfs_wait_on_write_block(struct super_block *s)
2916{
2917        struct reiserfs_journal *journal = SB_JOURNAL(s);
2918        wait_event(journal->j_join_wait,
2919                   !test_bit(J_WRITERS_BLOCKED, &journal->j_state));
2920}
2921
2922static void queue_log_writer(struct super_block *s)
2923{
2924        wait_queue_t wait;
2925        struct reiserfs_journal *journal = SB_JOURNAL(s);
2926        set_bit(J_WRITERS_QUEUED, &journal->j_state);
2927
2928        /*
2929         * we don't want to use wait_event here because
2930         * we only want to wait once.
2931         */
2932        init_waitqueue_entry(&wait, current);
2933        add_wait_queue(&journal->j_join_wait, &wait);
2934        set_current_state(TASK_UNINTERRUPTIBLE);
2935        if (test_bit(J_WRITERS_QUEUED, &journal->j_state)) {
2936                reiserfs_write_unlock(s);
2937                schedule();
2938                reiserfs_write_lock(s);
2939        }
2940        __set_current_state(TASK_RUNNING);
2941        remove_wait_queue(&journal->j_join_wait, &wait);
2942}
2943
2944static void wake_queued_writers(struct super_block *s)
2945{
2946        struct reiserfs_journal *journal = SB_JOURNAL(s);
2947        if (test_and_clear_bit(J_WRITERS_QUEUED, &journal->j_state))
2948                wake_up(&journal->j_join_wait);
2949}
2950
2951static void let_transaction_grow(struct super_block *sb, unsigned int trans_id)
2952{
2953        struct reiserfs_journal *journal = SB_JOURNAL(sb);
2954        unsigned long bcount = journal->j_bcount;
2955        while (1) {
2956                reiserfs_write_unlock(sb);
2957                schedule_timeout_uninterruptible(1);
2958                reiserfs_write_lock(sb);
2959                journal->j_current_jl->j_state |= LIST_COMMIT_PENDING;
2960                while ((atomic_read(&journal->j_wcount) > 0 ||
2961                        atomic_read(&journal->j_jlock)) &&
2962                       journal->j_trans_id == trans_id) {
2963                        queue_log_writer(sb);
2964                }
2965                if (journal->j_trans_id != trans_id)
2966                        break;
2967                if (bcount == journal->j_bcount)
2968                        break;
2969                bcount = journal->j_bcount;
2970        }
2971}
2972
2973/* join == true if you must join an existing transaction.
2974** join == false if you can deal with waiting for others to finish
2975**
2976** this will block until the transaction is joinable.  send the number of blocks you
2977** expect to use in nblocks.
2978*/
2979static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
2980                              struct super_block *sb, unsigned long nblocks,
2981                              int join)
2982{
2983        time_t now = get_seconds();
2984        unsigned int old_trans_id;
2985        struct reiserfs_journal *journal = SB_JOURNAL(sb);
2986        struct reiserfs_transaction_handle myth;
2987        int sched_count = 0;
2988        int retval;
2989
2990        reiserfs_check_lock_depth(sb, "journal_begin");
2991        BUG_ON(nblocks > journal->j_trans_max);
2992
2993        PROC_INFO_INC(sb, journal.journal_being);
2994        /* set here for journal_join */
2995        th->t_refcount = 1;
2996        th->t_super = sb;
2997
2998      relock:
2999        lock_journal(sb);
3000        if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) {
3001                unlock_journal(sb);
3002                retval = journal->j_errno;
3003                goto out_fail;
3004        }
3005        journal->j_bcount++;
3006
3007        if (test_bit(J_WRITERS_BLOCKED, &journal->j_state)) {
3008                unlock_journal(sb);
3009                reiserfs_write_unlock(sb);
3010                reiserfs_wait_on_write_block(sb);
3011                reiserfs_write_lock(sb);
3012                PROC_INFO_INC(sb, journal.journal_relock_writers);
3013                goto relock;
3014        }
3015        now = get_seconds();
3016
3017        /* if there is no room in the journal OR
3018         ** if this transaction is too old, and we weren't called joinable, wait for it to finish before beginning
3019         ** we don't sleep if there aren't other writers
3020         */
3021
3022        if ((!join && journal->j_must_wait > 0) ||
3023            (!join
3024             && (journal->j_len_alloc + nblocks + 2) >= journal->j_max_batch)
3025            || (!join && atomic_read(&journal->j_wcount) > 0
3026                && journal->j_trans_start_time > 0
3027                && (now - journal->j_trans_start_time) >
3028                journal->j_max_trans_age) || (!join
3029                                              && atomic_read(&journal->j_jlock))
3030            || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) {
3031
3032                old_trans_id = journal->j_trans_id;
3033                unlock_journal(sb);     /* allow others to finish this transaction */
3034
3035                if (!join && (journal->j_len_alloc + nblocks + 2) >=
3036                    journal->j_max_batch &&
3037                    ((journal->j_len + nblocks + 2) * 100) <
3038                    (journal->j_len_alloc * 75)) {
3039                        if (atomic_read(&journal->j_wcount) > 10) {
3040                                sched_count++;
3041                                queue_log_writer(sb);
3042                                goto relock;
3043                        }
3044                }
3045                /* don't mess with joining the transaction if all we have to do is
3046                 * wait for someone else to do a commit
3047                 */
3048                if (atomic_read(&journal->j_jlock)) {
3049                        while (journal->j_trans_id == old_trans_id &&
3050                               atomic_read(&journal->j_jlock)) {
3051                                queue_log_writer(sb);
3052                        }
3053                        goto relock;
3054                }
3055                retval = journal_join(&myth, sb, 1);
3056                if (retval)
3057                        goto out_fail;
3058
3059                /* someone might have ended the transaction while we joined */
3060                if (old_trans_id != journal->j_trans_id) {
3061                        retval = do_journal_end(&myth, sb, 1, 0);
3062                } else {
3063                        retval = do_journal_end(&myth, sb, 1, COMMIT_NOW);
3064                }
3065
3066                if (retval)
3067                        goto out_fail;
3068
3069                PROC_INFO_INC(sb, journal.journal_relock_wcount);
3070                goto relock;
3071        }
3072        /* we are the first writer, set trans_id */
3073        if (journal->j_trans_start_time == 0) {
3074                journal->j_trans_start_time = get_seconds();
3075        }
3076        atomic_inc(&(journal->j_wcount));
3077        journal->j_len_alloc += nblocks;
3078        th->t_blocks_logged = 0;
3079        th->t_blocks_allocated = nblocks;
3080        th->t_trans_id = journal->j_trans_id;
3081        unlock_journal(sb);
3082        INIT_LIST_HEAD(&th->t_list);
3083        return 0;
3084
3085      out_fail:
3086        memset(th, 0, sizeof(*th));
3087        /* Re-set th->t_super, so we can properly keep track of how many
3088         * persistent transactions there are. We need to do this so if this
3089         * call is part of a failed restart_transaction, we can free it later */
3090        th->t_super = sb;
3091        return retval;
3092}
3093
3094struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct
3095                                                                    super_block
3096                                                                    *s,
3097                                                                    int nblocks)
3098{
3099        int ret;
3100        struct reiserfs_transaction_handle *th;
3101
3102        /* if we're nesting into an existing transaction.  It will be
3103         ** persistent on its own
3104         */
3105        if (reiserfs_transaction_running(s)) {
3106                th = current->journal_info;
3107                th->t_refcount++;
3108                BUG_ON(th->t_refcount < 2);
3109                
3110                return th;
3111        }
3112        th = kmalloc(sizeof(struct reiserfs_transaction_handle), GFP_NOFS);
3113        if (!th)
3114                return NULL;
3115        ret = journal_begin(th, s, nblocks);
3116        if (ret) {
3117                kfree(th);
3118                return NULL;
3119        }
3120
3121        SB_JOURNAL(s)->j_persistent_trans++;
3122        return th;
3123}
3124
3125int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *th)
3126{
3127        struct super_block *s = th->t_super;
3128        int ret = 0;
3129        if (th->t_trans_id)
3130                ret = journal_end(th, th->t_super, th->t_blocks_allocated);
3131        else
3132                ret = -EIO;
3133        if (th->t_refcount == 0) {
3134                SB_JOURNAL(s)->j_persistent_trans--;
3135                kfree(th);
3136        }
3137        return ret;
3138}
3139
3140static int journal_join(struct reiserfs_transaction_handle *th,
3141                        struct super_block *sb, unsigned long nblocks)
3142{
3143        struct reiserfs_transaction_handle *cur_th = current->journal_info;
3144
3145        /* this keeps do_journal_end from NULLing out the current->journal_info
3146         ** pointer
3147         */
3148        th->t_handle_save = cur_th;
3149        BUG_ON(cur_th && cur_th->t_refcount > 1);
3150        return do_journal_begin_r(th, sb, nblocks, JBEGIN_JOIN);
3151}
3152
3153int journal_join_abort(struct reiserfs_transaction_handle *th,
3154                       struct super_block *sb, unsigned long nblocks)
3155{
3156        struct reiserfs_transaction_handle *cur_th = current->journal_info;
3157
3158        /* this keeps do_journal_end from NULLing out the current->journal_info
3159         ** pointer
3160         */
3161        th->t_handle_save = cur_th;
3162        BUG_ON(cur_th && cur_th->t_refcount > 1);
3163        return do_journal_begin_r(th, sb, nblocks, JBEGIN_ABORT);
3164}
3165
3166int journal_begin(struct reiserfs_transaction_handle *th,
3167                  struct super_block *sb, unsigned long nblocks)
3168{
3169        struct reiserfs_transaction_handle *cur_th = current->journal_info;
3170        int ret;
3171
3172        th->t_handle_save = NULL;
3173        if (cur_th) {
3174                /* we are nesting into the current transaction */
3175                if (cur_th->t_super == sb) {
3176                        BUG_ON(!cur_th->t_refcount);
3177                        cur_th->t_refcount++;
3178                        memcpy(th, cur_th, sizeof(*th));
3179                        if (th->t_refcount <= 1)
3180                                reiserfs_warning(sb, "reiserfs-2005",
3181                                                 "BAD: refcount <= 1, but "
3182                                                 "journal_info != 0");
3183                        return 0;
3184                } else {
3185                        /* we've ended up with a handle from a different filesystem.
3186                         ** save it and restore on journal_end.  This should never
3187                         ** really happen...
3188                         */
3189                        reiserfs_warning(sb, "clm-2100",
3190                                         "nesting info a different FS");
3191                        th->t_handle_save = current->journal_info;
3192                        current->journal_info = th;
3193                }
3194        } else {
3195                current->journal_info = th;
3196        }
3197        ret = do_journal_begin_r(th, sb, nblocks, JBEGIN_REG);
3198        BUG_ON(current->journal_info != th);
3199
3200        /* I guess this boils down to being the reciprocal of clm-2100 above.
3201         * If do_journal_begin_r fails, we need to put it back, since journal_end
3202         * won't be called to do it. */
3203        if (ret)
3204                current->journal_info = th->t_handle_save;
3205        else
3206                BUG_ON(!th->t_refcount);
3207
3208        return ret;
3209}
3210
3211/*
3212** puts bh into the current transaction.  If it was already there, reorders removes the
3213** old pointers from the hash, and puts new ones in (to make sure replay happen in the right order).
3214**
3215** if it was dirty, cleans and files onto the clean list.  I can't let it be dirty again until the
3216** transaction is committed.
3217**
3218** if j_len, is bigger than j_len_alloc, it pushes j_len_alloc to 10 + j_len.
3219*/
3220int journal_mark_dirty(struct reiserfs_transaction_handle *th,
3221                       struct super_block *sb, struct buffer_head *bh)
3222{
3223        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3224        struct reiserfs_journal_cnode *cn = NULL;
3225        int count_already_incd = 0;
3226        int prepared = 0;
3227        BUG_ON(!th->t_trans_id);
3228
3229        PROC_INFO_INC(sb, journal.mark_dirty);
3230        if (th->t_trans_id != journal->j_trans_id) {
3231                reiserfs_panic(th->t_super, "journal-1577",
3232                               "handle trans id %ld != current trans id %ld",
3233                               th->t_trans_id, journal->j_trans_id);
3234        }
3235
3236        prepared = test_clear_buffer_journal_prepared(bh);
3237        clear_buffer_journal_restore_dirty(bh);
3238        /* already in this transaction, we are done */
3239        if (buffer_journaled(bh)) {
3240                PROC_INFO_INC(sb, journal.mark_dirty_already);
3241                return 0;
3242        }
3243
3244        /* this must be turned into a panic instead of a warning.  We can't allow
3245         ** a dirty or journal_dirty or locked buffer to be logged, as some changes
3246         ** could get to disk too early.  NOT GOOD.
3247         */
3248        if (!prepared || buffer_dirty(bh)) {
3249                reiserfs_warning(sb, "journal-1777",
3250                                 "buffer %llu bad state "
3251                                 "%cPREPARED %cLOCKED %cDIRTY %cJDIRTY_WAIT",
3252                                 (unsigned long long)bh->b_blocknr,
3253                                 prepared ? ' ' : '!',
3254                                 buffer_locked(bh) ? ' ' : '!',
3255                                 buffer_dirty(bh) ? ' ' : '!',
3256                                 buffer_journal_dirty(bh) ? ' ' : '!');
3257        }
3258
3259        if (atomic_read(&(journal->j_wcount)) <= 0) {
3260                reiserfs_warning(sb, "journal-1409",
3261                                 "returning because j_wcount was %d",
3262                                 atomic_read(&(journal->j_wcount)));
3263                return 1;
3264        }
3265        /* this error means I've screwed up, and we've overflowed the transaction.
3266         ** Nothing can be done here, except make the FS readonly or panic.
3267         */
3268        if (journal->j_len >= journal->j_trans_max) {
3269                reiserfs_panic(th->t_super, "journal-1413",
3270                               "j_len (%lu) is too big",
3271                               journal->j_len);
3272        }
3273
3274        if (buffer_journal_dirty(bh)) {
3275                count_already_incd = 1;
3276                PROC_INFO_INC(sb, journal.mark_dirty_notjournal);
3277                clear_buffer_journal_dirty(bh);
3278        }
3279
3280        if (journal->j_len > journal->j_len_alloc) {
3281                journal->j_len_alloc = journal->j_len + JOURNAL_PER_BALANCE_CNT;
3282        }
3283
3284        set_buffer_journaled(bh);
3285
3286        /* now put this guy on the end */
3287        if (!cn) {
3288                cn = get_cnode(sb);
3289                if (!cn) {
3290                        reiserfs_panic(sb, "journal-4", "get_cnode failed!");
3291                }
3292
3293                if (th->t_blocks_logged == th->t_blocks_allocated) {
3294                        th->t_blocks_allocated += JOURNAL_PER_BALANCE_CNT;
3295                        journal->j_len_alloc += JOURNAL_PER_BALANCE_CNT;
3296                }
3297                th->t_blocks_logged++;
3298                journal->j_len++;
3299
3300                cn->bh = bh;
3301                cn->blocknr = bh->b_blocknr;
3302                cn->sb = sb;
3303                cn->jlist = NULL;
3304                insert_journal_hash(journal->j_hash_table, cn);
3305                if (!count_already_incd) {
3306                        get_bh(bh);
3307                }
3308        }
3309        cn->next = NULL;
3310        cn->prev = journal->j_last;
3311        cn->bh = bh;
3312        if (journal->j_last) {
3313                journal->j_last->next = cn;
3314                journal->j_last = cn;
3315        } else {
3316                journal->j_first = cn;
3317                journal->j_last = cn;
3318        }
3319        reiserfs_schedule_old_flush(sb);
3320        return 0;
3321}
3322
3323int journal_end(struct reiserfs_transaction_handle *th,
3324                struct super_block *sb, unsigned long nblocks)
3325{
3326        if (!current->journal_info && th->t_refcount > 1)
3327                reiserfs_warning(sb, "REISER-NESTING",
3328                                 "th NULL, refcount %d", th->t_refcount);
3329
3330        if (!th->t_trans_id) {
3331                WARN_ON(1);
3332                return -EIO;
3333        }
3334
3335        th->t_refcount--;
3336        if (th->t_refcount > 0) {
3337                struct reiserfs_transaction_handle *cur_th =
3338                    current->journal_info;
3339
3340                /* we aren't allowed to close a nested transaction on a different
3341                 ** filesystem from the one in the task struct
3342                 */
3343                BUG_ON(cur_th->t_super != th->t_super);
3344
3345                if (th != cur_th) {
3346                        memcpy(current->journal_info, th, sizeof(*th));
3347                        th->t_trans_id = 0;
3348                }
3349                return 0;
3350        } else {
3351                return do_journal_end(th, sb, nblocks, 0);
3352        }
3353}
3354
3355/* removes from the current transaction, relsing and descrementing any counters.
3356** also files the removed buffer directly onto the clean list
3357**
3358** called by journal_mark_freed when a block has been deleted
3359**
3360** returns 1 if it cleaned and relsed the buffer. 0 otherwise
3361*/
3362static int remove_from_transaction(struct super_block *sb,
3363                                   b_blocknr_t blocknr, int already_cleaned)
3364{
3365        struct buffer_head *bh;
3366        struct reiserfs_journal_cnode *cn;
3367        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3368        int ret = 0;
3369
3370        cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr);
3371        if (!cn || !cn->bh) {
3372                return ret;
3373        }
3374        bh = cn->bh;
3375        if (cn->prev) {
3376                cn->prev->next = cn->next;
3377        }
3378        if (cn->next) {
3379                cn->next->prev = cn->prev;
3380        }
3381        if (cn == journal->j_first) {
3382                journal->j_first = cn->next;
3383        }
3384        if (cn == journal->j_last) {
3385                journal->j_last = cn->prev;
3386        }
3387        if (bh)
3388                remove_journal_hash(sb, journal->j_hash_table, NULL,
3389                                    bh->b_blocknr, 0);
3390        clear_buffer_journaled(bh);     /* don't log this one */
3391
3392        if (!already_cleaned) {
3393                clear_buffer_journal_dirty(bh);
3394                clear_buffer_dirty(bh);
3395                clear_buffer_journal_test(bh);
3396                put_bh(bh);
3397                if (atomic_read(&(bh->b_count)) < 0) {
3398                        reiserfs_warning(sb, "journal-1752",
3399                                         "b_count < 0");
3400                }
3401                ret = 1;
3402        }
3403        journal->j_len--;
3404        journal->j_len_alloc--;
3405        free_cnode(sb, cn);
3406        return ret;
3407}
3408
3409/*
3410** for any cnode in a journal list, it can only be dirtied of all the
3411** transactions that include it are committed to disk.
3412** this checks through each transaction, and returns 1 if you are allowed to dirty,
3413** and 0 if you aren't
3414**
3415** it is called by dirty_journal_list, which is called after flush_commit_list has gotten all the log
3416** blocks for a given transaction on disk
3417**
3418*/
3419static int can_dirty(struct reiserfs_journal_cnode *cn)
3420{
3421        struct super_block *sb = cn->sb;
3422        b_blocknr_t blocknr = cn->blocknr;
3423        struct reiserfs_journal_cnode *cur = cn->hprev;
3424        int can_dirty = 1;
3425
3426        /* first test hprev.  These are all newer than cn, so any node here
3427         ** with the same block number and dev means this node can't be sent
3428         ** to disk right now.
3429         */
3430        while (cur && can_dirty) {
3431                if (cur->jlist && cur->bh && cur->blocknr && cur->sb == sb &&
3432                    cur->blocknr == blocknr) {
3433                        can_dirty = 0;
3434                }
3435                cur = cur->hprev;
3436        }
3437        /* then test hnext.  These are all older than cn.  As long as they
3438         ** are committed to the log, it is safe to write cn to disk
3439         */
3440        cur = cn->hnext;
3441        while (cur && can_dirty) {
3442                if (cur->jlist && cur->jlist->j_len > 0 &&
3443                    atomic_read(&(cur->jlist->j_commit_left)) > 0 && cur->bh &&
3444                    cur->blocknr && cur->sb == sb && cur->blocknr == blocknr) {
3445                        can_dirty = 0;
3446                }
3447                cur = cur->hnext;
3448        }
3449        return can_dirty;
3450}
3451
3452/* syncs the commit blocks, but does not force the real buffers to disk
3453** will wait until the current transaction is done/committed before returning
3454*/
3455int journal_end_sync(struct reiserfs_transaction_handle *th,
3456                     struct super_block *sb, unsigned long nblocks)
3457{
3458        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3459
3460        BUG_ON(!th->t_trans_id);
3461        /* you can sync while nested, very, very bad */
3462        BUG_ON(th->t_refcount > 1);
3463        if (journal->j_len == 0) {
3464                reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
3465                                             1);
3466                journal_mark_dirty(th, sb, SB_BUFFER_WITH_SB(sb));
3467        }
3468        return do_journal_end(th, sb, nblocks, COMMIT_NOW | WAIT);
3469}
3470
3471/*
3472** writeback the pending async commits to disk
3473*/
3474static void flush_async_commits(struct work_struct *work)
3475{
3476        struct reiserfs_journal *journal =
3477                container_of(work, struct reiserfs_journal, j_work.work);
3478        struct super_block *sb = journal->j_work_sb;
3479        struct reiserfs_journal_list *jl;
3480        struct list_head *entry;
3481
3482        reiserfs_write_lock(sb);
3483        if (!list_empty(&journal->j_journal_list)) {
3484                /* last entry is the youngest, commit it and you get everything */
3485                entry = journal->j_journal_list.prev;
3486                jl = JOURNAL_LIST_ENTRY(entry);
3487                flush_commit_list(sb, jl, 1);
3488        }
3489        reiserfs_write_unlock(sb);
3490}
3491
3492/*
3493** flushes any old transactions to disk
3494** ends the current transaction if it is too old
3495*/
3496void reiserfs_flush_old_commits(struct super_block *sb)
3497{
3498        time_t now;
3499        struct reiserfs_transaction_handle th;
3500        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3501
3502        now = get_seconds();
3503        /* safety check so we don't flush while we are replaying the log during
3504         * mount
3505         */
3506        if (list_empty(&journal->j_journal_list))
3507                return;
3508
3509        /* check the current transaction.  If there are no writers, and it is
3510         * too old, finish it, and force the commit blocks to disk
3511         */
3512        if (atomic_read(&journal->j_wcount) <= 0 &&
3513            journal->j_trans_start_time > 0 &&
3514            journal->j_len > 0 &&
3515            (now - journal->j_trans_start_time) > journal->j_max_trans_age) {
3516                if (!journal_join(&th, sb, 1)) {
3517                        reiserfs_prepare_for_journal(sb,
3518                                                     SB_BUFFER_WITH_SB(sb),
3519                                                     1);
3520                        journal_mark_dirty(&th, sb,
3521                                           SB_BUFFER_WITH_SB(sb));
3522
3523                        /* we're only being called from kreiserfsd, it makes no sense to do
3524                         ** an async commit so that kreiserfsd can do it later
3525                         */
3526                        do_journal_end(&th, sb, 1, COMMIT_NOW | WAIT);
3527                }
3528        }
3529}
3530
3531/*
3532** returns 0 if do_journal_end should return right away, returns 1 if do_journal_end should finish the commit
3533**
3534** if the current transaction is too old, but still has writers, this will wait on j_join_wait until all
3535** the writers are done.  By the time it wakes up, the transaction it was called has already ended, so it just
3536** flushes the commit list and returns 0.
3537**
3538** Won't batch when flush or commit_now is set.  Also won't batch when others are waiting on j_join_wait.
3539**
3540** Note, we can't allow the journal_end to proceed while there are still writers in the log.
3541*/
3542static int check_journal_end(struct reiserfs_transaction_handle *th,
3543                             struct super_block *sb, unsigned long nblocks,
3544                             int flags)
3545{
3546
3547        time_t now;
3548        int flush = flags & FLUSH_ALL;
3549        int commit_now = flags & COMMIT_NOW;
3550        int wait_on_commit = flags & WAIT;
3551        struct reiserfs_journal_list *jl;
3552        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3553
3554        BUG_ON(!th->t_trans_id);
3555
3556        if (th->t_trans_id != journal->j_trans_id) {
3557                reiserfs_panic(th->t_super, "journal-1577",
3558                               "handle trans id %ld != current trans id %ld",
3559                               th->t_trans_id, journal->j_trans_id);
3560        }
3561
3562        journal->j_len_alloc -= (th->t_blocks_allocated - th->t_blocks_logged);
3563        if (atomic_read(&(journal->j_wcount)) > 0) {    /* <= 0 is allowed.  unmounting might not call begin */
3564                atomic_dec(&(journal->j_wcount));
3565        }
3566
3567        /* BUG, deal with case where j_len is 0, but people previously freed blocks need to be released
3568         ** will be dealt with by next transaction that actually writes something, but should be taken
3569         ** care of in this trans
3570         */
3571        BUG_ON(journal->j_len == 0);
3572
3573        /* if wcount > 0, and we are called to with flush or commit_now,
3574         ** we wait on j_join_wait.  We will wake up when the last writer has
3575         ** finished the transaction, and started it on its way to the disk.
3576         ** Then, we flush the commit or journal list, and just return 0
3577         ** because the rest of journal end was already done for this transaction.
3578         */
3579        if (atomic_read(&(journal->j_wcount)) > 0) {
3580                if (flush || commit_now) {
3581                        unsigned trans_id;
3582
3583                        jl = journal->j_current_jl;
3584                        trans_id = jl->j_trans_id;
3585                        if (wait_on_commit)
3586                                jl->j_state |= LIST_COMMIT_PENDING;
3587                        atomic_set(&(journal->j_jlock), 1);
3588                        if (flush) {
3589                                journal->j_next_full_flush = 1;
3590                        }
3591                        unlock_journal(sb);
3592
3593                        /* sleep while the current transaction is still j_jlocked */
3594                        while (journal->j_trans_id == trans_id) {
3595                                if (atomic_read(&journal->j_jlock)) {
3596                                        queue_log_writer(sb);
3597                                } else {
3598                                        lock_journal(sb);
3599                                        if (journal->j_trans_id == trans_id) {
3600                                                atomic_set(&(journal->j_jlock),
3601                                                           1);
3602                                        }
3603                                        unlock_journal(sb);
3604                                }
3605                        }
3606                        BUG_ON(journal->j_trans_id == trans_id);
3607                        
3608                        if (commit_now
3609                            && journal_list_still_alive(sb, trans_id)
3610                            && wait_on_commit) {
3611                                flush_commit_list(sb, jl, 1);
3612                        }
3613                        return 0;
3614                }
3615                unlock_journal(sb);
3616                return 0;
3617        }
3618
3619        /* deal with old transactions where we are the last writers */
3620        now = get_seconds();
3621        if ((now - journal->j_trans_start_time) > journal->j_max_trans_age) {
3622                commit_now = 1;
3623                journal->j_next_async_flush = 1;
3624        }
3625        /* don't batch when someone is waiting on j_join_wait */
3626        /* don't batch when syncing the commit or flushing the whole trans */
3627        if (!(journal->j_must_wait > 0) && !(atomic_read(&(journal->j_jlock)))
3628            && !flush && !commit_now && (journal->j_len < journal->j_max_batch)
3629            && journal->j_len_alloc < journal->j_max_batch
3630            && journal->j_cnode_free > (journal->j_trans_max * 3)) {
3631                journal->j_bcount++;
3632                unlock_journal(sb);
3633                return 0;
3634        }
3635
3636        if (journal->j_start > SB_ONDISK_JOURNAL_SIZE(sb)) {
3637                reiserfs_panic(sb, "journal-003",
3638                               "j_start (%ld) is too high",
3639                               journal->j_start);
3640        }
3641        return 1;
3642}
3643
3644/*
3645** Does all the work that makes deleting blocks safe.
3646** when deleting a block mark BH_JNew, just remove it from the current transaction, clean it's buffer_head and move on.
3647**
3648** otherwise:
3649** set a bit for the block in the journal bitmap.  That will prevent it from being allocated for unformatted nodes
3650** before this transaction has finished.
3651**
3652** mark any cnodes for this block as BLOCK_FREED, and clear their bh pointers.  That will prevent any old transactions with
3653** this block from trying to flush to the real location.  Since we aren't removing the cnode from the journal_list_hash,
3654** the block can't be reallocated yet.
3655**
3656** Then remove it from the current transaction, decrementing any counters and filing it on the clean list.
3657*/
3658int journal_mark_freed(struct reiserfs_transaction_handle *th,
3659                       struct super_block *sb, b_blocknr_t blocknr)
3660{
3661        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3662        struct reiserfs_journal_cnode *cn = NULL;
3663        struct buffer_head *bh = NULL;
3664        struct reiserfs_list_bitmap *jb = NULL;
3665        int cleaned = 0;
3666        BUG_ON(!th->t_trans_id);
3667
3668        cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr);
3669        if (cn && cn->bh) {
3670                bh = cn->bh;
3671                get_bh(bh);
3672        }
3673        /* if it is journal new, we just remove it from this transaction */
3674        if (bh && buffer_journal_new(bh)) {
3675                clear_buffer_journal_new(bh);
3676                clear_prepared_bits(bh);
3677                reiserfs_clean_and_file_buffer(bh);
3678                cleaned = remove_from_transaction(sb, blocknr, cleaned);
3679        } else {
3680                /* set the bit for this block in the journal bitmap for this transaction */
3681                jb = journal->j_current_jl->j_list_bitmap;
3682                if (!jb) {
3683                        reiserfs_panic(sb, "journal-1702",
3684                                       "journal_list_bitmap is NULL");
3685                }
3686                set_bit_in_list_bitmap(sb, blocknr, jb);
3687
3688                /* Note, the entire while loop is not allowed to schedule.  */
3689
3690                if (bh) {
3691                        clear_prepared_bits(bh);
3692                        reiserfs_clean_and_file_buffer(bh);
3693                }
3694                cleaned = remove_from_transaction(sb, blocknr, cleaned);
3695
3696                /* find all older transactions with this block, make sure they don't try to write it out */
3697                cn = get_journal_hash_dev(sb, journal->j_list_hash_table,
3698                                          blocknr);
3699                while (cn) {
3700                        if (sb == cn->sb && blocknr == cn->blocknr) {
3701                                set_bit(BLOCK_FREED, &cn->state);
3702                                if (cn->bh) {
3703                                        if (!cleaned) {
3704                                                /* remove_from_transaction will brelse the buffer if it was 
3705                                                 ** in the current trans
3706                                                 */
3707                                                clear_buffer_journal_dirty(cn->
3708                                                                           bh);
3709                                                clear_buffer_dirty(cn->bh);
3710                                                clear_buffer_journal_test(cn->
3711                                                                          bh);
3712                                                cleaned = 1;
3713                                                put_bh(cn->bh);
3714                                                if (atomic_read
3715                                                    (&(cn->bh->b_count)) < 0) {
3716                                                        reiserfs_warning(sb,
3717                                                                 "journal-2138",
3718                                                                 "cn->bh->b_count < 0");
3719                                                }
3720                                        }
3721                                        if (cn->jlist) {        /* since we are clearing the bh, we MUST dec nonzerolen */
3722                                                atomic_dec(&
3723                                                           (cn->jlist->
3724                                                            j_nonzerolen));
3725                                        }
3726                                        cn->bh = NULL;
3727                                }
3728                        }
3729                        cn = cn->hnext;
3730                }
3731        }
3732
3733        if (bh)
3734                release_buffer_page(bh); /* get_hash grabs the buffer */
3735        return 0;
3736}
3737
3738void reiserfs_update_inode_transaction(struct inode *inode)
3739{
3740        struct reiserfs_journal *journal = SB_JOURNAL(inode->i_sb);
3741        REISERFS_I(inode)->i_jl = journal->j_current_jl;
3742        REISERFS_I(inode)->i_trans_id = journal->j_trans_id;
3743}
3744
3745/*
3746 * returns -1 on error, 0 if no commits/barriers were done and 1
3747 * if a transaction was actually committed and the barrier was done
3748 */
3749static int __commit_trans_jl(struct inode *inode, unsigned long id,
3750                             struct reiserfs_journal_list *jl)
3751{
3752        struct reiserfs_transaction_handle th;
3753        struct super_block *sb = inode->i_sb;
3754        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3755        int ret = 0;
3756
3757        /* is it from the current transaction, or from an unknown transaction? */
3758        if (id == journal->j_trans_id) {
3759                jl = journal->j_current_jl;
3760                /* try to let other writers come in and grow this transaction */
3761                let_transaction_grow(sb, id);
3762                if (journal->j_trans_id != id) {
3763                        goto flush_commit_only;
3764                }
3765
3766                ret = journal_begin(&th, sb, 1);
3767                if (ret)
3768                        return ret;
3769
3770                /* someone might have ended this transaction while we joined */
3771                if (journal->j_trans_id != id) {
3772                        reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
3773                                                     1);
3774                        journal_mark_dirty(&th, sb, SB_BUFFER_WITH_SB(sb));
3775                        ret = journal_end(&th, sb, 1);
3776                        goto flush_commit_only;
3777                }
3778
3779                ret = journal_end_sync(&th, sb, 1);
3780                if (!ret)
3781                        ret = 1;
3782
3783        } else {
3784                /* this gets tricky, we have to make sure the journal list in
3785                 * the inode still exists.  We know the list is still around
3786                 * if we've got a larger transaction id than the oldest list
3787                 */
3788              flush_commit_only:
3789                if (journal_list_still_alive(inode->i_sb, id)) {
3790                        /*
3791                         * we only set ret to 1 when we know for sure
3792                         * the barrier hasn't been started yet on the commit
3793                         * block.
3794                         */
3795                        if (atomic_read(&jl->j_commit_left) > 1)
3796                                ret = 1;
3797                        flush_commit_list(sb, jl, 1);
3798                        if (journal->j_errno)
3799                                ret = journal->j_errno;
3800                }
3801        }
3802        /* otherwise the list is gone, and long since committed */
3803        return ret;
3804}
3805
3806int reiserfs_commit_for_inode(struct inode *inode)
3807{
3808        unsigned int id = REISERFS_I(inode)->i_trans_id;
3809        struct reiserfs_journal_list *jl = REISERFS_I(inode)->i_jl;
3810
3811        /* for the whole inode, assume unset id means it was
3812         * changed in the current transaction.  More conservative
3813         */
3814        if (!id || !jl) {
3815                reiserfs_update_inode_transaction(inode);
3816                id = REISERFS_I(inode)->i_trans_id;
3817                /* jl will be updated in __commit_trans_jl */
3818        }
3819
3820        return __commit_trans_jl(inode, id, jl);
3821}
3822
3823void reiserfs_restore_prepared_buffer(struct super_block *sb,
3824                                      struct buffer_head *bh)
3825{
3826        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3827        PROC_INFO_INC(sb, journal.restore_prepared);
3828        if (!bh) {
3829                return;
3830        }
3831        if (test_clear_buffer_journal_restore_dirty(bh) &&
3832            buffer_journal_dirty(bh)) {
3833                struct reiserfs_journal_cnode *cn;
3834                cn = get_journal_hash_dev(sb,
3835                                          journal->j_list_hash_table,
3836                                          bh->b_blocknr);
3837                if (cn && can_dirty(cn)) {
3838                        set_buffer_journal_test(bh);
3839                        mark_buffer_dirty(bh);
3840                }
3841        }
3842        clear_buffer_journal_prepared(bh);
3843}
3844
3845extern struct tree_balance *cur_tb;
3846/*
3847** before we can change a metadata block, we have to make sure it won't
3848** be written to disk while we are altering it.  So, we must:
3849** clean it
3850** wait on it.
3851**
3852*/
3853int reiserfs_prepare_for_journal(struct super_block *sb,
3854                                 struct buffer_head *bh, int wait)
3855{
3856        PROC_INFO_INC(sb, journal.prepare);
3857
3858        if (!trylock_buffer(bh)) {
3859                if (!wait)
3860                        return 0;
3861                lock_buffer(bh);
3862        }
3863        set_buffer_journal_prepared(bh);
3864        if (test_clear_buffer_dirty(bh) && buffer_journal_dirty(bh)) {
3865                clear_buffer_journal_test(bh);
3866                set_buffer_journal_restore_dirty(bh);
3867        }
3868        unlock_buffer(bh);
3869        return 1;
3870}
3871
3872static void flush_old_journal_lists(struct super_block *s)
3873{
3874        struct reiserfs_journal *journal = SB_JOURNAL(s);
3875        struct reiserfs_journal_list *jl;
3876        struct list_head *entry;
3877        time_t now = get_seconds();
3878
3879        while (!list_empty(&journal->j_journal_list)) {
3880                entry = journal->j_journal_list.next;
3881                jl = JOURNAL_LIST_ENTRY(entry);
3882                /* this check should always be run, to send old lists to disk */
3883                if (jl->j_timestamp < (now - (JOURNAL_MAX_TRANS_AGE * 4)) &&
3884                    atomic_read(&jl->j_commit_left) == 0 &&
3885                    test_transaction(s, jl)) {
3886                        flush_used_journal_lists(s, jl);
3887                } else {
3888                        break;
3889                }
3890        }
3891}
3892
3893/*
3894** long and ugly.  If flush, will not return until all commit
3895** blocks and all real buffers in the trans are on disk.
3896** If no_async, won't return until all commit blocks are on disk.
3897**
3898** keep reading, there are comments as you go along
3899**
3900** If the journal is aborted, we just clean up. Things like flushing
3901** journal lists, etc just won't happen.
3902*/
3903static int do_journal_end(struct reiserfs_transaction_handle *th,
3904                          struct super_block *sb, unsigned long nblocks,
3905                          int flags)
3906{
3907        struct reiserfs_journal *journal = SB_JOURNAL(sb);
3908        struct reiserfs_journal_cnode *cn, *next, *jl_cn;
3909        struct reiserfs_journal_cnode *last_cn = NULL;
3910        struct reiserfs_journal_desc *desc;
3911        struct reiserfs_journal_commit *commit;
3912        struct buffer_head *c_bh;       /* commit bh */
3913        struct buffer_head *d_bh;       /* desc bh */
3914        int cur_write_start = 0;        /* start index of current log write */
3915        int old_start;
3916        int i;
3917        int flush;
3918        int wait_on_commit;
3919        struct reiserfs_journal_list *jl, *temp_jl;
3920        struct list_head *entry, *safe;
3921        unsigned long jindex;
3922        unsigned int commit_trans_id;
3923        int trans_half;
3924
3925        BUG_ON(th->t_refcount > 1);
3926        BUG_ON(!th->t_trans_id);
3927
3928        /* protect flush_older_commits from doing mistakes if the
3929           transaction ID counter gets overflowed.  */
3930        if (th->t_trans_id == ~0U)
3931                flags |= FLUSH_ALL | COMMIT_NOW | WAIT;
3932        flush = flags & FLUSH_ALL;
3933        wait_on_commit = flags & WAIT;
3934
3935        current->journal_info = th->t_handle_save;
3936        reiserfs_check_lock_depth(sb, "journal end");
3937        if (journal->j_len == 0) {
3938                reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
3939                                             1);
3940                journal_mark_dirty(th, sb, SB_BUFFER_WITH_SB(sb));
3941        }
3942
3943        lock_journal(sb);
3944        if (journal->j_next_full_flush) {
3945                flags |= FLUSH_ALL;
3946                flush = 1;
3947        }
3948        if (journal->j_next_async_flush) {
3949                flags |= COMMIT_NOW | WAIT;
3950                wait_on_commit = 1;
3951        }
3952
3953        /* check_journal_end locks the journal, and unlocks if it does not return 1
3954         ** it tells us if we should continue with the journal_end, or just return
3955         */
3956        if (!check_journal_end(th, sb, nblocks, flags)) {
3957                reiserfs_schedule_old_flush(sb);
3958                wake_queued_writers(sb);
3959                reiserfs_async_progress_wait(sb);
3960                goto out;
3961        }
3962
3963        /* check_journal_end might set these, check again */
3964        if (journal->j_next_full_flush) {
3965                flush = 1;
3966        }
3967
3968        /*
3969         ** j must wait means we have to flush the log blocks, and the real blocks for
3970         ** this transaction
3971         */
3972        if (journal->j_must_wait > 0) {
3973                flush = 1;
3974        }
3975#ifdef REISERFS_PREALLOCATE
3976        /* quota ops might need to nest, setup the journal_info pointer for them
3977         * and raise the refcount so that it is > 0. */
3978        current->journal_info = th;
3979        th->t_refcount++;
3980        reiserfs_discard_all_prealloc(th);      /* it should not involve new blocks into
3981                                                 * the transaction */
3982        th->t_refcount--;
3983        current->journal_info = th->t_handle_save;
3984#endif
3985
3986        /* setup description block */
3987        d_bh =
3988            journal_getblk(sb,
3989                           SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
3990                           journal->j_start);
3991        set_buffer_uptodate(d_bh);
3992        desc = (struct reiserfs_journal_desc *)(d_bh)->b_data;
3993        memset(d_bh->b_data, 0, d_bh->b_size);
3994        memcpy(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8);
3995        set_desc_trans_id(desc, journal->j_trans_id);
3996
3997        /* setup commit block.  Don't write (keep it clean too) this one until after everyone else is written */
3998        c_bh = journal_getblk(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
3999                              ((journal->j_start + journal->j_len +
4000                                1) % SB_ONDISK_JOURNAL_SIZE(sb)));
4001        commit = (struct reiserfs_journal_commit *)c_bh->b_data;
4002        memset(c_bh->b_data, 0, c_bh->b_size);
4003        set_commit_trans_id(commit, journal->j_trans_id);
4004        set_buffer_uptodate(c_bh);
4005
4006        /* init this journal list */
4007        jl = journal->j_current_jl;
4008
4009        /* we lock the commit before doing anything because
4010         * we want to make sure nobody tries to run flush_commit_list until
4011         * the new transaction is fully setup, and we've already flushed the
4012         * ordered bh list
4013         */
4014        reiserfs_mutex_lock_safe(&jl->j_commit_mutex, sb);
4015
4016        /* save the transaction id in case we need to commit it later */
4017        commit_trans_id = jl->j_trans_id;
4018
4019        atomic_set(&jl->j_older_commits_done, 0);
4020        jl->j_trans_id = journal->j_trans_id;
4021        jl->j_timestamp = journal->j_trans_start_time;
4022        jl->j_commit_bh = c_bh;
4023        jl->j_start = journal->j_start;
4024        jl->j_len = journal->j_len;
4025        atomic_set(&jl->j_nonzerolen, journal->j_len);
4026        atomic_set(&jl->j_commit_left, journal->j_len + 2);
4027        jl->j_realblock = NULL;
4028
4029        /* The ENTIRE FOR LOOP MUST not cause schedule to occur.
4030         **  for each real block, add it to the journal list hash,
4031         ** copy into real block index array in the commit or desc block
4032         */
4033        trans_half = journal_trans_half(sb->s_blocksize);
4034        for (i = 0, cn = journal->j_first; cn; cn = cn->next, i++) {
4035                if (buffer_journaled(cn->bh)) {
4036                        jl_cn = get_cnode(sb);
4037                        if (!jl_cn) {
4038                                reiserfs_panic(sb, "journal-1676",
4039                                               "get_cnode returned NULL");
4040                        }
4041                        if (i == 0) {
4042                                jl->j_realblock = jl_cn;
4043                        }
4044                        jl_cn->prev = last_cn;
4045                        jl_cn->next = NULL;
4046                        if (last_cn) {
4047                                last_cn->next = jl_cn;
4048                        }
4049                        last_cn = jl_cn;
4050                        /* make sure the block we are trying to log is not a block
4051                           of journal or reserved area */
4052
4053                        if (is_block_in_log_or_reserved_area
4054                            (sb, cn->bh->b_blocknr)) {
4055                                reiserfs_panic(sb, "journal-2332",
4056                                               "Trying to log block %lu, "
4057                                               "which is a log block",
4058                                               cn->bh->b_blocknr);
4059                        }
4060                        jl_cn->blocknr = cn->bh->b_blocknr;
4061                        jl_cn->state = 0;
4062                        jl_cn->sb = sb;
4063                        jl_cn->bh = cn->bh;
4064                        jl_cn->jlist = jl;
4065                        insert_journal_hash(journal->j_list_hash_table, jl_cn);
4066                        if (i < trans_half) {
4067                                desc->j_realblock[i] =
4068                                    cpu_to_le32(cn->bh->b_blocknr);
4069                        } else {
4070                                commit->j_realblock[i - trans_half] =
4071                                    cpu_to_le32(cn->bh->b_blocknr);
4072                        }
4073                } else {
4074                        i--;
4075                }
4076        }
4077        set_desc_trans_len(desc, journal->j_len);
4078        set_desc_mount_id(desc, journal->j_mount_id);
4079        set_desc_trans_id(desc, journal->j_trans_id);
4080        set_commit_trans_len(commit, journal->j_len);
4081
4082        /* special check in case all buffers in the journal were marked for not logging */
4083        BUG_ON(journal->j_len == 0);
4084
4085        /* we're about to dirty all the log blocks, mark the description block
4086         * dirty now too.  Don't mark the commit block dirty until all the
4087         * others are on disk
4088         */
4089        mark_buffer_dirty(d_bh);
4090
4091        /* first data block is j_start + 1, so add one to cur_write_start wherever you use it */
4092        cur_write_start = journal->j_start;
4093        cn = journal->j_first;
4094        jindex = 1;             /* start at one so we don't get the desc again */
4095        while (cn) {
4096                clear_buffer_journal_new(cn->bh);
4097                /* copy all the real blocks into log area.  dirty log blocks */
4098                if (buffer_journaled(cn->bh)) {
4099                        struct buffer_head *tmp_bh;
4100                        char *addr;
4101                        struct page *page;
4102                        tmp_bh =
4103                            journal_getblk(sb,
4104                                           SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
4105                                           ((cur_write_start +
4106                                             jindex) %
4107                                            SB_ONDISK_JOURNAL_SIZE(sb)));
4108                        set_buffer_uptodate(tmp_bh);
4109                        page = cn->bh->b_page;
4110                        addr = kmap(page);
4111                        memcpy(tmp_bh->b_data,
4112                               addr + offset_in_page(cn->bh->b_data),
4113                               cn->bh->b_size);
4114                        kunmap(page);
4115                        mark_buffer_dirty(tmp_bh);
4116                        jindex++;
4117                        set_buffer_journal_dirty(cn->bh);
4118                        clear_buffer_journaled(cn->bh);
4119                } else {
4120                        /* JDirty cleared sometime during transaction.  don't log this one */
4121                        reiserfs_warning(sb, "journal-2048",
4122                                         "BAD, buffer in journal hash, "
4123                                         "but not JDirty!");
4124                        brelse(cn->bh);
4125                }
4126                next = cn->next;
4127                free_cnode(sb, cn);
4128                cn = next;
4129                reiserfs_write_unlock(sb);
4130                cond_resched();
4131                reiserfs_write_lock(sb);
4132        }
4133
4134        /* we are done  with both the c_bh and d_bh, but
4135         ** c_bh must be written after all other commit blocks,
4136         ** so we dirty/relse c_bh in flush_commit_list, with commit_left <= 1.
4137         */
4138
4139        journal->j_current_jl = alloc_journal_list(sb);
4140
4141        /* now it is safe to insert this transaction on the main list */
4142        list_add_tail(&jl->j_list, &journal->j_journal_list);
4143        list_add_tail(&jl->j_working_list, &journal->j_working_list);
4144        journal->j_num_work_lists++;
4145
4146        /* reset journal values for the next transaction */
4147        old_start = journal->j_start;
4148        journal->j_start =
4149            (journal->j_start + journal->j_len +
4150             2) % SB_ONDISK_JOURNAL_SIZE(sb);
4151        atomic_set(&(journal->j_wcount), 0);
4152        journal->j_bcount = 0;
4153        journal->j_last = NULL;
4154        journal->j_first = NULL;
4155        journal->j_len = 0;
4156        journal->j_trans_start_time = 0;
4157        /* check for trans_id overflow */
4158        if (++journal->j_trans_id == 0)
4159                journal->j_trans_id = 10;
4160        journal->j_current_jl->j_trans_id = journal->j_trans_id;
4161        journal->j_must_wait = 0;
4162        journal->j_len_alloc = 0;
4163        journal->j_next_full_flush = 0;
4164        journal->j_next_async_flush = 0;
4165        init_journal_hash(sb);
4166
4167        // make sure reiserfs_add_jh sees the new current_jl before we
4168        // write out the tails
4169        smp_mb();
4170
4171        /* tail conversion targets have to hit the disk before we end the
4172         * transaction.  Otherwise a later transaction might repack the tail
4173         * before this transaction commits, leaving the data block unflushed and
4174         * clean, if we crash before the later transaction commits, the data block
4175         * is lost.
4176         */
4177        if (!list_empty(&jl->j_tail_bh_list)) {
4178                reiserfs_write_unlock(sb);
4179                write_ordered_buffers(&journal->j_dirty_buffers_lock,
4180                                      journal, jl, &jl->j_tail_bh_list);
4181                reiserfs_write_lock(sb);
4182        }
4183        BUG_ON(!list_empty(&jl->j_tail_bh_list));
4184        mutex_unlock(&jl->j_commit_mutex);
4185
4186        /* honor the flush wishes from the caller, simple commits can
4187         ** be done outside the journal lock, they are done below
4188         **
4189         ** if we don't flush the commit list right now, we put it into
4190         ** the work queue so the people waiting on the async progress work
4191         ** queue don't wait for this proc to flush journal lists and such.
4192         */
4193        if (flush) {
4194                flush_commit_list(sb, jl, 1);
4195                flush_journal_list(sb, jl, 1);
4196        } else if (!(jl->j_state & LIST_COMMIT_PENDING))
4197                queue_delayed_work(commit_wq, &journal->j_work, HZ / 10);
4198
4199        /* if the next transaction has any chance of wrapping, flush
4200         ** transactions that might get overwritten.  If any journal lists are very
4201         ** old flush them as well.
4202         */
4203      first_jl:
4204        list_for_each_safe(entry, safe, &journal->j_journal_list) {
4205                temp_jl = JOURNAL_LIST_ENTRY(entry);
4206                if (journal->j_start <= temp_jl->j_start) {
4207                        if ((journal->j_start + journal->j_trans_max + 1) >=
4208                            temp_jl->j_start) {
4209                                flush_used_journal_lists(sb, temp_jl);
4210                                goto first_jl;
4211                        } else if ((journal->j_start +
4212                                    journal->j_trans_max + 1) <
4213                                   SB_ONDISK_JOURNAL_SIZE(sb)) {
4214                                /* if we don't cross into the next transaction and we don't
4215                                 * wrap, there is no way we can overlap any later transactions
4216                                 * break now
4217                                 */
4218                                break;
4219                        }
4220                } else if ((journal->j_start +
4221                            journal->j_trans_max + 1) >
4222                           SB_ONDISK_JOURNAL_SIZE(sb)) {
4223                        if (((journal->j_start + journal->j_trans_max + 1) %
4224                             SB_ONDISK_JOURNAL_SIZE(sb)) >=
4225                            temp_jl->j_start) {
4226                                flush_used_journal_lists(sb, temp_jl);
4227                                goto first_jl;
4228                        } else {
4229                                /* we don't overlap anything from out start to the end of the
4230                                 * log, and our wrapped portion doesn't overlap anything at
4231                                 * the start of the log.  We can break
4232                                 */
4233                                break;
4234                        }
4235                }
4236        }
4237        flush_old_journal_lists(sb);
4238
4239        journal->j_current_jl->j_list_bitmap =
4240            get_list_bitmap(sb, journal->j_current_jl);
4241
4242        if (!(journal->j_current_jl->j_list_bitmap)) {
4243                reiserfs_panic(sb, "journal-1996",
4244                               "could not get a list bitmap");
4245        }
4246
4247        atomic_set(&(journal->j_jlock), 0);
4248        unlock_journal(sb);
4249        /* wake up any body waiting to join. */
4250        clear_bit(J_WRITERS_QUEUED, &journal->j_state);
4251        wake_up(&(journal->j_join_wait));
4252
4253        if (!flush && wait_on_commit &&
4254            journal_list_still_alive(sb, commit_trans_id)) {
4255                flush_commit_list(sb, jl, 1);
4256        }
4257      out:
4258        reiserfs_check_lock_depth(sb, "journal end2");
4259
4260        memset(th, 0, sizeof(*th));
4261        /* Re-set th->t_super, so we can properly keep track of how many
4262         * persistent transactions there are. We need to do this so if this
4263         * call is part of a failed restart_transaction, we can free it later */
4264        th->t_super = sb;
4265
4266        return journal->j_errno;
4267}
4268
4269/* Send the file system read only and refuse new transactions */
4270void reiserfs_abort_journal(struct super_block *sb, int errno)
4271{
4272        struct reiserfs_journal *journal = SB_JOURNAL(sb);
4273        if (test_bit(J_ABORTED, &journal->j_state))
4274                return;
4275
4276        if (!journal->j_errno)
4277                journal->j_errno = errno;
4278
4279        sb->s_flags |= MS_RDONLY;
4280        set_bit(J_ABORTED, &journal->j_state);
4281
4282#ifdef CONFIG_REISERFS_CHECK
4283        dump_stack();
4284#endif
4285}
4286
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.