linux/fs/ext3/inode.c History
<<
>>
Prefs
   1/*
   2 *  linux/fs/ext3/inode.c
   3 *
   4 * Copyright (C) 1992, 1993, 1994, 1995
   5 * Remy Card (card@masi.ibp.fr)
   6 * Laboratoire MASI - Institut Blaise Pascal
   7 * Universite Pierre et Marie Curie (Paris VI)
   8 *
   9 *  from
  10 *
  11 *  linux/fs/minix/inode.c
  12 *
  13 *  Copyright (C) 1991, 1992  Linus Torvalds
  14 *
  15 *  Goal-directed block allocation by Stephen Tweedie
  16 *      (sct@redhat.com), 1993, 1998
  17 *  Big-endian to little-endian byte-swapping/bitmaps by
  18 *        David S. Miller (davem@caip.rutgers.edu), 1995
  19 *  64-bit file support on 64-bit platforms by Jakub Jelinek
  20 *      (jj@sunsite.ms.mff.cuni.cz)
  21 *
  22 *  Assorted race fixes, rewrite of ext3_get_block() by Al Viro, 2000
  23 */
  24
  25#include <linux/module.h>
  26#include <linux/fs.h>
  27#include <linux/time.h>
  28#include <linux/ext3_jbd.h>
  29#include <linux/jbd.h>
  30#include <linux/highuid.h>
  31#include <linux/pagemap.h>
  32#include <linux/quotaops.h>
  33#include <linux/string.h>
  34#include <linux/buffer_head.h>
  35#include <linux/writeback.h>
  36#include <linux/mpage.h>
  37#include <linux/uio.h>
  38#include <linux/bio.h>
  39#include <linux/fiemap.h>
  40#include <linux/namei.h>
  41#include "xattr.h"
  42#include "acl.h"
  43
  44static int ext3_writepage_trans_blocks(struct inode *inode);
  45
  46/*
  47 * Test whether an inode is a fast symlink.
  48 */
  49static int ext3_inode_is_fast_symlink(struct inode *inode)
  50{
  51        int ea_blocks = EXT3_I(inode)->i_file_acl ?
  52                (inode->i_sb->s_blocksize >> 9) : 0;
  53
  54        return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
  55}
  56
  57/*
  58 * The ext3 forget function must perform a revoke if we are freeing data
  59 * which has been journaled.  Metadata (eg. indirect blocks) must be
  60 * revoked in all cases.
  61 *
  62 * "bh" may be NULL: a metadata block may have been freed from memory
  63 * but there may still be a record of it in the journal, and that record
  64 * still needs to be revoked.
  65 */
  66int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
  67                        struct buffer_head *bh, ext3_fsblk_t blocknr)
  68{
  69        int err;
  70
  71        might_sleep();
  72
  73        BUFFER_TRACE(bh, "enter");
  74
  75        jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
  76                  "data mode %lx\n",
  77                  bh, is_metadata, inode->i_mode,
  78                  test_opt(inode->i_sb, DATA_FLAGS));
  79
  80        /* Never use the revoke function if we are doing full data
  81         * journaling: there is no need to, and a V1 superblock won't
  82         * support it.  Otherwise, only skip the revoke on un-journaled
  83         * data blocks. */
  84
  85        if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ||
  86            (!is_metadata && !ext3_should_journal_data(inode))) {
  87                if (bh) {
  88                        BUFFER_TRACE(bh, "call journal_forget");
  89                        return ext3_journal_forget(handle, bh);
  90                }
  91                return 0;
  92        }
  93
  94        /*
  95         * data!=journal && (is_metadata || should_journal_data(inode))
  96         */
  97        BUFFER_TRACE(bh, "call ext3_journal_revoke");
  98        err = ext3_journal_revoke(handle, blocknr, bh);
  99        if (err)
 100                ext3_abort(inode->i_sb, __func__,
 101                           "error %d when attempting revoke", err);
 102        BUFFER_TRACE(bh, "exit");
 103        return err;
 104}
 105
 106/*
 107 * Work out how many blocks we need to proceed with the next chunk of a
 108 * truncate transaction.
 109 */
 110static unsigned long blocks_for_truncate(struct inode *inode)
 111{
 112        unsigned long needed;
 113
 114        needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
 115
 116        /* Give ourselves just enough room to cope with inodes in which
 117         * i_blocks is corrupt: we've seen disk corruptions in the past
 118         * which resulted in random data in an inode which looked enough
 119         * like a regular file for ext3 to try to delete it.  Things
 120         * will go a bit crazy if that happens, but at least we should
 121         * try not to panic the whole kernel. */
 122        if (needed < 2)
 123                needed = 2;
 124
 125        /* But we need to bound the transaction so we don't overflow the
 126         * journal. */
 127        if (needed > EXT3_MAX_TRANS_DATA)
 128                needed = EXT3_MAX_TRANS_DATA;
 129
 130        return EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
 131}
 132
 133/*
 134 * Truncate transactions can be complex and absolutely huge.  So we need to
 135 * be able to restart the transaction at a conventient checkpoint to make
 136 * sure we don't overflow the journal.
 137 *
 138 * start_transaction gets us a new handle for a truncate transaction,
 139 * and extend_transaction tries to extend the existing one a bit.  If
 140 * extend fails, we need to propagate the failure up and restart the
 141 * transaction in the top-level truncate loop. --sct
 142 */
 143static handle_t *start_transaction(struct inode *inode)
 144{
 145        handle_t *result;
 146
 147        result = ext3_journal_start(inode, blocks_for_truncate(inode));
 148        if (!IS_ERR(result))
 149                return result;
 150
 151        ext3_std_error(inode->i_sb, PTR_ERR(result));
 152        return result;
 153}
 154
 155/*
 156 * Try to extend this transaction for the purposes of truncation.
 157 *
 158 * Returns 0 if we managed to create more room.  If we can't create more
 159 * room, and the transaction must be restarted we return 1.
 160 */
 161static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
 162{
 163        if (handle->h_buffer_credits > EXT3_RESERVE_TRANS_BLOCKS)
 164                return 0;
 165        if (!ext3_journal_extend(handle, blocks_for_truncate(inode)))
 166                return 0;
 167        return 1;
 168}
 169
 170/*
 171 * Restart the transaction associated with *handle.  This does a commit,
 172 * so before we call here everything must be consistently dirtied against
 173 * this transaction.
 174 */
 175static int truncate_restart_transaction(handle_t *handle, struct inode *inode)
 176{
 177        int ret;
 178
 179        jbd_debug(2, "restarting handle %p\n", handle);
 180        /*
 181         * Drop truncate_mutex to avoid deadlock with ext3_get_blocks_handle
 182         * At this moment, get_block can be called only for blocks inside
 183         * i_size since page cache has been already dropped and writes are
 184         * blocked by i_mutex. So we can safely drop the truncate_mutex.
 185         */
 186        mutex_unlock(&EXT3_I(inode)->truncate_mutex);
 187        ret = ext3_journal_restart(handle, blocks_for_truncate(inode));
 188        mutex_lock(&EXT3_I(inode)->truncate_mutex);
 189        return ret;
 190}
 191
 192/*
 193 * Called at the last iput() if i_nlink is zero.
 194 */
 195void ext3_delete_inode (struct inode * inode)
 196{
 197        handle_t *handle;
 198
 199        if (!is_bad_inode(inode))
 200                dquot_initialize(inode);
 201
 202        truncate_inode_pages(&inode->i_data, 0);
 203
 204        if (is_bad_inode(inode))
 205                goto no_delete;
 206
 207        handle = start_transaction(inode);
 208        if (IS_ERR(handle)) {
 209                /*
 210                 * If we're going to skip the normal cleanup, we still need to
 211                 * make sure that the in-core orphan linked list is properly
 212                 * cleaned up.
 213                 */
 214                ext3_orphan_del(NULL, inode);
 215                goto no_delete;
 216        }
 217
 218        if (IS_SYNC(inode))
 219                handle->h_sync = 1;
 220        inode->i_size = 0;
 221        if (inode->i_blocks)
 222                ext3_truncate(inode);
 223        /*
 224         * Kill off the orphan record which ext3_truncate created.
 225         * AKPM: I think this can be inside the above `if'.
 226         * Note that ext3_orphan_del() has to be able to cope with the
 227         * deletion of a non-existent orphan - this is because we don't
 228         * know if ext3_truncate() actually created an orphan record.
 229         * (Well, we could do this if we need to, but heck - it works)
 230         */
 231        ext3_orphan_del(handle, inode);
 232        EXT3_I(inode)->i_dtime  = get_seconds();
 233
 234        /*
 235         * One subtle ordering requirement: if anything has gone wrong
 236         * (transaction abort, IO errors, whatever), then we can still
 237         * do these next steps (the fs will already have been marked as
 238         * having errors), but we can't free the inode if the mark_dirty
 239         * fails.
 240         */
 241        if (ext3_mark_inode_dirty(handle, inode))
 242                /* If that failed, just do the required in-core inode clear. */
 243                clear_inode(inode);
 244        else
 245                ext3_free_inode(handle, inode);
 246        ext3_journal_stop(handle);
 247        return;
 248no_delete:
 249        clear_inode(inode);     /* We must guarantee clearing of inode... */
 250}
 251
 252typedef struct {
 253        __le32  *p;
 254        __le32  key;
 255        struct buffer_head *bh;
 256} Indirect;
 257
 258static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
 259{
 260        p->key = *(p->p = v);
 261        p->bh = bh;
 262}
 263
 264static int verify_chain(Indirect *from, Indirect *to)
 265{
 266        while (from <= to && from->key == *from->p)
 267                from++;
 268        return (from > to);
 269}
 270
 271/**
 272 *      ext3_block_to_path - parse the block number into array of offsets
 273 *      @inode: inode in question (we are only interested in its superblock)
 274 *      @i_block: block number to be parsed
 275 *      @offsets: array to store the offsets in
 276 *      @boundary: set this non-zero if the referred-to block is likely to be
 277 *             followed (on disk) by an indirect block.
 278 *
 279 *      To store the locations of file's data ext3 uses a data structure common
 280 *      for UNIX filesystems - tree of pointers anchored in the inode, with
 281 *      data blocks at leaves and indirect blocks in intermediate nodes.
 282 *      This function translates the block number into path in that tree -
 283 *      return value is the path length and @offsets[n] is the offset of
 284 *      pointer to (n+1)th node in the nth one. If @block is out of range
 285 *      (negative or too large) warning is printed and zero returned.
 286 *
 287 *      Note: function doesn't find node addresses, so no IO is needed. All
 288 *      we need to know is the capacity of indirect blocks (taken from the
 289 *      inode->i_sb).
 290 */
 291
 292/*
 293 * Portability note: the last comparison (check that we fit into triple
 294 * indirect block) is spelled differently, because otherwise on an
 295 * architecture with 32-bit longs and 8Kb pages we might get into trouble
 296 * if our filesystem had 8Kb blocks. We might use long long, but that would
 297 * kill us on x86. Oh, well, at least the sign propagation does not matter -
 298 * i_block would have to be negative in the very beginning, so we would not
 299 * get there at all.
 300 */
 301
 302static int ext3_block_to_path(struct inode *inode,
 303                        long i_block, int offsets[4], int *boundary)
 304{
 305        int ptrs = EXT3_ADDR_PER_BLOCK(inode->i_sb);
 306        int ptrs_bits = EXT3_ADDR_PER_BLOCK_BITS(inode->i_sb);
 307        const long direct_blocks = EXT3_NDIR_BLOCKS,
 308                indirect_blocks = ptrs,
 309                double_blocks = (1 << (ptrs_bits * 2));
 310        int n = 0;
 311        int final = 0;
 312
 313        if (i_block < 0) {
 314                ext3_warning (inode->i_sb, "ext3_block_to_path", "block < 0");
 315        } else if (i_block < direct_blocks) {
 316                offsets[n++] = i_block;
 317                final = direct_blocks;
 318        } else if ( (i_block -= direct_blocks) < indirect_blocks) {
 319                offsets[n++] = EXT3_IND_BLOCK;
 320                offsets[n++] = i_block;
 321                final = ptrs;
 322        } else if ((i_block -= indirect_blocks) < double_blocks) {
 323                offsets[n++] = EXT3_DIND_BLOCK;
 324                offsets[n++] = i_block >> ptrs_bits;
 325                offsets[n++] = i_block & (ptrs - 1);
 326                final = ptrs;
 327        } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
 328                offsets[n++] = EXT3_TIND_BLOCK;
 329                offsets[n++] = i_block >> (ptrs_bits * 2);
 330                offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
 331                offsets[n++] = i_block & (ptrs - 1);
 332                final = ptrs;
 333        } else {
 334                ext3_warning(inode->i_sb, "ext3_block_to_path", "block > big");
 335        }
 336        if (boundary)
 337                *boundary = final - 1 - (i_block & (ptrs - 1));
 338        return n;
 339}
 340
 341/**
 342 *      ext3_get_branch - read the chain of indirect blocks leading to data
 343 *      @inode: inode in question
 344 *      @depth: depth of the chain (1 - direct pointer, etc.)
 345 *      @offsets: offsets of pointers in inode/indirect blocks
 346 *      @chain: place to store the result
 347 *      @err: here we store the error value
 348 *
 349 *      Function fills the array of triples <key, p, bh> and returns %NULL
 350 *      if everything went OK or the pointer to the last filled triple
 351 *      (incomplete one) otherwise. Upon the return chain[i].key contains
 352 *      the number of (i+1)-th block in the chain (as it is stored in memory,
 353 *      i.e. little-endian 32-bit), chain[i].p contains the address of that
 354 *      number (it points into struct inode for i==0 and into the bh->b_data
 355 *      for i>0) and chain[i].bh points to the buffer_head of i-th indirect
 356 *      block for i>0 and NULL for i==0. In other words, it holds the block
 357 *      numbers of the chain, addresses they were taken from (and where we can
 358 *      verify that chain did not change) and buffer_heads hosting these
 359 *      numbers.
 360 *
 361 *      Function stops when it stumbles upon zero pointer (absent block)
 362 *              (pointer to last triple returned, *@err == 0)
 363 *      or when it gets an IO error reading an indirect block
 364 *              (ditto, *@err == -EIO)
 365 *      or when it notices that chain had been changed while it was reading
 366 *              (ditto, *@err == -EAGAIN)
 367 *      or when it reads all @depth-1 indirect blocks successfully and finds
 368 *      the whole chain, all way to the data (returns %NULL, *err == 0).
 369 */
 370static Indirect *ext3_get_branch(struct inode *inode, int depth, int *offsets,
 371                                 Indirect chain[4], int *err)
 372{
 373        struct super_block *sb = inode->i_sb;
 374        Indirect *p = chain;
 375        struct buffer_head *bh;
 376
 377        *err = 0;
 378        /* i_data is not going away, no lock needed */
 379        add_chain (chain, NULL, EXT3_I(inode)->i_data + *offsets);
 380        if (!p->key)
 381                goto no_block;
 382        while (--depth) {
 383                bh = sb_bread(sb, le32_to_cpu(p->key));
 384                if (!bh)
 385                        goto failure;
 386                /* Reader: pointers */
 387                if (!verify_chain(chain, p))
 388                        goto changed;
 389                add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
 390                /* Reader: end */
 391                if (!p->key)
 392                        goto no_block;
 393        }
 394        return NULL;
 395
 396changed:
 397        brelse(bh);
 398        *err = -EAGAIN;
 399        goto no_block;
 400failure:
 401        *err = -EIO;
 402no_block:
 403        return p;
 404}
 405
 406/**
 407 *      ext3_find_near - find a place for allocation with sufficient locality
 408 *      @inode: owner
 409 *      @ind: descriptor of indirect block.
 410 *
 411 *      This function returns the preferred place for block allocation.
 412 *      It is used when heuristic for sequential allocation fails.
 413 *      Rules are:
 414 *        + if there is a block to the left of our position - allocate near it.
 415 *        + if pointer will live in indirect block - allocate near that block.
 416 *        + if pointer will live in inode - allocate in the same
 417 *          cylinder group.
 418 *
 419 * In the latter case we colour the starting block by the callers PID to
 420 * prevent it from clashing with concurrent allocations for a different inode
 421 * in the same block group.   The PID is used here so that functionally related
 422 * files will be close-by on-disk.
 423 *
 424 *      Caller must make sure that @ind is valid and will stay that way.
 425 */
 426static ext3_fsblk_t ext3_find_near(struct inode *inode, Indirect *ind)
 427{
 428        struct ext3_inode_info *ei = EXT3_I(inode);
 429        __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
 430        __le32 *p;
 431        ext3_fsblk_t bg_start;
 432        ext3_grpblk_t colour;
 433
 434        /* Try to find previous block */
 435        for (p = ind->p - 1; p >= start; p--) {
 436                if (*p)
 437                        return le32_to_cpu(*p);
 438        }
 439
 440        /* No such thing, so let's try location of indirect block */
 441        if (ind->bh)
 442                return ind->bh->b_blocknr;
 443
 444        /*
 445         * It is going to be referred to from the inode itself? OK, just put it
 446         * into the same cylinder group then.
 447         */
 448        bg_start = ext3_group_first_block_no(inode->i_sb, ei->i_block_group);
 449        colour = (current->pid % 16) *
 450                        (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
 451        return bg_start + colour;
 452}
 453
 454/**
 455 *      ext3_find_goal - find a preferred place for allocation.
 456 *      @inode: owner
 457 *      @block:  block we want
 458 *      @partial: pointer to the last triple within a chain
 459 *
 460 *      Normally this function find the preferred place for block allocation,
 461 *      returns it.
 462 */
 463
 464static ext3_fsblk_t ext3_find_goal(struct inode *inode, long block,
 465                                   Indirect *partial)
 466{
 467        struct ext3_block_alloc_info *block_i;
 468
 469        block_i =  EXT3_I(inode)->i_block_alloc_info;
 470
 471        /*
 472         * try the heuristic for sequential allocation,
 473         * failing that at least try to get decent locality.
 474         */
 475        if (block_i && (block == block_i->last_alloc_logical_block + 1)
 476                && (block_i->last_alloc_physical_block != 0)) {
 477                return block_i->last_alloc_physical_block + 1;
 478        }
 479
 480        return ext3_find_near(inode, partial);
 481}
 482
 483/**
 484 *      ext3_blks_to_allocate: Look up the block map and count the number
 485 *      of direct blocks need to be allocated for the given branch.
 486 *
 487 *      @branch: chain of indirect blocks
 488 *      @k: number of blocks need for indirect blocks
 489 *      @blks: number of data blocks to be mapped.
 490 *      @blocks_to_boundary:  the offset in the indirect block
 491 *
 492 *      return the total number of blocks to be allocate, including the
 493 *      direct and indirect blocks.
 494 */
 495static int ext3_blks_to_allocate(Indirect *branch, int k, unsigned long blks,
 496                int blocks_to_boundary)
 497{
 498        unsigned long count = 0;
 499
 500        /*
 501         * Simple case, [t,d]Indirect block(s) has not allocated yet
 502         * then it's clear blocks on that path have not allocated
 503         */
 504        if (k > 0) {
 505                /* right now we don't handle cross boundary allocation */
 506                if (blks < blocks_to_boundary + 1)
 507                        count += blks;
 508                else
 509                        count += blocks_to_boundary + 1;
 510                return count;
 511        }
 512
 513        count++;
 514        while (count < blks && count <= blocks_to_boundary &&
 515                le32_to_cpu(*(branch[0].p + count)) == 0) {
 516                count++;
 517        }
 518        return count;
 519}
 520
 521/**
 522 *      ext3_alloc_blocks: multiple allocate blocks needed for a branch
 523 *      @indirect_blks: the number of blocks need to allocate for indirect
 524 *                      blocks
 525 *
 526 *      @new_blocks: on return it will store the new block numbers for
 527 *      the indirect blocks(if needed) and the first direct block,
 528 *      @blks:  on return it will store the total number of allocated
 529 *              direct blocks
 530 */
 531static int ext3_alloc_blocks(handle_t *handle, struct inode *inode,
 532                        ext3_fsblk_t goal, int indirect_blks, int blks,
 533                        ext3_fsblk_t new_blocks[4], int *err)
 534{
 535        int target, i;
 536        unsigned long count = 0;
 537        int index = 0;
 538        ext3_fsblk_t current_block = 0;
 539        int ret = 0;
 540
 541        /*
 542         * Here we try to allocate the requested multiple blocks at once,
 543         * on a best-effort basis.
 544         * To build a branch, we should allocate blocks for
 545         * the indirect blocks(if not allocated yet), and at least
 546         * the first direct block of this branch.  That's the
 547         * minimum number of blocks need to allocate(required)
 548         */
 549        target = blks + indirect_blks;
 550
 551        while (1) {
 552                count = target;
 553                /* allocating blocks for indirect blocks and direct blocks */
 554                current_block = ext3_new_blocks(handle,inode,goal,&count,err);
 555                if (*err)
 556                        goto failed_out;
 557
 558                target -= count;
 559                /* allocate blocks for indirect blocks */
 560                while (index < indirect_blks && count) {
 561                        new_blocks[index++] = current_block++;
 562                        count--;
 563                }
 564
 565                if (count > 0)
 566                        break;
 567        }
 568
 569        /* save the new block number for the first direct block */
 570        new_blocks[index] = current_block;
 571
 572        /* total number of blocks allocated for direct blocks */
 573        ret = count;
 574        *err = 0;
 575        return ret;
 576failed_out:
 577        for (i = 0; i <index; i++)
 578                ext3_free_blocks(handle, inode, new_blocks[i], 1);
 579        return ret;
 580}
 581
 582/**
 583 *      ext3_alloc_branch - allocate and set up a chain of blocks.
 584 *      @inode: owner
 585 *      @indirect_blks: number of allocated indirect blocks
 586 *      @blks: number of allocated direct blocks
 587 *      @offsets: offsets (in the blocks) to store the pointers to next.
 588 *      @branch: place to store the chain in.
 589 *
 590 *      This function allocates blocks, zeroes out all but the last one,
 591 *      links them into chain and (if we are synchronous) writes them to disk.
 592 *      In other words, it prepares a branch that can be spliced onto the
 593 *      inode. It stores the information about that chain in the branch[], in
 594 *      the same format as ext3_get_branch() would do. We are calling it after
 595 *      we had read the existing part of chain and partial points to the last
 596 *      triple of that (one with zero ->key). Upon the exit we have the same
 597 *      picture as after the successful ext3_get_block(), except that in one
 598 *      place chain is disconnected - *branch->p is still zero (we did not
 599 *      set the last link), but branch->key contains the number that should
 600 *      be placed into *branch->p to fill that gap.
 601 *
 602 *      If allocation fails we free all blocks we've allocated (and forget
 603 *      their buffer_heads) and return the error value the from failed
 604 *      ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
 605 *      as described above and return 0.
 606 */
 607static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
 608                        int indirect_blks, int *blks, ext3_fsblk_t goal,
 609                        int *offsets, Indirect *branch)
 610{
 611        int blocksize = inode->i_sb->s_blocksize;
 612        int i, n = 0;
 613        int err = 0;
 614        struct buffer_head *bh;
 615        int num;
 616        ext3_fsblk_t new_blocks[4];
 617        ext3_fsblk_t current_block;
 618
 619        num = ext3_alloc_blocks(handle, inode, goal, indirect_blks,
 620                                *blks, new_blocks, &err);
 621        if (err)
 622                return err;
 623
 624        branch[0].key = cpu_to_le32(new_blocks[0]);
 625        /*
 626         * metadata blocks and data blocks are allocated.
 627         */
 628        for (n = 1; n <= indirect_blks;  n++) {
 629                /*
 630                 * Get buffer_head for parent block, zero it out
 631                 * and set the pointer to new one, then send
 632                 * parent to disk.
 633                 */
 634                bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
 635                branch[n].bh = bh;
 636                lock_buffer(bh);
 637                BUFFER_TRACE(bh, "call get_create_access");
 638                err = ext3_journal_get_create_access(handle, bh);
 639                if (err) {
 640                        unlock_buffer(bh);
 641                        brelse(bh);
 642                        goto failed;
 643                }
 644
 645                memset(bh->b_data, 0, blocksize);
 646                branch[n].p = (__le32 *) bh->b_data + offsets[n];
 647                branch[n].key = cpu_to_le32(new_blocks[n]);
 648                *branch[n].p = branch[n].key;
 649                if ( n == indirect_blks) {
 650                        current_block = new_blocks[n];
 651                        /*
 652                         * End of chain, update the last new metablock of
 653                         * the chain to point to the new allocated
 654                         * data blocks numbers
 655                         */
 656                        for (i=1; i < num; i++)
 657                                *(branch[n].p + i) = cpu_to_le32(++current_block);
 658                }
 659                BUFFER_TRACE(bh, "marking uptodate");
 660                set_buffer_uptodate(bh);
 661                unlock_buffer(bh);
 662
 663                BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
 664                err = ext3_journal_dirty_metadata(handle, bh);
 665                if (err)
 666                        goto failed;
 667        }
 668        *blks = num;
 669        return err;
 670failed:
 671        /* Allocation failed, free what we already allocated */
 672        for (i = 1; i <= n ; i++) {
 673                BUFFER_TRACE(branch[i].bh, "call journal_forget");
 674                ext3_journal_forget(handle, branch[i].bh);
 675        }
 676        for (i = 0; i <indirect_blks; i++)
 677                ext3_free_blocks(handle, inode, new_blocks[i], 1);
 678
 679        ext3_free_blocks(handle, inode, new_blocks[i], num);
 680
 681        return err;
 682}
 683
 684/**
 685 * ext3_splice_branch - splice the allocated branch onto inode.
 686 * @inode: owner
 687 * @block: (logical) number of block we are adding
 688 * @chain: chain of indirect blocks (with a missing link - see
 689 *      ext3_alloc_branch)
 690 * @where: location of missing link
 691 * @num:   number of indirect blocks we are adding
 692 * @blks:  number of direct blocks we are adding
 693 *
 694 * This function fills the missing link and does all housekeeping needed in
 695 * inode (->i_blocks, etc.). In case of success we end up with the full
 696 * chain to new block and return 0.
 697 */
 698static int ext3_splice_branch(handle_t *handle, struct inode *inode,
 699                        long block, Indirect *where, int num, int blks)
 700{
 701        int i;
 702        int err = 0;
 703        struct ext3_block_alloc_info *block_i;
 704        ext3_fsblk_t current_block;
 705        struct ext3_inode_info *ei = EXT3_I(inode);
 706
 707        block_i = ei->i_block_alloc_info;
 708        /*
 709         * If we're splicing into a [td]indirect block (as opposed to the
 710         * inode) then we need to get write access to the [td]indirect block
 711         * before the splice.
 712         */
 713        if (where->bh) {
 714                BUFFER_TRACE(where->bh, "get_write_access");
 715                err = ext3_journal_get_write_access(handle, where->bh);
 716                if (err)
 717                        goto err_out;
 718        }
 719        /* That's it */
 720
 721        *where->p = where->key;
 722
 723        /*
 724         * Update the host buffer_head or inode to point to more just allocated
 725         * direct blocks blocks
 726         */
 727        if (num == 0 && blks > 1) {
 728                current_block = le32_to_cpu(where->key) + 1;
 729                for (i = 1; i < blks; i++)
 730                        *(where->p + i ) = cpu_to_le32(current_block++);
 731        }
 732
 733        /*
 734         * update the most recently allocated logical & physical block
 735         * in i_block_alloc_info, to assist find the proper goal block for next
 736         * allocation
 737         */
 738        if (block_i) {
 739                block_i->last_alloc_logical_block = block + blks - 1;
 740                block_i->last_alloc_physical_block =
 741                                le32_to_cpu(where[num].key) + blks - 1;
 742        }
 743
 744        /* We are done with atomic stuff, now do the rest of housekeeping */
 745
 746        inode->i_ctime = CURRENT_TIME_SEC;
 747        ext3_mark_inode_dirty(handle, inode);
 748        /* ext3_mark_inode_dirty already updated i_sync_tid */
 749        atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
 750
 751        /* had we spliced it onto indirect block? */
 752        if (where->bh) {
 753                /*
 754                 * If we spliced it onto an indirect block, we haven't
 755                 * altered the inode.  Note however that if it is being spliced
 756                 * onto an indirect block at the very end of the file (the
 757                 * file is growing) then we *will* alter the inode to reflect
 758                 * the new i_size.  But that is not done here - it is done in
 759                 * generic_commit_write->__mark_inode_dirty->ext3_dirty_inode.
 760                 */
 761                jbd_debug(5, "splicing indirect only\n");
 762                BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
 763                err = ext3_journal_dirty_metadata(handle, where->bh);
 764                if (err)
 765                        goto err_out;
 766        } else {
 767                /*
 768                 * OK, we spliced it into the inode itself on a direct block.
 769                 * Inode was dirtied above.
 770                 */
 771                jbd_debug(5, "splicing direct\n");
 772        }
 773        return err;
 774
 775err_out:
 776        for (i = 1; i <= num; i++) {
 777                BUFFER_TRACE(where[i].bh, "call journal_forget");
 778                ext3_journal_forget(handle, where[i].bh);
 779                ext3_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
 780        }
 781        ext3_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks);
 782
 783        return err;
 784}
 785
 786/*
 787 * Allocation strategy is simple: if we have to allocate something, we will
 788 * have to go the whole way to leaf. So let's do it before attaching anything
 789 * to tree, set linkage between the newborn blocks, write them if sync is
 790 * required, recheck the path, free and repeat if check fails, otherwise
 791 * set the last missing link (that will protect us from any truncate-generated
 792 * removals - all blocks on the path are immune now) and possibly force the
 793 * write on the parent block.
 794 * That has a nice additional property: no special recovery from the failed
 795 * allocations is needed - we simply release blocks and do not touch anything
 796 * reachable from inode.
 797 *
 798 * `handle' can be NULL if create == 0.
 799 *
 800 * The BKL may not be held on entry here.  Be sure to take it early.
 801 * return > 0, # of blocks mapped or allocated.
 802 * return = 0, if plain lookup failed.
 803 * return < 0, error case.
 804 */
 805int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
 806                sector_t iblock, unsigned long maxblocks,
 807                struct buffer_head *bh_result,
 808                int create)
 809{
 810        int err = -EIO;
 811        int offsets[4];
 812        Indirect chain[4];
 813        Indirect *partial;
 814        ext3_fsblk_t goal;
 815        int indirect_blks;
 816        int blocks_to_boundary = 0;
 817        int depth;
 818        struct ext3_inode_info *ei = EXT3_I(inode);
 819        int count = 0;
 820        ext3_fsblk_t first_block = 0;
 821
 822
 823        J_ASSERT(handle != NULL || create == 0);
 824        depth = ext3_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
 825
 826        if (depth == 0)
 827                goto out;
 828
 829        partial = ext3_get_branch(inode, depth, offsets, chain, &err);
 830
 831        /* Simplest case - block found, no allocation needed */
 832        if (!partial) {
 833                first_block = le32_to_cpu(chain[depth - 1].key);
 834                clear_buffer_new(bh_result);
 835                count++;
 836                /*map more blocks*/
 837                while (count < maxblocks && count <= blocks_to_boundary) {
 838                        ext3_fsblk_t blk;
 839
 840                        if (!verify_chain(chain, chain + depth - 1)) {
 841                                /*
 842                                 * Indirect block might be removed by
 843                                 * truncate while we were reading it.
 844                                 * Handling of that case: forget what we've
 845                                 * got now. Flag the err as EAGAIN, so it
 846                                 * will reread.
 847                                 */
 848                                err = -EAGAIN;
 849                                count = 0;
 850                                break;
 851                        }
 852                        blk = le32_to_cpu(*(chain[depth-1].p + count));
 853
 854                        if (blk == first_block + count)
 855                                count++;
 856                        else
 857                                break;
 858                }
 859                if (err != -EAGAIN)
 860                        goto got_it;
 861        }
 862
 863        /* Next simple case - plain lookup or failed read of indirect block */
 864        if (!create || err == -EIO)
 865                goto cleanup;
 866
 867        mutex_lock(&ei->truncate_mutex);
 868
 869        /*
 870         * If the indirect block is missing while we are reading
 871         * the chain(ext3_get_branch() returns -EAGAIN err), or
 872         * if the chain has been changed after we grab the semaphore,
 873         * (either because another process truncated this branch, or
 874         * another get_block allocated this branch) re-grab the chain to see if
 875         * the request block has been allocated or not.
 876         *
 877         * Since we already block the truncate/other get_block
 878         * at this point, we will have the current copy of the chain when we
 879         * splice the branch into the tree.
 880         */
 881        if (err == -EAGAIN || !verify_chain(chain, partial)) {
 882                while (partial > chain) {
 883                        brelse(partial->bh);
 884                        partial--;
 885                }
 886                partial = ext3_get_branch(inode, depth, offsets, chain, &err);
 887                if (!partial) {
 888                        count++;
 889                        mutex_unlock(&ei->truncate_mutex);
 890                        if (err)
 891                                goto cleanup;
 892                        clear_buffer_new(bh_result);
 893                        goto got_it;
 894                }
 895        }
 896
 897        /*
 898         * Okay, we need to do block allocation.  Lazily initialize the block
 899         * allocation info here if necessary
 900        */
 901        if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
 902                ext3_init_block_alloc_info(inode);
 903
 904        goal = ext3_find_goal(inode, iblock, partial);
 905
 906        /* the number of blocks need to allocate for [d,t]indirect blocks */
 907        indirect_blks = (chain + depth) - partial - 1;
 908
 909        /*
 910         * Next look up the indirect map to count the totoal number of
 911         * direct blocks to allocate for this branch.
 912         */
 913        count = ext3_blks_to_allocate(partial, indirect_blks,
 914                                        maxblocks, blocks_to_boundary);
 915        /*
 916         * Block out ext3_truncate while we alter the tree
 917         */
 918        err = ext3_alloc_branch(handle, inode, indirect_blks, &count, goal,
 919                                offsets + (partial - chain), partial);
 920
 921        /*
 922         * The ext3_splice_branch call will free and forget any buffers
 923         * on the new chain if there is a failure, but that risks using
 924         * up transaction credits, especially for bitmaps where the
 925         * credits cannot be returned.  Can we handle this somehow?  We
 926         * may need to return -EAGAIN upwards in the worst case.  --sct
 927         */
 928        if (!err)
 929                err = ext3_splice_branch(handle, inode, iblock,
 930                                        partial, indirect_blks, count);
 931        mutex_unlock(&ei->truncate_mutex);
 932        if (err)
 933                goto cleanup;
 934
 935        set_buffer_new(bh_result);
 936got_it:
 937        map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
 938        if (count > blocks_to_boundary)
 939                set_buffer_boundary(bh_result);
 940        err = count;
 941        /* Clean up and exit */
 942        partial = chain + depth - 1;    /* the whole chain */
 943cleanup:
 944        while (partial > chain) {
 945                BUFFER_TRACE(partial->bh, "call brelse");
 946                brelse(partial->bh);
 947                partial--;
 948        }
 949        BUFFER_TRACE(bh_result, "returned");
 950out:
 951        return err;
 952}
 953
 954/* Maximum number of blocks we map for direct IO at once. */
 955#define DIO_MAX_BLOCKS 4096
 956/*
 957 * Number of credits we need for writing DIO_MAX_BLOCKS:
 958 * We need sb + group descriptor + bitmap + inode -> 4
 959 * For B blocks with A block pointers per block we need:
 960 * 1 (triple ind.) + (B/A/A + 2) (doubly ind.) + (B/A + 2) (indirect).
 961 * If we plug in 4096 for B and 256 for A (for 1KB block size), we get 25.
 962 */
 963#define DIO_CREDITS 25
 964
 965static int ext3_get_block(struct inode *inode, sector_t iblock,
 966                        struct buffer_head *bh_result, int create)
 967{
 968        handle_t *handle = ext3_journal_current_handle();
 969        int ret = 0, started = 0;
 970        unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
 971
 972        if (create && !handle) {        /* Direct IO write... */
 973                if (max_blocks > DIO_MAX_BLOCKS)
 974                        max_blocks = DIO_MAX_BLOCKS;
 975                handle = ext3_journal_start(inode, DIO_CREDITS +
 976                                EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
 977                if (IS_ERR(handle)) {
 978                        ret = PTR_ERR(handle);
 979                        goto out;
 980                }
 981                started = 1;
 982        }
 983
 984        ret = ext3_get_blocks_handle(handle, inode, iblock,
 985                                        max_blocks, bh_result, create);
 986        if (ret > 0) {
 987                bh_result->b_size = (ret << inode->i_blkbits);
 988                ret = 0;
 989        }
 990        if (started)
 991                ext3_journal_stop(handle);
 992out:
 993        return ret;
 994}
 995
 996int ext3_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 997                u64 start, u64 len)
 998{
 999        return generic_block_fiemap(inode, fieinfo, start, len,
1000                                    ext3_get_block);
1001}
1002
1003/*
1004 * `handle' can be NULL if create is zero
1005 */
1006struct buffer_head *ext3_getblk(handle_t *handle, struct inode *inode,
1007                                long block, int create, int *errp)
1008{
1009        struct buffer_head dummy;
1010        int fatal = 0, err;
1011
1012        J_ASSERT(handle != NULL || create == 0);
1013
1014        dummy.b_state = 0;
1015        dummy.b_blocknr = -1000;
1016        buffer_trace_init(&dummy.b_history);
1017        err = ext3_get_blocks_handle(handle, inode, block, 1,
1018                                        &dummy, create);
1019        /*
1020         * ext3_get_blocks_handle() returns number of blocks
1021         * mapped. 0 in case of a HOLE.
1022         */
1023        if (err > 0) {
1024                if (err > 1)
1025                        WARN_ON(1);
1026                err = 0;
1027        }
1028        *errp = err;
1029        if (!err && buffer_mapped(&dummy)) {
1030                struct buffer_head *bh;
1031                bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1032                if (!bh) {
1033                        *errp = -EIO;
1034                        goto err;
1035                }
1036                if (buffer_new(&dummy)) {
1037                        J_ASSERT(create != 0);
1038                        J_ASSERT(handle != NULL);
1039
1040                        /*
1041                         * Now that we do not always journal data, we should
1042                         * keep in mind whether this should always journal the
1043                         * new buffer as metadata.  For now, regular file
1044                         * writes use ext3_get_block instead, so it's not a
1045                         * problem.
1046                         */
1047                        lock_buffer(bh);
1048                        BUFFER_TRACE(bh, "call get_create_access");
1049                        fatal = ext3_journal_get_create_access(handle, bh);
1050                        if (!fatal && !buffer_uptodate(bh)) {
1051                                memset(bh->b_data,0,inode->i_sb->s_blocksize);
1052                                set_buffer_uptodate(bh);
1053                        }
1054                        unlock_buffer(bh);
1055                        BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1056                        err = ext3_journal_dirty_metadata(handle, bh);
1057                        if (!fatal)
1058                                fatal = err;
1059                } else {
1060                        BUFFER_TRACE(bh, "not a new buffer");
1061                }
1062                if (fatal) {
1063                        *errp = fatal;
1064                        brelse(bh);
1065                        bh = NULL;
1066                }
1067                return bh;
1068        }
1069err:
1070        return NULL;
1071}
1072
1073struct buffer_head *ext3_bread(handle_t *handle, struct inode *inode,
1074                               int block, int create, int *err)
1075{
1076        struct buffer_head * bh;
1077
1078        bh = ext3_getblk(handle, inode, block, create, err);
1079        if (!bh)
1080                return bh;
1081        if (buffer_uptodate(bh))
1082                return bh;
1083        ll_rw_block(READ_META, 1, &bh);
1084        wait_on_buffer(bh);
1085        if (buffer_uptodate(bh))
1086                return bh;
1087        put_bh(bh);
1088        *err = -EIO;
1089        return NULL;
1090}
1091
1092static int walk_page_buffers(   handle_t *handle,
1093                                struct buffer_head *head,
1094                                unsigned from,
1095                                unsigned to,
1096                                int *partial,
1097                                int (*fn)(      handle_t *handle,
1098                                                struct buffer_head *bh))
1099{
1100        struct buffer_head *bh;
1101        unsigned block_start, block_end;
1102        unsigned blocksize = head->b_size;
1103        int err, ret = 0;
1104        struct buffer_head *next;
1105
1106        for (   bh = head, block_start = 0;
1107                ret == 0 && (bh != head || !block_start);
1108                block_start = block_end, bh = next)
1109        {
1110                next = bh->b_this_page;
1111                block_end = block_start + blocksize;
1112                if (block_end <= from || block_start >= to) {
1113                        if (partial && !buffer_uptodate(bh))
1114                                *partial = 1;
1115                        continue;
1116                }
1117                err = (*fn)(handle, bh);
1118                if (!ret)
1119                        ret = err;
1120        }
1121        return ret;
1122}
1123
1124/*
1125 * To preserve ordering, it is essential that the hole instantiation and
1126 * the data write be encapsulated in a single transaction.  We cannot
1127 * close off a transaction and start a new one between the ext3_get_block()
1128 * and the commit_write().  So doing the journal_start at the start of
1129 * prepare_write() is the right place.
1130 *
1131 * Also, this function can nest inside ext3_writepage() ->
1132 * block_write_full_page(). In that case, we *know* that ext3_writepage()
1133 * has generated enough buffer credits to do the whole page.  So we won't
1134 * block on the journal in that case, which is good, because the caller may
1135 * be PF_MEMALLOC.
1136 *
1137 * By accident, ext3 can be reentered when a transaction is open via
1138 * quota file writes.  If we were to commit the transaction while thus
1139 * reentered, there can be a deadlock - we would be holding a quota
1140 * lock, and the commit would never complete if another thread had a
1141 * transaction open and was blocking on the quota lock - a ranking
1142 * violation.
1143 *
1144 * So what we do is to rely on the fact that journal_stop/journal_start
1145 * will _not_ run commit under these circumstances because handle->h_ref
1146 * is elevated.  We'll still have enough credits for the tiny quotafile
1147 * write.
1148 */
1149static int do_journal_get_write_access(handle_t *handle,
1150                                        struct buffer_head *bh)
1151{
1152        if (!buffer_mapped(bh) || buffer_freed(bh))
1153                return 0;
1154        return ext3_journal_get_write_access(handle, bh);
1155}
1156
1157/*
1158 * Truncate blocks that were not used by write. We have to truncate the
1159 * pagecache as well so that corresponding buffers get properly unmapped.
1160 */
1161static void ext3_truncate_failed_write(struct inode *inode)
1162{
1163        truncate_inode_pages(inode->i_mapping, inode->i_size);
1164        ext3_truncate(inode);
1165}
1166
1167static int ext3_write_begin(struct file *file, struct address_space *mapping,
1168                                loff_t pos, unsigned len, unsigned flags,
1169                                struct page **pagep, void **fsdata)
1170{
1171        struct inode *inode = mapping->host;
1172        int ret;
1173        handle_t *handle;
1174        int retries = 0;
1175        struct page *page;
1176        pgoff_t index;
1177        unsigned from, to;
1178        /* Reserve one block more for addition to orphan list in case
1179         * we allocate blocks but write fails for some reason */
1180        int needed_blocks = ext3_writepage_trans_blocks(inode) + 1;
1181
1182        index = pos >> PAGE_CACHE_SHIFT;
1183        from = pos & (PAGE_CACHE_SIZE - 1);
1184        to = from + len;
1185
1186retry:
1187        page = grab_cache_page_write_begin(mapping, index, flags);
1188        if (!page)
1189                return -ENOMEM;
1190        *pagep = page;
1191
1192        handle = ext3_journal_start(inode, needed_blocks);
1193        if (IS_ERR(handle)) {
1194                unlock_page(page);
1195                page_cache_release(page);
1196                ret = PTR_ERR(handle);
1197                goto out;
1198        }
1199        ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
1200                                                        ext3_get_block);
1201        if (ret)
1202                goto write_begin_failed;
1203
1204        if (ext3_should_journal_data(inode)) {
1205                ret = walk_page_buffers(handle, page_buffers(page),
1206                                from, to, NULL, do_journal_get_write_access);
1207        }
1208write_begin_failed:
1209        if (ret) {
1210                /*
1211                 * block_write_begin may have instantiated a few blocks
1212                 * outside i_size.  Trim these off again. Don't need
1213                 * i_size_read because we hold i_mutex.
1214                 *
1215                 * Add inode to orphan list in case we crash before truncate
1216                 * finishes. Do this only if ext3_can_truncate() agrees so
1217                 * that orphan processing code is happy.
1218                 */
1219                if (pos + len > inode->i_size && ext3_can_truncate(inode))
1220                        ext3_orphan_add(handle, inode);
1221                ext3_journal_stop(handle);
1222                unlock_page(page);
1223                page_cache_release(page);
1224                if (pos + len > inode->i_size)
1225                        ext3_truncate_failed_write(inode);
1226        }
1227        if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1228                goto retry;
1229out:
1230        return ret;
1231}
1232
1233
1234int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1235{
1236        int err = journal_dirty_data(handle, bh);
1237        if (err)
1238                ext3_journal_abort_handle(__func__, __func__,
1239                                                bh, handle, err);
1240        return err;
1241}
1242
1243/* For ordered writepage and write_end functions */
1244static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1245{
1246        /*
1247         * Write could have mapped the buffer but it didn't copy the data in
1248         * yet. So avoid filing such buffer into a transaction.
1249         */
1250        if (buffer_mapped(bh) && buffer_uptodate(bh))
1251                return ext3_journal_dirty_data(handle, bh);
1252        return 0;
1253}
1254
1255/* For write_end() in data=journal mode */
1256static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1257{
1258        if (!buffer_mapped(bh) || buffer_freed(bh))
1259                return 0;
1260        set_buffer_uptodate(bh);
1261        return ext3_journal_dirty_metadata(handle, bh);
1262}
1263
1264/*
1265 * This is nasty and subtle: ext3_write_begin() could have allocated blocks
1266 * for the whole page but later we failed to copy the data in. Update inode
1267 * size according to what we managed to copy. The rest is going to be
1268 * truncated in write_end function.
1269 */
1270static void update_file_sizes(struct inode *inode, loff_t pos, unsigned copied)
1271{
1272        /* What matters to us is i_disksize. We don't write i_size anywhere */
1273        if (pos + copied > inode->i_size)
1274                i_size_write(inode, pos + copied);
1275        if (pos + copied > EXT3_I(inode)->i_disksize) {
1276                EXT3_I(inode)->i_disksize = pos + copied;
1277                mark_inode_dirty(inode);
1278        }
1279}
1280
1281/*
1282 * We need to pick up the new inode size which generic_commit_write gave us
1283 * `file' can be NULL - eg, when called from page_symlink().
1284 *
1285 * ext3 never places buffers on inode->i_mapping->private_list.  metadata
1286 * buffers are managed internally.
1287 */
1288static int ext3_ordered_write_end(struct file *file,
1289                                struct address_space *mapping,
1290                                loff_t pos, unsigned len, unsigned copied,
1291                                struct page *page, void *fsdata)
1292{
1293        handle_t *handle = ext3_journal_current_handle();
1294        struct inode *inode = file->f_mapping->host;
1295        unsigned from, to;
1296        int ret = 0, ret2;
1297
1298        copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1299
1300        from = pos & (PAGE_CACHE_SIZE - 1);
1301        to = from + copied;
1302        ret = walk_page_buffers(handle, page_buffers(page),
1303                from, to, NULL, journal_dirty_data_fn);
1304
1305        if (ret == 0)
1306                update_file_sizes(inode, pos, copied);
1307        /*
1308         * There may be allocated blocks outside of i_size because
1309         * we failed to copy some data. Prepare for truncate.
1310         */
1311        if (pos + len > inode->i_size && ext3_can_truncate(inode))
1312                ext3_orphan_add(handle, inode);
1313        ret2 = ext3_journal_stop(handle);
1314        if (!ret)
1315                ret = ret2;
1316        unlock_page(page);
1317        page_cache_release(page);
1318
1319        if (pos + len > inode->i_size)
1320                ext3_truncate_failed_write(inode);
1321        return ret ? ret : copied;
1322}
1323
1324static int ext3_writeback_write_end(struct file *file,
1325                                struct address_space *mapping,
1326                                loff_t pos, unsigned len, unsigned copied,
1327                                struct page *page, void *fsdata)
1328{
1329        handle_t *handle = ext3_journal_current_handle();
1330        struct inode *inode = file->f_mapping->host;
1331        int ret;
1332
1333        copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1334        update_file_sizes(inode, pos, copied);
1335        /*
1336         * There may be allocated blocks outside of i_size because
1337         * we failed to copy some data. Prepare for truncate.
1338         */
1339        if (pos + len > inode->i_size && ext3_can_truncate(inode))
1340                ext3_orphan_add(handle, inode);
1341        ret = ext3_journal_stop(handle);
1342        unlock_page(page);
1343        page_cache_release(page);
1344
1345        if (pos + len > inode->i_size)
1346                ext3_truncate_failed_write(inode);
1347        return ret ? ret : copied;
1348}
1349
1350static int ext3_journalled_write_end(struct file *file,
1351                                struct address_space *mapping,
1352                                loff_t pos, unsigned len, unsigned copied,
1353                                struct page *page, void *fsdata)
1354{
1355        handle_t *handle = ext3_journal_current_handle();
1356        struct inode *inode = mapping->host;
1357        int ret = 0, ret2;
1358        int partial = 0;
1359        unsigned from, to;
1360
1361        from = pos & (PAGE_CACHE_SIZE - 1);
1362        to = from + len;
1363
1364        if (copied < len) {
1365                if (!PageUptodate(page))
1366                        copied = 0;
1367                page_zero_new_buffers(page, from + copied, to);
1368                to = from + copied;
1369        }
1370
1371        ret = walk_page_buffers(handle, page_buffers(page), from,
1372                                to, &partial, write_end_fn);
1373        if (!partial)
1374                SetPageUptodate(page);
1375
1376        if (pos + copied > inode->i_size)
1377                i_size_write(inode, pos + copied);
1378        /*
1379         * There may be allocated blocks outside of i_size because
1380         * we failed to copy some data. Prepare for truncate.
1381         */
1382        if (pos + len > inode->i_size && ext3_can_truncate(inode))
1383                ext3_orphan_add(handle, inode);
1384        ext3_set_inode_state(inode, EXT3_STATE_JDATA);
1385        if (inode->i_size > EXT3_I(inode)->i_disksize) {
1386                EXT3_I(inode)->i_disksize = inode->i_size;
1387                ret2 = ext3_mark_inode_dirty(handle, inode);
1388                if (!ret)
1389                        ret = ret2;
1390        }
1391
1392        ret2 = ext3_journal_stop(handle);
1393        if (!ret)
1394                ret = ret2;
1395        unlock_page(page);
1396        page_cache_release(page);
1397
1398        if (pos + len > inode->i_size)
1399                ext3_truncate_failed_write(inode);
1400        return ret ? ret : copied;
1401}
1402
1403/*
1404 * bmap() is special.  It gets used by applications such as lilo and by
1405 * the swapper to find the on-disk block of a specific piece of data.
1406 *
1407 * Naturally, this is dangerous if the block concerned is still in the
1408 * journal.  If somebody makes a swapfile on an ext3 data-journaling
1409 * filesystem and enables swap, then they may get a nasty shock when the
1410 * data getting swapped to that swapfile suddenly gets overwritten by
1411 * the original zero's written out previously to the journal and
1412 * awaiting writeback in the kernel's buffer cache.
1413 *
1414 * So, if we see any bmap calls here on a modified, data-journaled file,
1415 * take extra steps to flush any blocks which might be in the cache.
1416 */
1417static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
1418{
1419        struct inode *inode = mapping->host;
1420        journal_t *journal;
1421        int err;
1422
1423        if (ext3_test_inode_state(inode, EXT3_STATE_JDATA)) {
1424                /*
1425                 * This is a REALLY heavyweight approach, but the use of
1426                 * bmap on dirty files is expected to be extremely rare:
1427                 * only if we run lilo or swapon on a freshly made file
1428                 * do we expect this to happen.
1429                 *
1430                 * (bmap requires CAP_SYS_RAWIO so this does not
1431                 * represent an unprivileged user DOS attack --- we'd be
1432                 * in trouble if mortal users could trigger this path at
1433                 * will.)
1434                 *
1435                 * NB. EXT3_STATE_JDATA is not set on files other than
1436                 * regular files.  If somebody wants to bmap a directory
1437                 * or symlink and gets confused because the buffer
1438                 * hasn't yet been flushed to disk, they deserve
1439                 * everything they get.
1440                 */
1441
1442                ext3_clear_inode_state(inode, EXT3_STATE_JDATA);
1443                journal = EXT3_JOURNAL(inode);
1444                journal_lock_updates(journal);
1445                err = journal_flush(journal);
1446                journal_unlock_updates(journal);
1447
1448                if (err)
1449                        return 0;
1450        }
1451
1452        return generic_block_bmap(mapping,block,ext3_get_block);
1453}
1454
1455static int bget_one(handle_t *handle, struct buffer_head *bh)
1456{
1457        get_bh(bh);
1458        return 0;
1459}
1460
1461static int bput_one(handle_t *handle, struct buffer_head *bh)
1462{
1463        put_bh(bh);
1464        return 0;
1465}
1466
1467static int buffer_unmapped(handle_t *handle, struct buffer_head *bh)
1468{
1469        return !buffer_mapped(bh);
1470}
1471
1472/*
1473 * Note that we always start a transaction even if we're not journalling
1474 * data.  This is to preserve ordering: any hole instantiation within
1475 * __block_write_full_page -> ext3_get_block() should be journalled
1476 * along with the data so we don't crash and then get metadata which
1477 * refers to old data.
1478 *
1479 * In all journalling modes block_write_full_page() will start the I/O.
1480 *
1481 * Problem:
1482 *
1483 *      ext3_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1484 *              ext3_writepage()
1485 *
1486 * Similar for:
1487 *
1488 *      ext3_file_write() -> generic_file_write() -> __alloc_pages() -> ...
1489 *
1490 * Same applies to ext3_get_block().  We will deadlock on various things like
1491 * lock_journal and i_truncate_mutex.
1492 *
1493 * Setting PF_MEMALLOC here doesn't work - too many internal memory
1494 * allocations fail.
1495 *
1496 * 16May01: If we're reentered then journal_current_handle() will be
1497 *          non-zero. We simply *return*.
1498 *
1499 * 1 July 2001: @@@ FIXME:
1500 *   In journalled data mode, a data buffer may be metadata against the
1501 *   current transaction.  But the same file is part of a shared mapping
1502 *   and someone does a writepage() on it.
1503 *
1504 *   We will move the buffer onto the async_data list, but *after* it has
1505 *   been dirtied. So there's a small window where we have dirty data on
1506 *   BJ_Metadata.
1507 *
1508 *   Note that this only applies to the last partial page in the file.  The
1509 *   bit which block_write_full_page() uses prepare/commit for.  (That's
1510 *   broken code anyway: it's wrong for msync()).
1511 *
1512 *   It's a rare case: affects the final partial page, for journalled data
1513 *   where the file is subject to bith write() and writepage() in the same
1514 *   transction.  To fix it we'll need a custom block_write_full_page().
1515 *   We'll probably need that anyway for journalling writepage() output.
1516 *
1517 * We don't honour synchronous mounts for writepage().  That would be
1518 * disastrous.  Any write() or metadata operation will sync the fs for
1519 * us.
1520 *
1521 * AKPM2: if all the page's buffers are mapped to disk and !data=journal,
1522 * we don't need to open a transaction here.
1523 */
1524static int ext3_ordered_writepage(struct page *page,
1525                                struct writeback_control *wbc)
1526{
1527        struct inode *inode = page->mapping->host;
1528        struct buffer_head *page_bufs;
1529        handle_t *handle = NULL;
1530        int ret = 0;
1531        int err;
1532
1533        J_ASSERT(PageLocked(page));
1534        WARN_ON_ONCE(IS_RDONLY(inode));
1535
1536        /*
1537         * We give up here if we're reentered, because it might be for a
1538         * different filesystem.
1539         */
1540        if (ext3_journal_current_handle())
1541                goto out_fail;
1542
1543        if (!page_has_buffers(page)) {
1544                create_empty_buffers(page, inode->i_sb->s_blocksize,
1545                                (1 << BH_Dirty)|(1 << BH_Uptodate));
1546                page_bufs = page_buffers(page);
1547        } else {
1548                page_bufs = page_buffers(page);
1549                if (!walk_page_buffers(NULL, page_bufs, 0, PAGE_CACHE_SIZE,
1550                                       NULL, buffer_unmapped)) {
1551                        /* Provide NULL get_block() to catch bugs if buffers
1552                         * weren't really mapped */
1553                        return block_write_full_page(page, NULL, wbc);
1554                }
1555        }
1556        handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1557
1558        if (IS_ERR(handle)) {
1559                ret = PTR_ERR(handle);
1560                goto out_fail;
1561        }
1562
1563        walk_page_buffers(handle, page_bufs, 0,
1564                        PAGE_CACHE_SIZE, NULL, bget_one);
1565
1566        ret = block_write_full_page(page, ext3_get_block, wbc);
1567
1568        /*
1569         * The page can become unlocked at any point now, and
1570         * truncate can then come in and change things.  So we
1571         * can't touch *page from now on.  But *page_bufs is
1572         * safe due to elevated refcount.
1573         */
1574
1575        /*
1576         * And attach them to the current transaction.  But only if
1577         * block_write_full_page() succeeded.  Otherwise they are unmapped,
1578         * and generally junk.
1579         */
1580        if (ret == 0) {
1581                err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
1582                                        NULL, journal_dirty_data_fn);
1583                if (!ret)
1584                        ret = err;
1585        }
1586        walk_page_buffers(handle, page_bufs, 0,
1587                        PAGE_CACHE_SIZE, NULL, bput_one);
1588        err = ext3_journal_stop(handle);
1589        if (!ret)
1590                ret = err;
1591        return ret;
1592
1593out_fail:
1594        redirty_page_for_writepage(wbc, page);
1595        unlock_page(page);
1596        return ret;
1597}
1598
1599static int ext3_writeback_writepage(struct page *page,
1600                                struct writeback_control *wbc)
1601{
1602        struct inode *inode = page->mapping->host;
1603        handle_t *handle = NULL;
1604        int ret = 0;
1605        int err;
1606
1607        J_ASSERT(PageLocked(page));
1608        WARN_ON_ONCE(IS_RDONLY(inode));
1609
1610        if (ext3_journal_current_handle())
1611                goto out_fail;
1612
1613        if (page_has_buffers(page)) {
1614                if (!walk_page_buffers(NULL, page_buffers(page), 0,
1615                                      PAGE_CACHE_SIZE, NULL, buffer_unmapped)) {
1616                        /* Provide NULL get_block() to catch bugs if buffers
1617                         * weren't really mapped */
1618                        return block_write_full_page(page, NULL, wbc);
1619                }
1620        }
1621
1622        handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1623        if (IS_ERR(handle)) {
1624                ret = PTR_ERR(handle);
1625                goto out_fail;
1626        }
1627
1628        if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
1629                ret = nobh_writepage(page, ext3_get_block, wbc);
1630        else
1631                ret = block_write_full_page(page, ext3_get_block, wbc);
1632
1633        err = ext3_journal_stop(handle);
1634        if (!ret)
1635                ret = err;
1636        return ret;
1637
1638out_fail:
1639        redirty_page_for_writepage(wbc, page);
1640        unlock_page(page);
1641        return ret;
1642}
1643
1644static int ext3_journalled_writepage(struct page *page,
1645                                struct writeback_control *wbc)
1646{
1647        struct inode *inode = page->mapping->host;
1648        handle_t *handle = NULL;
1649        int ret = 0;
1650        int err;
1651
1652        J_ASSERT(PageLocked(page));
1653        WARN_ON_ONCE(IS_RDONLY(inode));
1654
1655        if (ext3_journal_current_handle())
1656                goto no_write;
1657
1658        handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1659        if (IS_ERR(handle)) {
1660                ret = PTR_ERR(handle);
1661                goto no_write;
1662        }
1663
1664        if (!page_has_buffers(page) || PageChecked(page)) {
1665                /*
1666                 * It's mmapped pagecache.  Add buffers and journal it.  There
1667                 * doesn't seem much point in redirtying the page here.
1668                 */
1669                ClearPageChecked(page);
1670                ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
1671                                        ext3_get_block);
1672                if (ret != 0) {
1673                        ext3_journal_stop(handle);
1674                        goto out_unlock;
1675                }
1676                ret = walk_page_buffers(handle, page_buffers(page), 0,
1677                        PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
1678
1679                err = walk_page_buffers(handle, page_buffers(page), 0,
1680                                PAGE_CACHE_SIZE, NULL, write_end_fn);
1681                if (ret == 0)
1682                        ret = err;
1683                ext3_set_inode_state(inode, EXT3_STATE_JDATA);
1684                unlock_page(page);
1685        } else {
1686                /*
1687                 * It may be a page full of checkpoint-mode buffers.  We don't
1688                 * really know unless we go poke around in the buffer_heads.
1689                 * But block_write_full_page will do the right thing.
1690                 */
1691                ret = block_write_full_page(page, ext3_get_block, wbc);
1692        }
1693        err = ext3_journal_stop(handle);
1694        if (!ret)
1695                ret = err;
1696out:
1697        return ret;
1698
1699no_write:
1700        redirty_page_for_writepage(wbc, page);
1701out_unlock:
1702        unlock_page(page);
1703        goto out;
1704}
1705
1706static int ext3_readpage(struct file *file, struct page *page)
1707{
1708        return mpage_readpage(page, ext3_get_block);
1709}
1710
1711static int
1712ext3_readpages(struct file *file, struct address_space *mapping,
1713                struct list_head *pages, unsigned nr_pages)
1714{
1715        return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
1716}
1717
1718static void ext3_invalidatepage(struct page *page, unsigned long offset)
1719{
1720        journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1721
1722        /*
1723         * If it's a full truncate we just forget about the pending dirtying
1724         */
1725        if (offset == 0)
1726                ClearPageChecked(page);
1727
1728        journal_invalidatepage(journal, page, offset);
1729}
1730
1731static int ext3_releasepage(struct page *page, gfp_t wait)
1732{
1733        journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1734
1735        WARN_ON(PageChecked(page));
1736        if (!page_has_buffers(page))
1737                return 0;
1738        return journal_try_to_free_buffers(journal, page, wait);
1739}
1740
1741/*
1742 * If the O_DIRECT write will extend the file then add this inode to the
1743 * orphan list.  So recovery will truncate it back to the original size
1744 * if the machine crashes during the write.
1745 *
1746 * If the O_DIRECT write is intantiating holes inside i_size and the machine
1747 * crashes then stale disk data _may_ be exposed inside the file. But current
1748 * VFS code falls back into buffered path in that case so we are safe.
1749 */
1750static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1751                        const struct iovec *iov, loff_t offset,
1752                        unsigned long nr_segs)
1753{
1754        struct file *file = iocb->ki_filp;
1755        struct inode *inode = file->f_mapping->host;
1756        struct ext3_inode_info *ei = EXT3_I(inode);
1757        handle_t *handle;
1758        ssize_t ret;
1759        int orphan = 0;
1760        size_t count = iov_length(iov, nr_segs);
1761        int retries = 0;
1762
1763        if (rw == WRITE) {
1764                loff_t final_size = offset + count;
1765
1766                if (final_size > inode->i_size) {
1767                        /* Credits for sb + inode write */
1768                        handle = ext3_journal_start(inode, 2);
1769                        if (IS_ERR(handle)) {
1770                                ret = PTR_ERR(handle);
1771                                goto out;
1772                        }
1773                        ret = ext3_orphan_add(handle, inode);
1774                        if (ret) {
1775                                ext3_journal_stop(handle);
1776                                goto out;
1777                        }
1778                        orphan = 1;
1779                        ei->i_disksize = inode->i_size;
1780                        ext3_journal_stop(handle);
1781                }
1782        }
1783
1784retry:
1785        ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1786                                 offset, nr_segs,
1787                                 ext3_get_block, NULL);
1788        if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1789                goto retry;
1790
1791        if (orphan) {
1792                int err;
1793
1794                /* Credits for sb + inode write */
1795                handle = ext3_journal_start(inode, 2);
1796                if (IS_ERR(handle)) {
1797                        /* This is really bad luck. We've written the data
1798                         * but cannot extend i_size. Truncate allocated blocks
1799                         * and pretend the write failed... */
1800                        ext3_truncate(inode);
1801                        ret = PTR_ERR(handle);
1802                        goto out;
1803                }
1804                if (inode->i_nlink)
1805                        ext3_orphan_del(handle, inode);
1806                if (ret > 0) {
1807                        loff_t end = offset + ret;
1808                        if (end > inode->i_size) {
1809                                ei->i_disksize = end;
1810                                i_size_write(inode, end);
1811                                /*
1812                                 * We're going to return a positive `ret'
1813                                 * here due to non-zero-length I/O, so there's
1814                                 * no way of reporting error returns from
1815                                 * ext3_mark_inode_dirty() to userspace.  So
1816                                 * ignore it.
1817                                 */
1818                                ext3_mark_inode_dirty(handle, inode);
1819                        }
1820                }
1821                err = ext3_journal_stop(handle);
1822                if (ret == 0)
1823                        ret = err;
1824        }
1825out:
1826        return ret;
1827}
1828
1829/*
1830 * Pages can be marked dirty completely asynchronously from ext3's journalling
1831 * activity.  By filemap_sync_pte(), try_to_unmap_one(), etc.  We cannot do
1832 * much here because ->set_page_dirty is called under VFS locks.  The page is
1833 * not necessarily locked.
1834 *
1835 * We cannot just dirty the page and leave attached buffers clean, because the
1836 * buffers' dirty state is "definitive".  We cannot just set the buffers dirty
1837 * or jbddirty because all the journalling code will explode.
1838 *
1839 * So what we do is to mark the page "pending dirty" and next time writepage
1840 * is called, propagate that into the buffers appropriately.
1841 */
1842static int ext3_journalled_set_page_dirty(struct page *page)
1843{
1844        SetPageChecked(page);
1845        return __set_page_dirty_nobuffers(page);
1846}
1847
1848static const struct address_space_operations ext3_ordered_aops = {
1849        .readpage               = ext3_readpage,
1850        .readpages              = ext3_readpages,
1851        .writepage              = ext3_ordered_writepage,
1852        .sync_page              = block_sync_page,
1853        .write_begin            = ext3_write_begin,
1854        .write_end              = ext3_ordered_write_end,
1855        .bmap                   = ext3_bmap,
1856        .invalidatepage         = ext3_invalidatepage,
1857        .releasepage            = ext3_releasepage,
1858        .direct_IO              = ext3_direct_IO,
1859        .migratepage            = buffer_migrate_page,
1860        .is_partially_uptodate  = block_is_partially_uptodate,
1861        .error_remove_page      = generic_error_remove_page,
1862};
1863
1864static const struct address_space_operations ext3_writeback_aops = {
1865        .readpage               = ext3_readpage,
1866        .readpages              = ext3_readpages,
1867        .writepage              = ext3_writeback_writepage,
1868        .sync_page              = block_sync_page,
1869        .write_begin            = ext3_write_begin,
1870        .write_end              = ext3_writeback_write_end,
1871        .bmap                   = ext3_bmap,
1872        .invalidatepage         = ext3_invalidatepage,
1873        .releasepage            = ext3_releasepage,
1874        .direct_IO              = ext3_direct_IO,
1875        .migratepage            = buffer_migrate_page,
1876        .is_partially_uptodate  = block_is_partially_uptodate,
1877        .error_remove_page      = generic_error_remove_page,
1878};
1879
1880static const struct address_space_operations ext3_journalled_aops = {
1881        .readpage               = ext3_readpage,
1882        .readpages              = ext3_readpages,
1883        .writepage              = ext3_journalled_writepage,
1884        .sync_page              = block_sync_page,
1885        .write_begin            = ext3_write_begin,
1886        .write_end              = ext3_journalled_write_end,
1887        .set_page_dirty         = ext3_journalled_set_page_dirty,
1888        .bmap                   = ext3_bmap,
1889        .invalidatepage         = ext3_invalidatepage,
1890        .releasepage            = ext3_releasepage,
1891        .is_partially_uptodate  = block_is_partially_uptodate,
1892        .error_remove_page      = generic_error_remove_page,
1893};
1894
1895void ext3_set_aops(struct inode *inode)
1896{
1897        if (ext3_should_order_data(inode))
1898                inode->i_mapping->a_ops = &ext3_ordered_aops;
1899        else if (ext3_should_writeback_data(inode))
1900                inode->i_mapping->a_ops = &ext3_writeback_aops;
1901        else
1902                inode->i_mapping->a_ops = &ext3_journalled_aops;
1903}
1904
1905/*
1906 * ext3_block_truncate_page() zeroes out a mapping from file offset `from'
1907 * up to the end of the block which corresponds to `from'.
1908 * This required during truncate. We need to physically zero the tail end
1909 * of that block so it doesn't yield old data if the file is later grown.
1910 */
1911static int ext3_block_truncate_page(handle_t *handle, struct page *page,
1912                struct address_space *mapping, loff_t from)
1913{
1914        ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
1915        unsigned offset = from & (PAGE_CACHE_SIZE-1);
1916        unsigned blocksize, iblock, length, pos;
1917        struct inode *inode = mapping->host;
1918        struct buffer_head *bh;
1919        int err = 0;
1920
1921        blocksize = inode->i_sb->s_blocksize;
1922        length = blocksize - (offset & (blocksize - 1));
1923        iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1924
1925        /*
1926         * For "nobh" option,  we can only work if we don't need to
1927         * read-in the page - otherwise we create buffers to do the IO.
1928         */
1929        if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
1930             ext3_should_writeback_data(inode) && PageUptodate(page)) {
1931                zero_user(page, offset, length);
1932                set_page_dirty(page);
1933                goto unlock;
1934        }
1935
1936        if (!page_has_buffers(page))
1937                create_empty_buffers(page, blocksize, 0);
1938
1939        /* Find the buffer that contains "offset" */
1940        bh = page_buffers(page);
1941        pos = blocksize;
1942        while (offset >= pos) {
1943                bh = bh->b_this_page;
1944                iblock++;
1945                pos += blocksize;
1946        }
1947
1948        err = 0;
1949        if (buffer_freed(bh)) {
1950                BUFFER_TRACE(bh, "freed: skip");
1951                goto unlock;
1952        }
1953
1954        if (!buffer_mapped(bh)) {
1955                BUFFER_TRACE(bh, "unmapped");
1956                ext3_get_block(inode, iblock, bh, 0);
1957                /* unmapped? It's a hole - nothing to do */
1958                if (!buffer_mapped(bh)) {
1959                        BUFFER_TRACE(bh, "still unmapped");
1960                        goto unlock;
1961                }
1962        }
1963
1964        /* Ok, it's mapped. Make sure it's up-to-date */
1965        if (PageUptodate(page))
1966                set_buffer_uptodate(bh);
1967
1968        if (!buffer_uptodate(bh)) {
1969                err = -EIO;
1970                ll_rw_block(READ, 1, &bh);
1971                wait_on_buffer(bh);
1972                /* Uhhuh. Read error. Complain and punt. */
1973                if (!buffer_uptodate(bh))
1974                        goto unlock;
1975        }
1976
1977        if (ext3_should_journal_data(inode)) {
1978                BUFFER_TRACE(bh, "get write access");
1979                err = ext3_journal_get_write_access(handle, bh);
1980                if (err)
1981                        goto unlock;
1982        }
1983
1984        zero_user(page, offset, length);
1985        BUFFER_TRACE(bh, "zeroed end of block");
1986
1987        err = 0;
1988        if (ext3_should_journal_data(inode)) {
1989                err = ext3_journal_dirty_metadata(handle, bh);
1990        } else {
1991                if (ext3_should_order_data(inode))
1992                        err = ext3_journal_dirty_data(handle, bh);
1993                mark_buffer_dirty(bh);
1994        }
1995
1996unlock:
1997        unlock_page(page);
1998        page_cache_release(page);
1999        return err;
2000}
2001
2002/*
2003 * Probably it should be a library function... search for first non-zero word
2004 * or memcmp with zero_page, whatever is better for particular architecture.
2005 * Linus?
2006 */
2007static inline int all_zeroes(__le32 *p, __le32 *q)
2008{
2009        while (p < q)
2010                if (*p++)
2011                        return 0;
2012        return 1;
2013}
2014
2015/**
2016 *      ext3_find_shared - find the indirect blocks for partial truncation.
2017 *      @inode:   inode in question
2018 *      @depth:   depth of the affected branch
2019 *      @offsets: offsets of pointers in that branch (see ext3_block_to_path)
2020 *      @chain:   place to store the pointers to partial indirect blocks
2021 *      @top:     place to the (detached) top of branch
2022 *
2023 *      This is a helper function used by ext3_truncate().
2024 *
2025 *      When we do truncate() we may have to clean the ends of several
2026 *      indirect blocks but leave the blocks themselves alive. Block is
2027 *      partially truncated if some data below the new i_size is refered
2028 *      from it (and it is on the path to the first completely truncated
2029 *      data block, indeed).  We have to free the top of that path along
2030 *      with everything to the right of the path. Since no allocation
2031 *      past the truncation point is possible until ext3_truncate()
2032 *      finishes, we may safely do the latter, but top of branch may
2033 *      require special attention - pageout below the truncation point
2034 *      might try to populate it.
2035 *
2036 *      We atomically detach the top of branch from the tree, store the
2037 *      block number of its root in *@top, pointers to buffer_heads of
2038 *      partially truncated blocks - in @chain[].bh and pointers to
2039 *      their last elements that should not be removed - in
2040 *      @chain[].p. Return value is the pointer to last filled element
2041 *      of @chain.
2042 *
2043 *      The work left to caller to do the actual freeing of subtrees:
2044 *              a) free the subtree starting from *@top
2045 *              b) free the subtrees whose roots are stored in
2046 *                      (@chain[i].p+1 .. end of @chain[i].bh->b_data)
2047 *              c) free the subtrees growing from the inode past the @chain[0].
2048 *                      (no partially truncated stuff there).  */
2049
2050static Indirect *ext3_find_shared(struct inode *inode, int depth,
2051                        int offsets[4], Indirect chain[4], __le32 *top)
2052{
2053        Indirect *partial, *p;
2054        int k, err;
2055
2056        *top = 0;
2057        /* Make k index the deepest non-null offset + 1 */
2058        for (k = depth; k > 1 && !offsets[k-1]; k--)
2059                ;
2060        partial = ext3_get_branch(inode, k, offsets, chain, &err);
2061        /* Writer: pointers */
2062        if (!partial)
2063                partial = chain + k-1;
2064        /*
2065         * If the branch acquired continuation since we've looked at it -
2066         * fine, it should all survive and (new) top doesn't belong to us.
2067         */
2068        if (!partial->key && *partial->p)
2069                /* Writer: end */
2070                goto no_top;
2071        for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
2072                ;
2073        /*
2074         * OK, we've found the last block that must survive. The rest of our
2075         * branch should be detached before unlocking. However, if that rest
2076         * of branch is all ours and does not grow immediately from the inode
2077         * it's easier to cheat and just decrement partial->p.
2078         */
2079        if (p == chain + k - 1 && p > chain) {
2080                p->p--;
2081        } else {
2082                *top = *p->p;
2083                /* Nope, don't do this in ext3.  Must leave the tree intact */
2084#if 0
2085                *p->p = 0;
2086#endif
2087        }
2088        /* Writer: end */
2089
2090        while(partial > p) {
2091                brelse(partial->bh);
2092                partial--;
2093        }
2094no_top:
2095        return partial;
2096}
2097
2098/*
2099 * Zero a number of block pointers in either an inode or an indirect block.
2100 * If we restart the transaction we must again get write access to the
2101 * indirect block for further modification.
2102 *
2103 * We release `count' blocks on disk, but (last - first) may be greater
2104 * than `count' because there can be holes in there.
2105 */
2106static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
2107                struct buffer_head *bh, ext3_fsblk_t block_to_free,
2108                unsigned long count, __le32 *first, __le32 *last)
2109{
2110        __le32 *p;
2111        if (try_to_extend_transaction(handle, inode)) {
2112                if (bh) {
2113                        BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2114                        ext3_journal_dirty_metadata(handle, bh);
2115                }
2116                ext3_mark_inode_dirty(handle, inode);
2117                truncate_restart_transaction(handle, inode);
2118                if (bh) {
2119                        BUFFER_TRACE(bh, "retaking write access");
2120                        ext3_journal_get_write_access(handle, bh);
2121                }
2122        }
2123
2124        /*
2125         * Any buffers which are on the journal will be in memory. We find
2126         * them on the hash table so journal_revoke() will run journal_forget()
2127         * on them.  We've already detached each block from the file, so
2128         * bforget() in journal_forget() should be safe.
2129         *
2130         * AKPM: turn on bforget in journal_forget()!!!
2131         */
2132        for (p = first; p < last; p++) {
2133                u32 nr = le32_to_cpu(*p);
2134                if (nr) {
2135                        struct buffer_head *bh;
2136
2137                        *p = 0;
2138                        bh = sb_find_get_block(inode->i_sb, nr);
2139                        ext3_forget(handle, 0, inode, bh, nr);
2140                }
2141        }
2142
2143        ext3_free_blocks(handle, inode, block_to_free, count);
2144}
2145
2146/**
2147 * ext3_free_data - free a list of data blocks
2148 * @handle:     handle for this transaction
2149 * @inode:      inode we are dealing with
2150 * @this_bh:    indirect buffer_head which contains *@first and *@last
2151 * @first:      array of block numbers
2152 * @last:       points immediately past the end of array
2153 *
2154 * We are freeing all blocks refered from that array (numbers are stored as
2155 * little-endian 32-bit) and updating @inode->i_blocks appropriately.
2156 *
2157 * We accumulate contiguous runs of blocks to free.  Conveniently, if these
2158 * blocks are contiguous then releasing them at one time will only affect one
2159 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
2160 * actually use a lot of journal space.
2161 *
2162 * @this_bh will be %NULL if @first and @last point into the inode's direct
2163 * block pointers.
2164 */
2165static void ext3_free_data(handle_t *handle, struct inode *inode,
2166                           struct buffer_head *this_bh,
2167                           __le32 *first, __le32 *last)
2168{
2169        ext3_fsblk_t block_to_free = 0;    /* Starting block # of a run */
2170        unsigned long count = 0;            /* Number of blocks in the run */
2171        __le32 *block_to_free_p = NULL;     /* Pointer into inode/ind
2172                                               corresponding to
2173                                               block_to_free */
2174        ext3_fsblk_t nr;                    /* Current block # */
2175        __le32 *p;                          /* Pointer into inode/ind
2176                                               for current block */
2177        int err;
2178
2179        if (this_bh) {                          /* For indirect block */
2180                BUFFER_TRACE(this_bh, "get_write_access");
2181                err = ext3_journal_get_write_access(handle, this_bh);
2182                /* Important: if we can't update the indirect pointers
2183                 * to the blocks, we can't free them. */
2184                if (err)
2185                        return;
2186        }
2187
2188        for (p = first; p < last; p++) {
2189                nr = le32_to_cpu(*p);
2190                if (nr) {
2191                        /* accumulate blocks to free if they're contiguous */
2192                        if (count == 0) {
2193                                block_to_free = nr;
2194                                block_to_free_p = p;
2195                                count = 1;
2196                        } else if (nr == block_to_free + count) {
2197                                count++;
2198                        } else {
2199                                ext3_clear_blocks(handle, inode, this_bh,
2200                                                  block_to_free,
2201                                                  count, block_to_free_p, p);
2202                                block_to_free = nr;
2203                                block_to_free_p = p;
2204                                count = 1;
2205                        }
2206                }
2207        }
2208
2209        if (count > 0)
2210                ext3_clear_blocks(handle, inode, this_bh, block_to_free,
2211                                  count, block_to_free_p, p);
2212
2213        if (this_bh) {
2214                BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
2215
2216                /*
2217                 * The buffer head should have an attached journal head at this
2218                 * point. However, if the data is corrupted and an indirect
2219                 * block pointed to itself, it would have been detached when
2220                 * the block was cleared. Check for this instead of OOPSing.
2221                 */
2222                if (bh2jh(this_bh))
2223                        ext3_journal_dirty_metadata(handle, this_bh);
2224                else
2225                        ext3_error(inode->i_sb, "ext3_free_data",
2226                                   "circular indirect block detected, "
2227                                   "inode=%lu, block=%llu",
2228                                   inode->i_ino,
2229                                   (unsigned long long)this_bh->b_blocknr);
2230        }
2231}
2232
2233/**
2234 *      ext3_free_branches - free an array of branches
2235 *      @handle: JBD handle for this transaction
2236 *      @inode: inode we are dealing with
2237 *      @parent_bh: the buffer_head which contains *@first and *@last
2238 *      @first: array of block numbers
2239 *      @last:  pointer immediately past the end of array
2240 *      @depth: depth of the branches to free
2241 *
2242 *      We are freeing all blocks refered from these branches (numbers are
2243 *      stored as little-endian 32-bit) and updating @inode->i_blocks
2244 *      appropriately.
2245 */
2246static void ext3_free_branches(handle_t *handle, struct inode *inode,
2247                               struct buffer_head *parent_bh,
2248                               __le32 *first, __le32 *last, int depth)
2249{
2250        ext3_fsblk_t nr;
2251        __le32 *p;
2252
2253        if (is_handle_aborted(handle))
2254                return;
2255
2256        if (depth--) {
2257                struct buffer_head *bh;
2258                int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2259                p = last;
2260                while (--p >= first) {
2261                        nr = le32_to_cpu(*p);
2262                        if (!nr)
2263                                continue;               /* A hole */
2264
2265                        /* Go read the buffer for the next level down */
2266                        bh = sb_bread(inode->i_sb, nr);
2267
2268                        /*
2269                         * A read failure? Report error and clear slot
2270                         * (should be rare).
2271                         */
2272                        if (!bh) {
2273                                ext3_error(inode->i_sb, "ext3_free_branches",
2274                                           "Read failure, inode=%lu, block="E3FSBLK,
2275                                           inode->i_ino, nr);
2276                                continue;
2277                        }
2278
2279                        /* This zaps the entire block.  Bottom up. */
2280                        BUFFER_TRACE(bh, "free child branches");
2281                        ext3_free_branches(handle, inode, bh,
2282                                           (__le32*)bh->b_data,
2283                                           (__le32*)bh->b_data + addr_per_block,
2284                                           depth);
2285
2286                        /*
2287                         * We've probably journalled the indirect block several
2288                         * times during the truncate.  But it's no longer
2289                         * needed and we now drop it from the transaction via
2290                         * journal_revoke().
2291                         *
2292                         * That's easy if it's exclusively part of this
2293                         * transaction.  But if it's part of the committing
2294                         * transaction then journal_forget() will simply
2295                         * brelse() it.  That means that if the underlying
2296                         * block is reallocated in ext3_get_block(),
2297                         * unmap_underlying_metadata() will find this block
2298                         * and will try to get rid of it.  damn, damn.
2299                         *
2300                         * If this block has already been committed to the
2301                         * journal, a revoke record will be written.  And
2302                         * revoke records must be emitted *before* clearing
2303                         * this block's bit in the bitmaps.
2304                         */
2305                        ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2306
2307                        /*
2308                         * Everything below this this pointer has been
2309                         * released.  Now let this top-of-subtree go.
2310                         *
2311                         * We want the freeing of this indirect block to be
2312                         * atomic in the journal with the updating of the
2313                         * bitmap block which owns it.  So make some room in
2314                         * the journal.
2315                         *
2316                         * We zero the parent pointer *after* freeing its
2317                         * pointee in the bitmaps, so if extend_transaction()
2318                         * for some reason fails to put the bitmap changes and
2319                         * the release into the same transaction, recovery
2320                         * will merely complain about releasing a free block,
2321                         * rather than leaking blocks.
2322                         */
2323                        if (is_handle_aborted(handle))
2324                                return;
2325                        if (try_to_extend_transaction(handle, inode)) {
2326                                ext3_mark_inode_dirty(handle, inode);
2327                                truncate_restart_transaction(handle, inode);
2328                        }
2329
2330                        ext3_free_blocks(handle, inode, nr, 1);
2331
2332                        if (parent_bh) {
2333                                /*
2334                                 * The block which we have just freed is
2335                                 * pointed to by an indirect block: journal it
2336                                 */
2337                                BUFFER_TRACE(parent_bh, "get_write_access");
2338                                if (!ext3_journal_get_write_access(handle,
2339                                                                   parent_bh)){
2340                                        *p = 0;
2341                                        BUFFER_TRACE(parent_bh,
2342                                        "call ext3_journal_dirty_metadata");
2343                                        ext3_journal_dirty_metadata(handle,
2344                                                                    parent_bh);
2345                                }
2346                        }
2347                }
2348        } else {
2349                /* We have reached the bottom of the tree. */
2350                BUFFER_TRACE(parent_bh, "free data blocks");
2351                ext3_free_data(handle, inode, parent_bh, first, last);
2352        }
2353}
2354
2355int ext3_can_truncate(struct inode *inode)
2356{
2357        if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2358                return 0;
2359        if (S_ISREG(inode->i_mode))
2360                return 1;
2361        if (S_ISDIR(inode->i_mode))
2362                return 1;
2363        if (S_ISLNK(inode->i_mode))
2364                return !ext3_inode_is_fast_symlink(inode);
2365        return 0;
2366}
2367
2368/*
2369 * ext3_truncate()
2370 *
2371 * We block out ext3_get_block() block instantiations across the entire
2372 * transaction, and VFS/VM ensures that ext3_truncate() cannot run
2373 * simultaneously on behalf of the same inode.
2374 *
2375 * As we work through the truncate and commmit bits of it to the journal there
2376 * is one core, guiding principle: the file's tree must always be consistent on
2377 * disk.  We must be able to restart the truncate after a crash.
2378 *
2379 * The file's tree may be transiently inconsistent in memory (although it
2380 * probably isn't), but whenever we close off and commit a journal transaction,
2381 * the contents of (the filesystem + the journal) must be consistent and
2382 * restartable.  It's pretty simple, really: bottom up, right to left (although
2383 * left-to-right works OK too).
2384 *
2385 * Note that at recovery time, journal replay occurs *before* the restart of
2386 * truncate against the orphan inode list.
2387 *
2388 * The committed inode has the new, desired i_size (which is the same as
2389 * i_disksize in this case).  After a crash, ext3_orphan_cleanup() will see
2390 * that this inode's truncate did not complete and it will again call
2391 * ext3_truncate() to have another go.  So there will be instantiated blocks
2392 * to the right of the truncation point in a crashed ext3 filesystem.  But
2393 * that's fine - as long as they are linked from the inode, the post-crash
2394 * ext3_truncate() run will find them and release them.
2395 */
2396void ext3_truncate(struct inode *inode)
2397{
2398        handle_t *handle;
2399        struct ext3_inode_info *ei = EXT3_I(inode);
2400        __le32 *i_data = ei->i_data;
2401        int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2402        struct address_space *mapping = inode->i_mapping;
2403        int offsets[4];
2404        Indirect chain[4];
2405        Indirect *partial;
2406        __le32 nr = 0;
2407        int n;
2408        long last_block;
2409        unsigned blocksize = inode->i_sb->s_blocksize;
2410        struct page *page;
2411
2412        if (!ext3_can_truncate(inode))
2413                goto out_notrans;
2414
2415        if (inode->i_size == 0 && ext3_should_writeback_data(inode))
2416                ext3_set_inode_state(inode, EXT3_STATE_FLUSH_ON_CLOSE);
2417
2418        /*
2419         * We have to lock the EOF page here, because lock_page() nests
2420         * outside journal_start().
2421         */
2422        if ((inode->i_size & (blocksize - 1)) == 0) {
2423                /* Block boundary? Nothing to do */
2424                page = NULL;
2425        } else {
2426                page = grab_cache_page(mapping,
2427                                inode->i_size >> PAGE_CACHE_SHIFT);
2428                if (!page)
2429                        goto out_notrans;
2430        }
2431
2432        handle = start_transaction(inode);
2433        if (IS_ERR(handle)) {
2434                if (page) {
2435                        clear_highpage(page);
2436                        flush_dcache_page(page);
2437                        unlock_page(page);
2438                        page_cache_release(page);
2439                }
2440                goto out_notrans;
2441        }
2442
2443        last_block = (inode->i_size + blocksize-1)
2444                                        >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2445
2446        if (page)
2447                ext3_block_truncate_page(handle, page, mapping, inode->i_size);
2448
2449        n = ext3_block_to_path(inode, last_block, offsets, NULL);
2450        if (n == 0)
2451                goto out_stop;  /* error */
2452
2453        /*
2454         * OK.  This truncate is going to happen.  We add the inode to the
2455         * orphan list, so that if this truncate spans multiple transactions,
2456         * and we crash, we will resume the truncate when the filesystem
2457         * recovers.  It also marks the inode dirty, to catch the new size.
2458         *
2459         * Implication: the file must always be in a sane, consistent
2460         * truncatable state while each transaction commits.
2461         */
2462        if (ext3_orphan_add(handle, inode))
2463                goto out_stop;
2464
2465        /*
2466         * The orphan list entry will now protect us from any crash which
2467         * occurs before the truncate completes, so it is now safe to propagate
2468         * the new, shorter inode size (held for now in i_size) into the
2469         * on-disk inode. We do this via i_disksize, which is the value which
2470         * ext3 *really* writes onto the disk inode.
2471         */
2472        ei->i_disksize = inode->i_size;
2473
2474        /*
2475         * From here we block out all ext3_get_block() callers who want to
2476         * modify the block allocation tree.
2477         */
2478        mutex_lock(&ei->truncate_mutex);
2479
2480        if (n == 1) {           /* direct blocks */
2481                ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2482                               i_data + EXT3_NDIR_BLOCKS);
2483                goto do_indirects;
2484        }
2485
2486        partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2487        /* Kill the top of shared branch (not detached) */
2488        if (nr) {
2489                if (partial == chain) {
2490                        /* Shared branch grows from the inode */
2491                        ext3_free_branches(handle, inode, NULL,
2492                                           &nr, &nr+1, (chain+n-1) - partial);
2493                        *partial->p = 0;
2494                        /*
2495                         * We mark the inode dirty prior to restart,
2496                         * and prior to stop.  No need for it here.
2497                         */
2498                } else {
2499                        /* Shared branch grows from an indirect block */
2500                        BUFFER_TRACE(partial->bh, "get_write_access");
2501                        ext3_free_branches(handle, inode, partial->bh,
2502                                        partial->p,
2503                                        partial->p+1, (chain+n-1) - partial);
2504                }
2505        }
2506        /* Clear the ends of indirect blocks on the shared branch */
2507        while (partial > chain) {
2508                ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2509                                   (__le32*)partial->bh->b_data+addr_per_block,
2510                                   (chain+n-1) - partial);
2511                BUFFER_TRACE(partial->bh, "call brelse");
2512                brelse (partial->bh);
2513                partial--;
2514        }
2515do_indirects:
2516        /* Kill the remaining (whole) subtrees */
2517        switch (offsets[0]) {
2518        default:
2519                nr = i_data[EXT3_IND_BLOCK];
2520                if (nr) {
2521                        ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
2522                        i_data[EXT3_IND_BLOCK] = 0;
2523                }
2524        case EXT3_IND_BLOCK:
2525                nr = i_data[EXT3_DIND_BLOCK];
2526                if (nr) {
2527                        ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
2528                        i_data[EXT3_DIND_BLOCK] = 0;
2529                }
2530        case EXT3_DIND_BLOCK:
2531                nr = i_data[EXT3_TIND_BLOCK];
2532                if (nr) {
2533                        ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
2534                        i_data[EXT3_TIND_BLOCK] = 0;
2535                }
2536        case EXT3_TIND_BLOCK:
2537                ;
2538        }
2539
2540        ext3_discard_reservation(inode);
2541
2542        mutex_unlock(&ei->truncate_mutex);
2543        inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
2544        ext3_mark_inode_dirty(handle, inode);
2545
2546        /*
2547         * In a multi-transaction truncate, we only make the final transaction
2548         * synchronous
2549         */
2550        if (IS_SYNC(inode))
2551                handle->h_sync = 1;
2552out_stop:
2553        /*
2554         * If this was a simple ftruncate(), and the file will remain alive
2555         * then we need to clear up the orphan record which we created above.
2556         * However, if this was a real unlink then we were called by
2557         * ext3_delete_inode(), and we allow that function to clean up the
2558         * orphan info for us.
2559         */
2560        if (inode->i_nlink)
2561                ext3_orphan_del(handle, inode);
2562
2563        ext3_journal_stop(handle);
2564        return;
2565out_notrans:
2566        /*
2567         * Delete the inode from orphan list so that it doesn't stay there
2568         * forever and trigger assertion on umount.
2569         */
2570        if (inode->i_nlink)
2571                ext3_orphan_del(NULL, inode);
2572}
2573
2574static ext3_fsblk_t ext3_get_inode_block(struct super_block *sb,
2575                unsigned long ino, struct ext3_iloc *iloc)
2576{
2577        unsigned long block_group;
2578        unsigned long offset;
2579        ext3_fsblk_t block;
2580        struct ext3_group_desc *gdp;
2581
2582        if (!ext3_valid_inum(sb, ino)) {
2583                /*
2584                 * This error is already checked for in namei.c unless we are
2585                 * looking at an NFS filehandle, in which case no error
2586                 * report is needed
2587                 */
2588                return 0;
2589        }
2590
2591        block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2592        gdp = ext3_get_group_desc(sb, block_group, NULL);
2593        if (!gdp)
2594                return 0;
2595        /*
2596         * Figure out the offset within the block group inode table
2597         */
2598        offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2599                EXT3_INODE_SIZE(sb);
2600        block = le32_to_cpu(gdp->bg_inode_table) +
2601                (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2602
2603        iloc->block_group = block_group;
2604        iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2605        return block;
2606}
2607
2608/*
2609 * ext3_get_inode_loc returns with an extra refcount against the inode's
2610 * underlying buffer_head on success. If 'in_mem' is true, we have all
2611 * data in memory that is needed to recreate the on-disk version of this
2612 * inode.
2613 */
2614static int __ext3_get_inode_loc(struct inode *inode,
2615                                struct ext3_iloc *iloc, int in_mem)
2616{
2617        ext3_fsblk_t block;
2618        struct buffer_head *bh;
2619
2620        block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2621        if (!block)
2622                return -EIO;
2623
2624        bh = sb_getblk(inode->i_sb, block);
2625        if (!bh) {
2626                ext3_error (inode->i_sb, "ext3_get_inode_loc",
2627                                "unable to read inode block - "
2628                                "inode=%lu, block="E3FSBLK,
2629                                 inode->i_ino, block);
2630                return -EIO;
2631        }
2632        if (!buffer_uptodate(bh)) {
2633                lock_buffer(bh);
2634
2635                /*
2636                 * If the buffer has the write error flag, we have failed
2637                 * to write out another inode in the same block.  In this
2638                 * case, we don't have to read the block because we may
2639                 * read the old inode data successfully.
2640                 */
2641                if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
2642                        set_buffer_uptodate(bh);
2643
2644                if (buffer_uptodate(bh)) {
2645                        /* someone brought it uptodate while we waited */
2646                        unlock_buffer(bh);
2647                        goto has_buffer;
2648                }
2649
2650                /*
2651                 * If we have all information of the inode in memory and this
2652                 * is the only valid inode in the block, we need not read the
2653                 * block.
2654                 */
2655                if (in_mem) {
2656                        struct buffer_head *bitmap_bh;
2657                        struct ext3_group_desc *desc;
2658                        int inodes_per_buffer;
2659                        int inode_offset, i;
2660                        int block_group;
2661                        int start;
2662
2663                        block_group = (inode->i_ino - 1) /
2664                                        EXT3_INODES_PER_GROUP(inode->i_sb);
2665                        inodes_per_buffer = bh->b_size /
2666                                EXT3_INODE_SIZE(inode->i_sb);
2667                        inode_offset = ((inode->i_ino - 1) %
2668                                        EXT3_INODES_PER_GROUP(inode->i_sb));
2669                        start = inode_offset & ~(inodes_per_buffer - 1);
2670
2671                        /* Is the inode bitmap in cache? */
2672                        desc = ext3_get_group_desc(inode->i_sb,
2673                                                block_group, NULL);
2674                        if (!desc)
2675                                goto make_io;
2676
2677                        bitmap_bh = sb_getblk(inode->i_sb,
2678                                        le32_to_cpu(desc->bg_inode_bitmap));
2679                        if (!bitmap_bh)
2680                                goto make_io;
2681
2682                        /*
2683                         * If the inode bitmap isn't in cache then the
2684                         * optimisation may end up performing two reads instead
2685                         * of one, so skip it.
2686                         */
2687                        if (!buffer_uptodate(bitmap_bh)) {
2688                                brelse(bitmap_bh);
2689                                goto make_io;
2690                        }
2691                        for (i = start; i < start + inodes_per_buffer; i++) {
2692                                if (i == inode_offset)
2693                                        continue;
2694                                if (ext3_test_bit(i, bitmap_bh->b_data))
2695                                        break;
2696                        }
2697                        brelse(bitmap_bh);
2698                        if (i == start + inodes_per_buffer) {
2699                                /* all other inodes are free, so skip I/O */
2700                                memset(bh->b_data, 0, bh->b_size);
2701                                set_buffer_uptodate(bh);
2702                                unlock_buffer(bh);
2703                                goto has_buffer;
2704                        }
2705                }
2706
2707make_io:
2708                /*
2709                 * There are other valid inodes in the buffer, this inode
2710                 * has in-inode xattrs, or we don't have this inode in memory.
2711                 * Read the block from disk.
2712                 */
2713                get_bh(bh);
2714                bh->b_end_io = end_buffer_read_sync;
2715                submit_bh(READ_META, bh);
2716                wait_on_buffer(bh);
2717                if (!buffer_uptodate(bh)) {
2718                        ext3_error(inode->i_sb, "ext3_get_inode_loc",
2719                                        "unable to read inode block - "
2720                                        "inode=%lu, block="E3FSBLK,
2721                                        inode->i_ino, block);
2722                        brelse(bh);
2723                        return -EIO;
2724                }
2725        }
2726has_buffer:
2727        iloc->bh = bh;
2728        return 0;
2729}
2730
2731int ext3_get_inode_loc(struct inode *inode, struct ext3_iloc *iloc)
2732{
2733        /* We have all inode data except xattrs in memory here. */
2734        return __ext3_get_inode_loc(inode, iloc,
2735                !ext3_test_inode_state(inode, EXT3_STATE_XATTR));
2736}
2737
2738void ext3_set_inode_flags(struct inode *inode)
2739{
2740        unsigned int flags = EXT3_I(inode)->i_flags;
2741
2742        inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
2743        if (flags & EXT3_SYNC_FL)
2744                inode->i_flags |= S_SYNC;
2745        if (flags & EXT3_APPEND_FL)
2746                inode->i_flags |= S_APPEND;
2747        if (flags & EXT3_IMMUTABLE_FL)
2748                inode->i_flags |= S_IMMUTABLE;
2749        if (flags & EXT3_NOATIME_FL)
2750                inode->i_flags |= S_NOATIME;
2751        if (flags & EXT3_DIRSYNC_FL)
2752                inode->i_flags |= S_DIRSYNC;
2753}
2754
2755/* Propagate flags from i_flags to EXT3_I(inode)->i_flags */
2756void ext3_get_inode_flags(struct ext3_inode_info *ei)
2757{
2758        unsigned int flags = ei->vfs_inode.i_flags;
2759
2760        ei->i_flags &= ~(EXT3_SYNC_FL|EXT3_APPEND_FL|
2761                        EXT3_IMMUTABLE_FL|EXT3_NOATIME_FL|EXT3_DIRSYNC_FL);
2762        if (flags & S_SYNC)
2763                ei->i_flags |= EXT3_SYNC_FL;
2764        if (flags & S_APPEND)
2765                ei->i_flags |= EXT3_APPEND_FL;
2766        if (flags & S_IMMUTABLE)
2767                ei->i_flags |= EXT3_IMMUTABLE_FL;
2768        if (flags & S_NOATIME)
2769                ei->i_flags |= EXT3_NOATIME_FL;
2770        if (flags & S_DIRSYNC)
2771                ei->i_flags |= EXT3_DIRSYNC_FL;
2772}
2773
2774struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
2775{
2776        struct ext3_iloc iloc;
2777        struct ext3_inode *raw_inode;
2778        struct ext3_inode_info *ei;
2779        struct buffer_head *bh;
2780        struct inode *inode;
2781        journal_t *journal = EXT3_SB(sb)->s_journal;
2782        transaction_t *transaction;
2783        long ret;
2784        int block;
2785
2786        inode = iget_locked(sb, ino);
2787        if (!inode)
2788                return ERR_PTR(-ENOMEM);
2789        if (!(inode->i_state & I_NEW))
2790                return inode;
2791
2792        ei = EXT3_I(inode);
2793        ei->i_block_alloc_info = NULL;
2794
2795        ret = __ext3_get_inode_loc(inode, &iloc, 0);
2796        if (ret < 0)
2797                goto bad_inode;
2798        bh = iloc.bh;
2799        raw_inode = ext3_raw_inode(&iloc);
2800        inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2801        inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2802        inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2803        if(!(test_opt (inode->i_sb, NO_UID32))) {
2804                inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2805                inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2806        }
2807        inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
2808        inode->i_size = le32_to_cpu(raw_inode->i_size);
2809        inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
2810        inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
2811        inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
2812        inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2813
2814        ei->i_state_flags = 0;
2815        ei->i_dir_start_lookup = 0;
2816        ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2817        /* We now have enough fields to check if the inode was active or not.
2818         * This is needed because nfsd might try to access dead inodes
2819         * the test is that same one that e2fsck uses
2820         * NeilBrown 1999oct15
2821         */
2822        if (inode->i_nlink == 0) {
2823                if (inode->i_mode == 0 ||
2824                    !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2825                        /* this inode is deleted */
2826                        brelse (bh);
2827                        ret = -ESTALE;
2828                        goto bad_inode;
2829                }
2830                /* The only unlinked inodes we let through here have
2831                 * valid i_mode and are being read by the orphan
2832                 * recovery code: that's fine, we're about to complete
2833                 * the process of deleting those. */
2834        }
2835        inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2836        ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2837#ifdef EXT3_FRAGMENTS
2838        ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2839        ei->i_frag_no = raw_inode->i_frag;
2840        ei->i_frag_size = raw_inode->i_fsize;
2841#endif
2842        ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2843        if (!S_ISREG(inode->i_mode)) {
2844                ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2845        } else {
2846                inode->i_size |=
2847                        ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2848        }
2849        ei->i_disksize = inode->i_size;
2850        inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2851        ei->i_block_group = iloc.block_group;
2852        /*
2853         * NOTE! The in-memory inode i_data array is in little-endian order
2854         * even on big-endian machines: we do NOT byteswap the block numbers!
2855         */
2856        for (block = 0; block < EXT3_N_BLOCKS; block++)
2857                ei->i_data[block] = raw_inode->i_block[block];
2858        INIT_LIST_HEAD(&ei->i_orphan);
2859
2860        /*
2861         * Set transaction id's of transactions that have to be committed
2862         * to finish f[data]sync. We set them to currently running transaction
2863         * as we cannot be sure that the inode or some of its metadata isn't
2864         * part of the transaction - the inode could have been reclaimed and
2865         * now it is reread from disk.
2866         */
2867        if (journal) {
2868                tid_t tid;
2869
2870                spin_lock(&journal->j_state_lock);
2871                if (journal->j_running_transaction)
2872                        transaction = journal->j_running_transaction;
2873                else
2874                        transaction = journal->j_committing_transaction;
2875                if (transaction)
2876                        tid = transaction->t_tid;
2877                else
2878                        tid = journal->j_commit_sequence;
2879                spin_unlock(&journal->j_state_lock);
2880                atomic_set(&ei->i_sync_tid, tid);
2881                atomic_set(&ei->i_datasync_tid, tid);
2882        }
2883
2884        if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 &&
2885            EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
2886                /*
2887                 * When mke2fs creates big inodes it does not zero out
2888                 * the unused bytes above EXT3_GOOD_OLD_INODE_SIZE,
2889                 * so ignore those first few inodes.
2890                 */
2891                ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
2892                if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
2893                    EXT3_INODE_SIZE(inode->i_sb)) {
2894                        brelse (bh);
2895                        ret = -EIO;
2896                        goto bad_inode;
2897                }
2898                if (ei->i_extra_isize == 0) {
2899                        /* The extra space is currently unused. Use it. */
2900                        ei->i_extra_isize = sizeof(struct ext3_inode) -
2901                                            EXT3_GOOD_OLD_INODE_SIZE;
2902                } else {
2903                        __le32 *magic = (void *)raw_inode +
2904                                        EXT3_GOOD_OLD_INODE_SIZE +
2905                                        ei->i_extra_isize;
2906                        if (*magic == cpu_to_le32(EXT3_XATTR_MAGIC))
2907                                 ext3_set_inode_state(inode, EXT3_STATE_XATTR);
2908                }
2909        } else
2910                ei->i_extra_isize = 0;
2911
2912        if (S_ISREG(inode->i_mode)) {
2913                inode->i_op = &ext3_file_inode_operations;
2914                inode->i_fop = &ext3_file_operations;
2915                ext3_set_aops(inode);
2916        } else if (S_ISDIR(inode->i_mode)) {
2917                inode->i_op = &ext3_dir_inode_operations;
2918                inode->i_fop = &ext3_dir_operations;
2919        } else if (S_ISLNK(inode->i_mode)) {
2920                if (ext3_inode_is_fast_symlink(inode)) {
2921                        inode->i_op = &ext3_fast_symlink_inode_operations;
2922                        nd_terminate_link(ei->i_data, inode->i_size,
2923                                sizeof(ei->i_data) - 1);
2924                } else {
2925                        inode->i_op = &ext3_symlink_inode_operations;
2926                        ext3_set_aops(inode);
2927                }
2928        } else {
2929                inode->i_op = &ext3_special_inode_operations;
2930                if (raw_inode->i_block[0])
2931                        init_special_inode(inode, inode->i_mode,
2932                           old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
2933                else
2934                        init_special_inode(inode, inode->i_mode,
2935                           new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
2936        }
2937        brelse (iloc.bh);
2938        ext3_set_inode_flags(inode);
2939        unlock_new_inode(inode);
2940        return inode;
2941
2942bad_inode:
2943        iget_failed(inode);
2944        return ERR_PTR(ret);
2945}
2946
2947/*
2948 * Post the struct inode info into an on-disk inode location in the
2949 * buffer-cache.  This gobbles the caller's reference to the
2950 * buffer_head in the inode location struct.
2951 *
2952 * The caller must have write access to iloc->bh.
2953 */
2954static int ext3_do_update_inode(handle_t *handle,
2955                                struct inode *inode,
2956                                struct ext3_iloc *iloc)
2957{
2958        struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
2959        struct ext3_inode_info *ei = EXT3_I(inode);
2960        struct buffer_head *bh = iloc->bh;
2961        int err = 0, rc, block;
2962
2963again:
2964        /* we can't allow multiple procs in here at once, its a bit racey */
2965        lock_buffer(bh);
2966
2967        /* For fields not not tracking in the in-memory inode,
2968         * initialise them to zero for new inodes. */
2969        if (ext3_test_inode_state(inode, EXT3_STATE_NEW))
2970                memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
2971
2972        ext3_get_inode_flags(ei);
2973        raw_inode->i_mode = cpu_to_le16(inode->i_mode);
2974        if(!(test_opt(inode->i_sb, NO_UID32))) {
2975                raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
2976                raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
2977/*
2978 * Fix up interoperability with old kernels. Otherwise, old inodes get
2979 * re-used with the upper 16 bits of the uid/gid intact
2980 */
2981                if(!ei->i_dtime) {
2982                        raw_inode->i_uid_high =
2983                                cpu_to_le16(high_16_bits(inode->i_uid));
2984                        raw_inode->i_gid_high =
2985                                cpu_to_le16(high_16_bits(inode->i_gid));
2986                } else {
2987                        raw_inode->i_uid_high = 0;
2988                        raw_inode->i_gid_high = 0;
2989                }
2990        } else {
2991                raw_inode->i_uid_low =
2992                        cpu_to_le16(fs_high2lowuid(inode->i_uid));
2993                raw_inode->i_gid_low =
2994                        cpu_to_le16(fs_high2lowgid(inode->i_gid));
2995                raw_inode->i_uid_high = 0;
2996                raw_inode->i_gid_high = 0;
2997        }
2998        raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
2999        raw_inode->i_size = cpu_to_le32(ei->i_disksize);
3000        raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
3001        raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
3002        raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
3003        raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
3004        raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
3005        raw_inode->i_flags = cpu_to_le32(ei->i_flags);
3006#ifdef EXT3_FRAGMENTS
3007        raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
3008        raw_inode->i_frag = ei->i_frag_no;
3009        raw_inode->i_fsize = ei->i_frag_size;
3010#endif
3011        raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
3012        if (!S_ISREG(inode->i_mode)) {
3013                raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
3014        } else {
3015                raw_inode->i_size_high =
3016                        cpu_to_le32(ei->i_disksize >> 32);
3017                if (ei->i_disksize > 0x7fffffffULL) {
3018                        struct super_block *sb = inode->i_sb;
3019                        if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
3020                                        EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
3021                            EXT3_SB(sb)->s_es->s_rev_level ==
3022                                        cpu_to_le32(EXT3_GOOD_OLD_REV)) {
3023                               /* If this is the first large file
3024                                * created, add a flag to the superblock.
3025                                */
3026                                unlock_buffer(bh);
3027                                err = ext3_journal_get_write_access(handle,
3028                                                EXT3_SB(sb)->s_sbh);
3029                                if (err)
3030                                        goto out_brelse;
3031
3032                                ext3_update_dynamic_rev(sb);
3033                                EXT3_SET_RO_COMPAT_FEATURE(sb,
3034                                        EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
3035                                handle->h_sync = 1;
3036                                err = ext3_journal_dirty_metadata(handle,
3037                                                EXT3_SB(sb)->s_sbh);
3038                                /* get our lock and start over */
3039                                goto again;
3040                        }
3041                }
3042        }
3043        raw_inode->i_generation = cpu_to_le32(inode->i_generation);
3044        if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
3045                if (old_valid_dev(inode->i_rdev)) {
3046                        raw_inode->i_block[0] =
3047                                cpu_to_le32(old_encode_dev(inode->i_rdev));
3048                        raw_inode->i_block[1] = 0;
3049                } else {
3050                        raw_inode->i_block[0] = 0;
3051                        raw_inode->i_block[1] =
3052                                cpu_to_le32(new_encode_dev(inode->i_rdev));
3053                        raw_inode->i_block[2] = 0;
3054                }
3055        } else for (block = 0; block < EXT3_N_BLOCKS; block++)
3056                raw_inode->i_block[block] = ei->i_data[block];
3057
3058        if (ei->i_extra_isize)
3059                raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
3060
3061        BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
3062        unlock_buffer(bh);
3063        rc = ext3_journal_dirty_metadata(handle, bh);
3064        if (!err)
3065                err = rc;
3066        ext3_clear_inode_state(inode, EXT3_STATE_NEW);
3067
3068        atomic_set(&ei->i_sync_tid, handle->h_transaction->t_tid);
3069out_brelse:
3070        brelse (bh);
3071        ext3_std_error(inode->i_sb, err);
3072        return err;
3073}
3074
3075/*
3076 * ext3_write_inode()
3077 *
3078 * We are called from a few places:
3079 *
3080 * - Within generic_file_write() for O_SYNC files.
3081 *   Here, there will be no transaction running. We wait for any running
3082 *   trasnaction to commit.
3083 *
3084 * - Within sys_sync(), kupdate and such.
3085 *   We wait on commit, if tol to.
3086 *
3087 * - Within prune_icache() (PF_MEMALLOC == true)
3088 *   Here we simply return.  We can't afford to block kswapd on the
3089 *   journal commit.
3090 *
3091 * In all cases it is actually safe for us to return without doing anything,
3092 * because the inode has been copied into a raw inode buffer in
3093 * ext3_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
3094 * knfsd.
3095 *
3096 * Note that we are absolutely dependent upon all inode dirtiers doing the
3097 * right thing: they *must* call mark_inode_dirty() after dirtying info in
3098 * which we are interested.
3099 *
3100 * It would be a bug for them to not do this.  The code:
3101 *
3102 *      mark_inode_dirty(inode)
3103 *      stuff();
3104 *      inode->i_size = expr;
3105 *
3106 * is in error because a kswapd-driven write_inode() could occur while
3107 * `stuff()' is running, and the new i_size will be lost.  Plus the inode
3108 * will no longer be on the superblock's dirty inode list.
3109 */
3110int ext3_write_inode(struct inode *inode, struct writeback_control *wbc)
3111{
3112        if (current->flags & PF_MEMALLOC)
3113                return 0;
3114
3115        if (ext3_journal_current_handle()) {
3116                jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
3117                dump_stack();
3118                return -EIO;
3119        }
3120
3121        if (wbc->sync_mode != WB_SYNC_ALL)
3122                return 0;
3123
3124        return ext3_force_commit(inode->i_sb);
3125}
3126
3127/*
3128 * ext3_setattr()
3129 *
3130 * Called from notify_change.
3131 *
3132 * We want to trap VFS attempts to truncate the file as soon as
3133 * possible.  In particular, we want to make sure that when the VFS
3134 * shrinks i_size, we put the inode on the orphan list and modify
3135 * i_disksize immediately, so that during the subsequent flushing of
3136 * dirty pages and freeing of disk blocks, we can guarantee that any
3137 * commit will leave the blocks being flushed in an unused state on
3138 * disk.  (On recovery, the inode will get truncated and the blocks will
3139 * be freed, so we have a strong guarantee that no future commit will
3140 * leave these blocks visible to the user.)
3141 *
3142 * Called with inode->sem down.
3143 */
3144int ext3_setattr(struct dentry *dentry, struct iattr *attr)
3145{
3146        struct inode *inode = dentry->d_inode;
3147        int error, rc = 0;
3148        const unsigned int ia_valid = attr->ia_valid;
3149
3150        error = inode_change_ok(inode, attr);
3151        if (error)
3152                return error;
3153
3154        if (ia_valid & ATTR_SIZE)
3155                dquot_initialize(inode);
3156        if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
3157                (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
3158                handle_t *handle;
3159
3160                /* (user+group)*(old+new) structure, inode write (sb,
3161                 * inode block, ? - but truncate inode update has it) */
3162                handle = ext3_journal_start(inode, EXT3_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
3163                                        EXT3_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)+3);
3164                if (IS_ERR(handle)) {
3165                        error = PTR_ERR(handle);
3166                        goto err_out;
3167                }
3168                error = dquot_transfer(inode, attr);
3169                if (error) {
3170                        ext3_journal_stop(handle);
3171                        return error;
3172                }
3173                /* Update corresponding info in inode so that everything is in
3174                 * one transaction */
3175                if (attr->ia_valid & ATTR_UID)
3176                        inode->i_uid = attr->ia_uid;
3177                if (attr->ia_valid & ATTR_GID)
3178                        inode->i_gid = attr->ia_gid;
3179                error = ext3_mark_inode_dirty(handle, inode);
3180                ext3_journal_stop(handle);
3181        }
3182
3183        if (S_ISREG(inode->i_mode) &&
3184            attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
3185                handle_t *handle;
3186
3187                handle = ext3_journal_start(inode, 3);
3188                if (IS_ERR(handle)) {
3189                        error = PTR_ERR(handle);
3190                        goto err_out;
3191                }
3192
3193                error = ext3_orphan_add(handle, inode);
3194                EXT3_I(inode)->i_disksize = attr->ia_size;
3195                rc = ext3_mark_inode_dirty(handle, inode);
3196                if (!error)
3197                        error = rc;
3198                ext3_journal_stop(handle);
3199        }
3200
3201        rc = inode_setattr(inode, attr);
3202
3203        if (!rc && (ia_valid & ATTR_MODE))
3204                rc = ext3_acl_chmod(inode);
3205
3206err_out:
3207        ext3_std_error(inode->i_sb, error);
3208        if (!error)
3209                error = rc;
3210        return error;
3211}
3212
3213
3214/*
3215 * How many blocks doth make a writepage()?
3216 *
3217 * With N blocks per page, it may be:
3218 * N data blocks
3219 * 2 indirect block
3220 * 2 dindirect
3221 * 1 tindirect
3222 * N+5 bitmap blocks (from the above)
3223 * N+5 group descriptor summary blocks
3224 * 1 inode block
3225 * 1 superblock.
3226 * 2 * EXT3_SINGLEDATA_TRANS_BLOCKS for the quote files
3227 *
3228 * 3 * (N + 5) + 2 + 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
3229 *
3230 * With ordered or writeback data it's the same, less the N data blocks.
3231 *
3232 * If the inode's direct blocks can hold an integral number of pages then a
3233 * page cannot straddle two indirect blocks, and we can only touch one indirect
3234 * and dindirect block, and the "5" above becomes "3".
3235 *
3236 * This still overestimates under most circumstances.  If we were to pass the
3237 * start and end offsets in here as well we could do block_to_path() on each
3238 * block and work out the exact number of indirects which are touched.  Pah.
3239 */
3240
3241static int ext3_writepage_trans_blocks(struct inode *inode)
3242{
3243        int bpp = ext3_journal_blocks_per_page(inode);
3244        int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
3245        int ret;
3246
3247        if (ext3_should_journal_data(inode))
3248                ret = 3 * (bpp + indirects) + 2;
3249        else
3250                ret = 2 * (bpp + indirects) + 2;
3251
3252#ifdef CONFIG_QUOTA
3253        /* We know that structure was already allocated during dquot_initialize so
3254         * we will be updating only the data blocks + inodes */
3255        ret += EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
3256#endif
3257
3258        return ret;
3259}
3260
3261/*
3262 * The caller must have previously called ext3_reserve_inode_write().
3263 * Give this, we know that the caller already has write access to iloc->bh.
3264 */
3265int ext3_mark_iloc_dirty(handle_t *handle,
3266                struct inode *inode, struct ext3_iloc *iloc)
3267{
3268        int err = 0;
3269
3270        /* the do_update_inode consumes one bh->b_count */
3271        get_bh(iloc->bh);
3272
3273        /* ext3_do_update_inode() does journal_dirty_metadata */
3274        err = ext3_do_update_inode(handle, inode, iloc);
3275        put_bh(iloc->bh);
3276        return err;
3277}
3278
3279/*
3280 * On success, We end up with an outstanding reference count against
3281 * iloc->bh.  This _must_ be cleaned up later.
3282 */
3283
3284int
3285ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
3286                         struct ext3_iloc *iloc)
3287{
3288        int err = 0;
3289        if (handle) {
3290                err = ext3_get_inode_loc(inode, iloc);
3291                if (!err) {
3292                        BUFFER_TRACE(iloc->bh, "get_write_access");
3293                        err = ext3_journal_get_write_access(handle, iloc->bh);
3294                        if (err) {
3295                                brelse(iloc->bh);
3296                                iloc->bh = NULL;
3297                        }
3298                }
3299        }
3300        ext3_std_error(inode->i_sb, err);
3301        return err;
3302}
3303
3304/*
3305 * What we do here is to mark the in-core inode as clean with respect to inode
3306 * dirtiness (it may still be data-dirty).
3307 * This means that the in-core inode may be reaped by prune_icache
3308 * without having to perform any I/O.  This is a very good thing,
3309 * because *any* task may call prune_icache - even ones which
3310 * have a transaction open against a different journal.
3311 *
3312 * Is this cheating?  Not really.  Sure, we haven't written the
3313 * inode out, but prune_icache isn't a user-visible syncing function.
3314 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
3315 * we start and wait on commits.
3316 *
3317 * Is this efficient/effective?  Well, we're being nice to the system
3318 * by cleaning up our inodes proactively so they can be reaped
3319 * without I/O.  But we are potentially leaving up to five seconds'
3320 * worth of inodes floating about which prune_icache wants us to
3321 * write out.  One way to fix that would be to get prune_icache()
3322 * to do a write_super() to free up some memory.  It has the desired
3323 * effect.
3324 */
3325int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
3326{
3327        struct ext3_iloc iloc;
3328        int err;
3329
3330        might_sleep();
3331        err = ext3_reserve_inode_write(handle, inode, &iloc);
3332        if (!err)
3333                err = ext3_mark_iloc_dirty(handle, inode, &iloc);
3334        return err;
3335}
3336
3337/*
3338 * ext3_dirty_inode() is called from __mark_inode_dirty()
3339 *
3340 * We're really interested in the case where a file is being extended.
3341 * i_size has been changed by generic_commit_write() and we thus need
3342 * to include the updated inode in the current transaction.
3343 *
3344 * Also, dquot_alloc_space() will always dirty the inode when blocks
3345 * are allocated to the file.
3346 *
3347 * If the inode is marked synchronous, we don't honour that here - doing
3348 * so would cause a commit on atime updates, which we don't bother doing.
3349 * We handle synchronous inodes at the highest possible level.
3350 */
3351void ext3_dirty_inode(struct inode *inode)
3352{
3353        handle_t *current_handle = ext3_journal_current_handle();
3354        handle_t *handle;
3355
3356        handle = ext3_journal_start(inode, 2);
3357        if (IS_ERR(handle))
3358                goto out;
3359        if (current_handle &&
3360                current_handle->h_transaction != handle->h_transaction) {
3361                /* This task has a transaction open against a different fs */
3362                printk(KERN_EMERG "%s: transactions do not match!\n",
3363                       __func__);
3364        } else {
3365                jbd_debug(5, "marking dirty.  outer handle=%p\n",
3366                                current_handle);
3367                ext3_mark_inode_dirty(handle, inode);
3368        }
3369        ext3_journal_stop(handle);
3370out:
3371        return;
3372}
3373
3374#if 0
3375/*
3376 * Bind an inode's backing buffer_head into this transaction, to prevent
3377 * it from being flushed to disk early.  Unlike
3378 * ext3_reserve_inode_write, this leaves behind no bh reference and
3379 * returns no iloc structure, so the caller needs to repeat the iloc
3380 * lookup to mark the inode dirty later.
3381 */
3382static int ext3_pin_inode(handle_t *handle, struct inode *inode)
3383{
3384        struct ext3_iloc iloc;
3385
3386        int err = 0;
3387        if (handle) {
3388                err = ext3_get_inode_loc(inode, &iloc);
3389                if (!err) {
3390                        BUFFER_TRACE(iloc.bh, "get_write_access");
3391                        err = journal_get_write_access(handle, iloc.bh);
3392                        if (!err)
3393                                err = ext3_journal_dirty_metadata(handle,
3394                                                                  iloc.bh);
3395                        brelse(iloc.bh);
3396                }
3397        }
3398        ext3_std_error(inode->i_sb, err);
3399        return err;
3400}
3401#endif
3402
3403int ext3_change_inode_journal_flag(struct inode *inode, int val)
3404{
3405        journal_t *journal;
3406        handle_t *handle;
3407        int err;
3408
3409        /*
3410         * We have to be very careful here: changing a data block's
3411         * journaling status dynamically is dangerous.  If we write a
3412         * data block to the journal, change the status and then delete
3413         * that block, we risk forgetting to revoke the old log record
3414         * from the journal and so a subsequent replay can corrupt data.
3415         * So, first we make sure that the journal is empty and that
3416         * nobody is changing anything.
3417         */
3418
3419        journal = EXT3_JOURNAL(inode);
3420        if (is_journal_aborted(journal))
3421                return -EROFS;
3422
3423        journal_lock_updates(journal);
3424        journal_flush(journal);
3425
3426        /*
3427         * OK, there are no updates running now, and all cached data is
3428         * synced to disk.  We are now in a completely consistent state
3429         * which doesn't have anything in the journal, and we know that
3430         * no filesystem updates are running, so it is safe to modify
3431         * the inode's in-core data-journaling state flag now.
3432         */
3433
3434        if (val)
3435                EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3436        else
3437                EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3438        ext3_set_aops(inode);
3439
3440        journal_unlock_updates(journal);
3441
3442        /* Finally we can mark the inode as dirty. */
3443
3444        handle = ext3_journal_start(inode, 1);
3445        if (IS_ERR(handle))
3446                return PTR_ERR(handle);
3447
3448        err = ext3_mark_inode_dirty(handle, inode);
3449        handle->h_sync = 1;
3450        ext3_journal_stop(handle);
3451        ext3_std_error(inode->i_sb, err);
3452
3453        return err;
3454}
3455
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.