linux/fs/ext2/inode.c
<<
>>
Prefs
   1/*
   2 *  linux/fs/ext2/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@dcs.ed.ac.uk), 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 ext2_get_block() by Al Viro, 2000
  23 */
  24
  25#include <linux/time.h>
  26#include <linux/highuid.h>
  27#include <linux/pagemap.h>
  28#include <linux/quotaops.h>
  29#include <linux/writeback.h>
  30#include <linux/buffer_head.h>
  31#include <linux/mpage.h>
  32#include <linux/fiemap.h>
  33#include <linux/namei.h>
  34#include "ext2.h"
  35#include "acl.h"
  36#include "xip.h"
  37
  38static int __ext2_write_inode(struct inode *inode, int do_sync);
  39
  40/*
  41 * Test whether an inode is a fast symlink.
  42 */
  43static inline int ext2_inode_is_fast_symlink(struct inode *inode)
  44{
  45        int ea_blocks = EXT2_I(inode)->i_file_acl ?
  46                (inode->i_sb->s_blocksize >> 9) : 0;
  47
  48        return (S_ISLNK(inode->i_mode) &&
  49                inode->i_blocks - ea_blocks == 0);
  50}
  51
  52static void ext2_truncate_blocks(struct inode *inode, loff_t offset);
  53
  54static void ext2_write_failed(struct address_space *mapping, loff_t to)
  55{
  56        struct inode *inode = mapping->host;
  57
  58        if (to > inode->i_size) {
  59                truncate_pagecache(inode, to, inode->i_size);
  60                ext2_truncate_blocks(inode, inode->i_size);
  61        }
  62}
  63
  64/*
  65 * Called at the last iput() if i_nlink is zero.
  66 */
  67void ext2_evict_inode(struct inode * inode)
  68{
  69        struct ext2_block_alloc_info *rsv;
  70        int want_delete = 0;
  71
  72        if (!inode->i_nlink && !is_bad_inode(inode)) {
  73                want_delete = 1;
  74                dquot_initialize(inode);
  75        } else {
  76                dquot_drop(inode);
  77        }
  78
  79        truncate_inode_pages(&inode->i_data, 0);
  80
  81        if (want_delete) {
  82                sb_start_intwrite(inode->i_sb);
  83                /* set dtime */
  84                EXT2_I(inode)->i_dtime  = get_seconds();
  85                mark_inode_dirty(inode);
  86                __ext2_write_inode(inode, inode_needs_sync(inode));
  87                /* truncate to 0 */
  88                inode->i_size = 0;
  89                if (inode->i_blocks)
  90                        ext2_truncate_blocks(inode, 0);
  91        }
  92
  93        invalidate_inode_buffers(inode);
  94        clear_inode(inode);
  95
  96        ext2_discard_reservation(inode);
  97        rsv = EXT2_I(inode)->i_block_alloc_info;
  98        EXT2_I(inode)->i_block_alloc_info = NULL;
  99        if (unlikely(rsv))
 100                kfree(rsv);
 101
 102        if (want_delete) {
 103                ext2_free_inode(inode);
 104                sb_end_intwrite(inode->i_sb);
 105        }
 106}
 107
 108typedef struct {
 109        __le32  *p;
 110        __le32  key;
 111        struct buffer_head *bh;
 112} Indirect;
 113
 114static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
 115{
 116        p->key = *(p->p = v);
 117        p->bh = bh;
 118}
 119
 120static inline int verify_chain(Indirect *from, Indirect *to)
 121{
 122        while (from <= to && from->key == *from->p)
 123                from++;
 124        return (from > to);
 125}
 126
 127/**
 128 *      ext2_block_to_path - parse the block number into array of offsets
 129 *      @inode: inode in question (we are only interested in its superblock)
 130 *      @i_block: block number to be parsed
 131 *      @offsets: array to store the offsets in
 132 *      @boundary: set this non-zero if the referred-to block is likely to be
 133 *             followed (on disk) by an indirect block.
 134 *      To store the locations of file's data ext2 uses a data structure common
 135 *      for UNIX filesystems - tree of pointers anchored in the inode, with
 136 *      data blocks at leaves and indirect blocks in intermediate nodes.
 137 *      This function translates the block number into path in that tree -
 138 *      return value is the path length and @offsets[n] is the offset of
 139 *      pointer to (n+1)th node in the nth one. If @block is out of range
 140 *      (negative or too large) warning is printed and zero returned.
 141 *
 142 *      Note: function doesn't find node addresses, so no IO is needed. All
 143 *      we need to know is the capacity of indirect blocks (taken from the
 144 *      inode->i_sb).
 145 */
 146
 147/*
 148 * Portability note: the last comparison (check that we fit into triple
 149 * indirect block) is spelled differently, because otherwise on an
 150 * architecture with 32-bit longs and 8Kb pages we might get into trouble
 151 * if our filesystem had 8Kb blocks. We might use long long, but that would
 152 * kill us on x86. Oh, well, at least the sign propagation does not matter -
 153 * i_block would have to be negative in the very beginning, so we would not
 154 * get there at all.
 155 */
 156
 157static int ext2_block_to_path(struct inode *inode,
 158                        long i_block, int offsets[4], int *boundary)
 159{
 160        int ptrs = EXT2_ADDR_PER_BLOCK(inode->i_sb);
 161        int ptrs_bits = EXT2_ADDR_PER_BLOCK_BITS(inode->i_sb);
 162        const long direct_blocks = EXT2_NDIR_BLOCKS,
 163                indirect_blocks = ptrs,
 164                double_blocks = (1 << (ptrs_bits * 2));
 165        int n = 0;
 166        int final = 0;
 167
 168        if (i_block < 0) {
 169                ext2_msg(inode->i_sb, KERN_WARNING,
 170                        "warning: %s: block < 0", __func__);
 171        } else if (i_block < direct_blocks) {
 172                offsets[n++] = i_block;
 173                final = direct_blocks;
 174        } else if ( (i_block -= direct_blocks) < indirect_blocks) {
 175                offsets[n++] = EXT2_IND_BLOCK;
 176                offsets[n++] = i_block;
 177                final = ptrs;
 178        } else if ((i_block -= indirect_blocks) < double_blocks) {
 179                offsets[n++] = EXT2_DIND_BLOCK;
 180                offsets[n++] = i_block >> ptrs_bits;
 181                offsets[n++] = i_block & (ptrs - 1);
 182                final = ptrs;
 183        } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
 184                offsets[n++] = EXT2_TIND_BLOCK;
 185                offsets[n++] = i_block >> (ptrs_bits * 2);
 186                offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
 187                offsets[n++] = i_block & (ptrs - 1);
 188                final = ptrs;
 189        } else {
 190                ext2_msg(inode->i_sb, KERN_WARNING,
 191                        "warning: %s: block is too big", __func__);
 192        }
 193        if (boundary)
 194                *boundary = final - 1 - (i_block & (ptrs - 1));
 195
 196        return n;
 197}
 198
 199/**
 200 *      ext2_get_branch - read the chain of indirect blocks leading to data
 201 *      @inode: inode in question
 202 *      @depth: depth of the chain (1 - direct pointer, etc.)
 203 *      @offsets: offsets of pointers in inode/indirect blocks
 204 *      @chain: place to store the result
 205 *      @err: here we store the error value
 206 *
 207 *      Function fills the array of triples <key, p, bh> and returns %NULL
 208 *      if everything went OK or the pointer to the last filled triple
 209 *      (incomplete one) otherwise. Upon the return chain[i].key contains
 210 *      the number of (i+1)-th block in the chain (as it is stored in memory,
 211 *      i.e. little-endian 32-bit), chain[i].p contains the address of that
 212 *      number (it points into struct inode for i==0 and into the bh->b_data
 213 *      for i>0) and chain[i].bh points to the buffer_head of i-th indirect
 214 *      block for i>0 and NULL for i==0. In other words, it holds the block
 215 *      numbers of the chain, addresses they were taken from (and where we can
 216 *      verify that chain did not change) and buffer_heads hosting these
 217 *      numbers.
 218 *
 219 *      Function stops when it stumbles upon zero pointer (absent block)
 220 *              (pointer to last triple returned, *@err == 0)
 221 *      or when it gets an IO error reading an indirect block
 222 *              (ditto, *@err == -EIO)
 223 *      or when it notices that chain had been changed while it was reading
 224 *              (ditto, *@err == -EAGAIN)
 225 *      or when it reads all @depth-1 indirect blocks successfully and finds
 226 *      the whole chain, all way to the data (returns %NULL, *err == 0).
 227 */
 228static Indirect *ext2_get_branch(struct inode *inode,
 229                                 int depth,
 230                                 int *offsets,
 231                                 Indirect chain[4],
 232                                 int *err)
 233{
 234        struct super_block *sb = inode->i_sb;
 235        Indirect *p = chain;
 236        struct buffer_head *bh;
 237
 238        *err = 0;
 239        /* i_data is not going away, no lock needed */
 240        add_chain (chain, NULL, EXT2_I(inode)->i_data + *offsets);
 241        if (!p->key)
 242                goto no_block;
 243        while (--depth) {
 244                bh = sb_bread(sb, le32_to_cpu(p->key));
 245                if (!bh)
 246                        goto failure;
 247                read_lock(&EXT2_I(inode)->i_meta_lock);
 248                if (!verify_chain(chain, p))
 249                        goto changed;
 250                add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
 251                read_unlock(&EXT2_I(inode)->i_meta_lock);
 252                if (!p->key)
 253                        goto no_block;
 254        }
 255        return NULL;
 256
 257changed:
 258        read_unlock(&EXT2_I(inode)->i_meta_lock);
 259        brelse(bh);
 260        *err = -EAGAIN;
 261        goto no_block;
 262failure:
 263        *err = -EIO;
 264no_block:
 265        return p;
 266}
 267
 268/**
 269 *      ext2_find_near - find a place for allocation with sufficient locality
 270 *      @inode: owner
 271 *      @ind: descriptor of indirect block.
 272 *
 273 *      This function returns the preferred place for block allocation.
 274 *      It is used when heuristic for sequential allocation fails.
 275 *      Rules are:
 276 *        + if there is a block to the left of our position - allocate near it.
 277 *        + if pointer will live in indirect block - allocate near that block.
 278 *        + if pointer will live in inode - allocate in the same cylinder group.
 279 *
 280 * In the latter case we colour the starting block by the callers PID to
 281 * prevent it from clashing with concurrent allocations for a different inode
 282 * in the same block group.   The PID is used here so that functionally related
 283 * files will be close-by on-disk.
 284 *
 285 *      Caller must make sure that @ind is valid and will stay that way.
 286 */
 287
 288static ext2_fsblk_t ext2_find_near(struct inode *inode, Indirect *ind)
 289{
 290        struct ext2_inode_info *ei = EXT2_I(inode);
 291        __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
 292        __le32 *p;
 293        ext2_fsblk_t bg_start;
 294        ext2_fsblk_t colour;
 295
 296        /* Try to find previous block */
 297        for (p = ind->p - 1; p >= start; p--)
 298                if (*p)
 299                        return le32_to_cpu(*p);
 300
 301        /* No such thing, so let's try location of indirect block */
 302        if (ind->bh)
 303                return ind->bh->b_blocknr;
 304
 305        /*
 306         * It is going to be referred from inode itself? OK, just put it into
 307         * the same cylinder group then.
 308         */
 309        bg_start = ext2_group_first_block_no(inode->i_sb, ei->i_block_group);
 310        colour = (current->pid % 16) *
 311                        (EXT2_BLOCKS_PER_GROUP(inode->i_sb) / 16);
 312        return bg_start + colour;
 313}
 314
 315/**
 316 *      ext2_find_goal - find a preferred place for allocation.
 317 *      @inode: owner
 318 *      @block:  block we want
 319 *      @partial: pointer to the last triple within a chain
 320 *
 321 *      Returns preferred place for a block (the goal).
 322 */
 323
 324static inline ext2_fsblk_t ext2_find_goal(struct inode *inode, long block,
 325                                          Indirect *partial)
 326{
 327        struct ext2_block_alloc_info *block_i;
 328
 329        block_i = EXT2_I(inode)->i_block_alloc_info;
 330
 331        /*
 332         * try the heuristic for sequential allocation,
 333         * failing that at least try to get decent locality.
 334         */
 335        if (block_i && (block == block_i->last_alloc_logical_block + 1)
 336                && (block_i->last_alloc_physical_block != 0)) {
 337                return block_i->last_alloc_physical_block + 1;
 338        }
 339
 340        return ext2_find_near(inode, partial);
 341}
 342
 343/**
 344 *      ext2_blks_to_allocate: Look up the block map and count the number
 345 *      of direct blocks need to be allocated for the given branch.
 346 *
 347 *      @branch: chain of indirect blocks
 348 *      @k: number of blocks need for indirect blocks
 349 *      @blks: number of data blocks to be mapped.
 350 *      @blocks_to_boundary:  the offset in the indirect block
 351 *
 352 *      return the total number of blocks to be allocate, including the
 353 *      direct and indirect blocks.
 354 */
 355static int
 356ext2_blks_to_allocate(Indirect * branch, int k, unsigned long blks,
 357                int blocks_to_boundary)
 358{
 359        unsigned long count = 0;
 360
 361        /*
 362         * Simple case, [t,d]Indirect block(s) has not allocated yet
 363         * then it's clear blocks on that path have not allocated
 364         */
 365        if (k > 0) {
 366                /* right now don't hanel cross boundary allocation */
 367                if (blks < blocks_to_boundary + 1)
 368                        count += blks;
 369                else
 370                        count += blocks_to_boundary + 1;
 371                return count;
 372        }
 373
 374        count++;
 375        while (count < blks && count <= blocks_to_boundary
 376                && le32_to_cpu(*(branch[0].p + count)) == 0) {
 377                count++;
 378        }
 379        return count;
 380}
 381
 382/**
 383 *      ext2_alloc_blocks: multiple allocate blocks needed for a branch
 384 *      @indirect_blks: the number of blocks need to allocate for indirect
 385 *                      blocks
 386 *
 387 *      @new_blocks: on return it will store the new block numbers for
 388 *      the indirect blocks(if needed) and the first direct block,
 389 *      @blks:  on return it will store the total number of allocated
 390 *              direct blocks
 391 */
 392static int ext2_alloc_blocks(struct inode *inode,
 393                        ext2_fsblk_t goal, int indirect_blks, int blks,
 394                        ext2_fsblk_t new_blocks[4], int *err)
 395{
 396        int target, i;
 397        unsigned long count = 0;
 398        int index = 0;
 399        ext2_fsblk_t current_block = 0;
 400        int ret = 0;
 401
 402        /*
 403         * Here we try to allocate the requested multiple blocks at once,
 404         * on a best-effort basis.
 405         * To build a branch, we should allocate blocks for
 406         * the indirect blocks(if not allocated yet), and at least
 407         * the first direct block of this branch.  That's the
 408         * minimum number of blocks need to allocate(required)
 409         */
 410        target = blks + indirect_blks;
 411
 412        while (1) {
 413                count = target;
 414                /* allocating blocks for indirect blocks and direct blocks */
 415                current_block = ext2_new_blocks(inode,goal,&count,err);
 416                if (*err)
 417                        goto failed_out;
 418
 419                target -= count;
 420                /* allocate blocks for indirect blocks */
 421                while (index < indirect_blks && count) {
 422                        new_blocks[index++] = current_block++;
 423                        count--;
 424                }
 425
 426                if (count > 0)
 427                        break;
 428        }
 429
 430        /* save the new block number for the first direct block */
 431        new_blocks[index] = current_block;
 432
 433        /* total number of blocks allocated for direct blocks */
 434        ret = count;
 435        *err = 0;
 436        return ret;
 437failed_out:
 438        for (i = 0; i <index; i++)
 439                ext2_free_blocks(inode, new_blocks[i], 1);
 440        if (index)
 441                mark_inode_dirty(inode);
 442        return ret;
 443}
 444
 445/**
 446 *      ext2_alloc_branch - allocate and set up a chain of blocks.
 447 *      @inode: owner
 448 *      @num: depth of the chain (number of blocks to allocate)
 449 *      @offsets: offsets (in the blocks) to store the pointers to next.
 450 *      @branch: place to store the chain in.
 451 *
 452 *      This function allocates @num blocks, zeroes out all but the last one,
 453 *      links them into chain and (if we are synchronous) writes them to disk.
 454 *      In other words, it prepares a branch that can be spliced onto the
 455 *      inode. It stores the information about that chain in the branch[], in
 456 *      the same format as ext2_get_branch() would do. We are calling it after
 457 *      we had read the existing part of chain and partial points to the last
 458 *      triple of that (one with zero ->key). Upon the exit we have the same
 459 *      picture as after the successful ext2_get_block(), except that in one
 460 *      place chain is disconnected - *branch->p is still zero (we did not
 461 *      set the last link), but branch->key contains the number that should
 462 *      be placed into *branch->p to fill that gap.
 463 *
 464 *      If allocation fails we free all blocks we've allocated (and forget
 465 *      their buffer_heads) and return the error value the from failed
 466 *      ext2_alloc_block() (normally -ENOSPC). Otherwise we set the chain
 467 *      as described above and return 0.
 468 */
 469
 470static int ext2_alloc_branch(struct inode *inode,
 471                        int indirect_blks, int *blks, ext2_fsblk_t goal,
 472                        int *offsets, Indirect *branch)
 473{
 474        int blocksize = inode->i_sb->s_blocksize;
 475        int i, n = 0;
 476        int err = 0;
 477        struct buffer_head *bh;
 478        int num;
 479        ext2_fsblk_t new_blocks[4];
 480        ext2_fsblk_t current_block;
 481
 482        num = ext2_alloc_blocks(inode, goal, indirect_blks,
 483                                *blks, new_blocks, &err);
 484        if (err)
 485                return err;
 486
 487        branch[0].key = cpu_to_le32(new_blocks[0]);
 488        /*
 489         * metadata blocks and data blocks are allocated.
 490         */
 491        for (n = 1; n <= indirect_blks;  n++) {
 492                /*
 493                 * Get buffer_head for parent block, zero it out
 494                 * and set the pointer to new one, then send
 495                 * parent to disk.
 496                 */
 497                bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
 498                branch[n].bh = bh;
 499                lock_buffer(bh);
 500                memset(bh->b_data, 0, blocksize);
 501                branch[n].p = (__le32 *) bh->b_data + offsets[n];
 502                branch[n].key = cpu_to_le32(new_blocks[n]);
 503                *branch[n].p = branch[n].key;
 504                if ( n == indirect_blks) {
 505                        current_block = new_blocks[n];
 506                        /*
 507                         * End of chain, update the last new metablock of
 508                         * the chain to point to the new allocated
 509                         * data blocks numbers
 510                         */
 511                        for (i=1; i < num; i++)
 512                                *(branch[n].p + i) = cpu_to_le32(++current_block);
 513                }
 514                set_buffer_uptodate(bh);
 515                unlock_buffer(bh);
 516                mark_buffer_dirty_inode(bh, inode);
 517                /* We used to sync bh here if IS_SYNC(inode).
 518                 * But we now rely upon generic_write_sync()
 519                 * and b_inode_buffers.  But not for directories.
 520                 */
 521                if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
 522                        sync_dirty_buffer(bh);
 523        }
 524        *blks = num;
 525        return err;
 526}
 527
 528/**
 529 * ext2_splice_branch - splice the allocated branch onto inode.
 530 * @inode: owner
 531 * @block: (logical) number of block we are adding
 532 * @where: location of missing link
 533 * @num:   number of indirect blocks we are adding
 534 * @blks:  number of direct blocks we are adding
 535 *
 536 * This function fills the missing link and does all housekeeping needed in
 537 * inode (->i_blocks, etc.). In case of success we end up with the full
 538 * chain to new block and return 0.
 539 */
 540static void ext2_splice_branch(struct inode *inode,
 541                        long block, Indirect *where, int num, int blks)
 542{
 543        int i;
 544        struct ext2_block_alloc_info *block_i;
 545        ext2_fsblk_t current_block;
 546
 547        block_i = EXT2_I(inode)->i_block_alloc_info;
 548
 549        /* XXX LOCKING probably should have i_meta_lock ?*/
 550        /* That's it */
 551
 552        *where->p = where->key;
 553
 554        /*
 555         * Update the host buffer_head or inode to point to more just allocated
 556         * direct blocks blocks
 557         */
 558        if (num == 0 && blks > 1) {
 559                current_block = le32_to_cpu(where->key) + 1;
 560                for (i = 1; i < blks; i++)
 561                        *(where->p + i ) = cpu_to_le32(current_block++);
 562        }
 563
 564        /*
 565         * update the most recently allocated logical & physical block
 566         * in i_block_alloc_info, to assist find the proper goal block for next
 567         * allocation
 568         */
 569        if (block_i) {
 570                block_i->last_alloc_logical_block = block + blks - 1;
 571                block_i->last_alloc_physical_block =
 572                                le32_to_cpu(where[num].key) + blks - 1;
 573        }
 574
 575        /* We are done with atomic stuff, now do the rest of housekeeping */
 576
 577        /* had we spliced it onto indirect block? */
 578        if (where->bh)
 579                mark_buffer_dirty_inode(where->bh, inode);
 580
 581        inode->i_ctime = CURRENT_TIME_SEC;
 582        mark_inode_dirty(inode);
 583}
 584
 585/*
 586 * Allocation strategy is simple: if we have to allocate something, we will
 587 * have to go the whole way to leaf. So let's do it before attaching anything
 588 * to tree, set linkage between the newborn blocks, write them if sync is
 589 * required, recheck the path, free and repeat if check fails, otherwise
 590 * set the last missing link (that will protect us from any truncate-generated
 591 * removals - all blocks on the path are immune now) and possibly force the
 592 * write on the parent block.
 593 * That has a nice additional property: no special recovery from the failed
 594 * allocations is needed - we simply release blocks and do not touch anything
 595 * reachable from inode.
 596 *
 597 * `handle' can be NULL if create == 0.
 598 *
 599 * return > 0, # of blocks mapped or allocated.
 600 * return = 0, if plain lookup failed.
 601 * return < 0, error case.
 602 */
 603static int ext2_get_blocks(struct inode *inode,
 604                           sector_t iblock, unsigned long maxblocks,
 605                           struct buffer_head *bh_result,
 606                           int create)
 607{
 608        int err = -EIO;
 609        int offsets[4];
 610        Indirect chain[4];
 611        Indirect *partial;
 612        ext2_fsblk_t goal;
 613        int indirect_blks;
 614        int blocks_to_boundary = 0;
 615        int depth;
 616        struct ext2_inode_info *ei = EXT2_I(inode);
 617        int count = 0;
 618        ext2_fsblk_t first_block = 0;
 619
 620        depth = ext2_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
 621
 622        if (depth == 0)
 623                return (err);
 624
 625        partial = ext2_get_branch(inode, depth, offsets, chain, &err);
 626        /* Simplest case - block found, no allocation needed */
 627        if (!partial) {
 628                first_block = le32_to_cpu(chain[depth - 1].key);
 629                clear_buffer_new(bh_result); /* What's this do? */
 630                count++;
 631                /*map more blocks*/
 632                while (count < maxblocks && count <= blocks_to_boundary) {
 633                        ext2_fsblk_t blk;
 634
 635                        if (!verify_chain(chain, chain + depth - 1)) {
 636                                /*
 637                                 * Indirect block might be removed by
 638                                 * truncate while we were reading it.
 639                                 * Handling of that case: forget what we've
 640                                 * got now, go to reread.
 641                                 */
 642                                err = -EAGAIN;
 643                                count = 0;
 644                                break;
 645                        }
 646                        blk = le32_to_cpu(*(chain[depth-1].p + count));
 647                        if (blk == first_block + count)
 648                                count++;
 649                        else
 650                                break;
 651                }
 652                if (err != -EAGAIN)
 653                        goto got_it;
 654        }
 655
 656        /* Next simple case - plain lookup or failed read of indirect block */
 657        if (!create || err == -EIO)
 658                goto cleanup;
 659
 660        mutex_lock(&ei->truncate_mutex);
 661        /*
 662         * If the indirect block is missing while we are reading
 663         * the chain(ext2_get_branch() returns -EAGAIN err), or
 664         * if the chain has been changed after we grab the semaphore,
 665         * (either because another process truncated this branch, or
 666         * another get_block allocated this branch) re-grab the chain to see if
 667         * the request block has been allocated or not.
 668         *
 669         * Since we already block the truncate/other get_block
 670         * at this point, we will have the current copy of the chain when we
 671         * splice the branch into the tree.
 672         */
 673        if (err == -EAGAIN || !verify_chain(chain, partial)) {
 674                while (partial > chain) {
 675                        brelse(partial->bh);
 676                        partial--;
 677                }
 678                partial = ext2_get_branch(inode, depth, offsets, chain, &err);
 679                if (!partial) {
 680                        count++;
 681                        mutex_unlock(&ei->truncate_mutex);
 682                        if (err)
 683                                goto cleanup;
 684                        clear_buffer_new(bh_result);
 685                        goto got_it;
 686                }
 687        }
 688
 689        /*
 690         * Okay, we need to do block allocation.  Lazily initialize the block
 691         * allocation info here if necessary
 692        */
 693        if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
 694                ext2_init_block_alloc_info(inode);
 695
 696        goal = ext2_find_goal(inode, iblock, partial);
 697
 698        /* the number of blocks need to allocate for [d,t]indirect blocks */
 699        indirect_blks = (chain + depth) - partial - 1;
 700        /*
 701         * Next look up the indirect map to count the totoal number of
 702         * direct blocks to allocate for this branch.
 703         */
 704        count = ext2_blks_to_allocate(partial, indirect_blks,
 705                                        maxblocks, blocks_to_boundary);
 706        /*
 707         * XXX ???? Block out ext2_truncate while we alter the tree
 708         */
 709        err = ext2_alloc_branch(inode, indirect_blks, &count, goal,
 710                                offsets + (partial - chain), partial);
 711
 712        if (err) {
 713                mutex_unlock(&ei->truncate_mutex);
 714                goto cleanup;
 715        }
 716
 717        if (ext2_use_xip(inode->i_sb)) {
 718                /*
 719                 * we need to clear the block
 720                 */
 721                err = ext2_clear_xip_target (inode,
 722                        le32_to_cpu(chain[depth-1].key));
 723                if (err) {
 724                        mutex_unlock(&ei->truncate_mutex);
 725                        goto cleanup;
 726                }
 727        }
 728
 729        ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
 730        mutex_unlock(&ei->truncate_mutex);
 731        set_buffer_new(bh_result);
 732got_it:
 733        map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
 734        if (count > blocks_to_boundary)
 735                set_buffer_boundary(bh_result);
 736        err = count;
 737        /* Clean up and exit */
 738        partial = chain + depth - 1;    /* the whole chain */
 739cleanup:
 740        while (partial > chain) {
 741                brelse(partial->bh);
 742                partial--;
 743        }
 744        return err;
 745}
 746
 747int ext2_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create)
 748{
 749        unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
 750        int ret = ext2_get_blocks(inode, iblock, max_blocks,
 751                              bh_result, create);
 752        if (ret > 0) {
 753                bh_result->b_size = (ret << inode->i_blkbits);
 754                ret = 0;
 755        }
 756        return ret;
 757
 758}
 759
 760int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 761                u64 start, u64 len)
 762{
 763        return generic_block_fiemap(inode, fieinfo, start, len,
 764                                    ext2_get_block);
 765}
 766
 767static int ext2_writepage(struct page *page, struct writeback_control *wbc)
 768{
 769        return block_write_full_page(page, ext2_get_block, wbc);
 770}
 771
 772static int ext2_readpage(struct file *file, struct page *page)
 773{
 774        return mpage_readpage(page, ext2_get_block);
 775}
 776
 777static int
 778ext2_readpages(struct file *file, struct address_space *mapping,
 779                struct list_head *pages, unsigned nr_pages)
 780{
 781        return mpage_readpages(mapping, pages, nr_pages, ext2_get_block);
 782}
 783
 784static int
 785ext2_write_begin(struct file *file, struct address_space *mapping,
 786                loff_t pos, unsigned len, unsigned flags,
 787                struct page **pagep, void **fsdata)
 788{
 789        int ret;
 790
 791        ret = block_write_begin(mapping, pos, len, flags, pagep,
 792                                ext2_get_block);
 793        if (ret < 0)
 794                ext2_write_failed(mapping, pos + len);
 795        return ret;
 796}
 797
 798static int ext2_write_end(struct file *file, struct address_space *mapping,
 799                        loff_t pos, unsigned len, unsigned copied,
 800                        struct page *page, void *fsdata)
 801{
 802        int ret;
 803
 804        ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
 805        if (ret < len)
 806                ext2_write_failed(mapping, pos + len);
 807        return ret;
 808}
 809
 810static int
 811ext2_nobh_write_begin(struct file *file, struct address_space *mapping,
 812                loff_t pos, unsigned len, unsigned flags,
 813                struct page **pagep, void **fsdata)
 814{
 815        int ret;
 816
 817        ret = nobh_write_begin(mapping, pos, len, flags, pagep, fsdata,
 818                               ext2_get_block);
 819        if (ret < 0)
 820                ext2_write_failed(mapping, pos + len);
 821        return ret;
 822}
 823
 824static int ext2_nobh_writepage(struct page *page,
 825                        struct writeback_control *wbc)
 826{
 827        return nobh_writepage(page, ext2_get_block, wbc);
 828}
 829
 830static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
 831{
 832        return generic_block_bmap(mapping,block,ext2_get_block);
 833}
 834
 835static ssize_t
 836ext2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
 837                        loff_t offset, unsigned long nr_segs)
 838{
 839        struct file *file = iocb->ki_filp;
 840        struct address_space *mapping = file->f_mapping;
 841        struct inode *inode = mapping->host;
 842        ssize_t ret;
 843
 844        ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
 845                                 ext2_get_block);
 846        if (ret < 0 && (rw & WRITE))
 847                ext2_write_failed(mapping, offset + iov_length(iov, nr_segs));
 848        return ret;
 849}
 850
 851static int
 852ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
 853{
 854        return mpage_writepages(mapping, wbc, ext2_get_block);
 855}
 856
 857const struct address_space_operations ext2_aops = {
 858        .readpage               = ext2_readpage,
 859        .readpages              = ext2_readpages,
 860        .writepage              = ext2_writepage,
 861        .write_begin            = ext2_write_begin,
 862        .write_end              = ext2_write_end,
 863        .bmap                   = ext2_bmap,
 864        .direct_IO              = ext2_direct_IO,
 865        .writepages             = ext2_writepages,
 866        .migratepage            = buffer_migrate_page,
 867        .is_partially_uptodate  = block_is_partially_uptodate,
 868        .error_remove_page      = generic_error_remove_page,
 869};
 870
 871const struct address_space_operations ext2_aops_xip = {
 872        .bmap                   = ext2_bmap,
 873        .get_xip_mem            = ext2_get_xip_mem,
 874};
 875
 876const struct address_space_operations ext2_nobh_aops = {
 877        .readpage               = ext2_readpage,
 878        .readpages              = ext2_readpages,
 879        .writepage              = ext2_nobh_writepage,
 880        .write_begin            = ext2_nobh_write_begin,
 881        .write_end              = nobh_write_end,
 882        .bmap                   = ext2_bmap,
 883        .direct_IO              = ext2_direct_IO,
 884        .writepages             = ext2_writepages,
 885        .migratepage            = buffer_migrate_page,
 886        .error_remove_page      = generic_error_remove_page,
 887};
 888
 889/*
 890 * Probably it should be a library function... search for first non-zero word
 891 * or memcmp with zero_page, whatever is better for particular architecture.
 892 * Linus?
 893 */
 894static inline int all_zeroes(__le32 *p, __le32 *q)
 895{
 896        while (p < q)
 897                if (*p++)
 898                        return 0;
 899        return 1;
 900}
 901
 902/**
 903 *      ext2_find_shared - find the indirect blocks for partial truncation.
 904 *      @inode:   inode in question
 905 *      @depth:   depth of the affected branch
 906 *      @offsets: offsets of pointers in that branch (see ext2_block_to_path)
 907 *      @chain:   place to store the pointers to partial indirect blocks
 908 *      @top:     place to the (detached) top of branch
 909 *
 910 *      This is a helper function used by ext2_truncate().
 911 *
 912 *      When we do truncate() we may have to clean the ends of several indirect
 913 *      blocks but leave the blocks themselves alive. Block is partially
 914 *      truncated if some data below the new i_size is referred from it (and
 915 *      it is on the path to the first completely truncated data block, indeed).
 916 *      We have to free the top of that path along with everything to the right
 917 *      of the path. Since no allocation past the truncation point is possible
 918 *      until ext2_truncate() finishes, we may safely do the latter, but top
 919 *      of branch may require special attention - pageout below the truncation
 920 *      point might try to populate it.
 921 *
 922 *      We atomically detach the top of branch from the tree, store the block
 923 *      number of its root in *@top, pointers to buffer_heads of partially
 924 *      truncated blocks - in @chain[].bh and pointers to their last elements
 925 *      that should not be removed - in @chain[].p. Return value is the pointer
 926 *      to last filled element of @chain.
 927 *
 928 *      The work left to caller to do the actual freeing of subtrees:
 929 *              a) free the subtree starting from *@top
 930 *              b) free the subtrees whose roots are stored in
 931 *                      (@chain[i].p+1 .. end of @chain[i].bh->b_data)
 932 *              c) free the subtrees growing from the inode past the @chain[0].p
 933 *                      (no partially truncated stuff there).
 934 */
 935
 936static Indirect *ext2_find_shared(struct inode *inode,
 937                                int depth,
 938                                int offsets[4],
 939                                Indirect chain[4],
 940                                __le32 *top)
 941{
 942        Indirect *partial, *p;
 943        int k, err;
 944
 945        *top = 0;
 946        for (k = depth; k > 1 && !offsets[k-1]; k--)
 947                ;
 948        partial = ext2_get_branch(inode, k, offsets, chain, &err);
 949        if (!partial)
 950                partial = chain + k-1;
 951        /*
 952         * If the branch acquired continuation since we've looked at it -
 953         * fine, it should all survive and (new) top doesn't belong to us.
 954         */
 955        write_lock(&EXT2_I(inode)->i_meta_lock);
 956        if (!partial->key && *partial->p) {
 957                write_unlock(&EXT2_I(inode)->i_meta_lock);
 958                goto no_top;
 959        }
 960        for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
 961                ;
 962        /*
 963         * OK, we've found the last block that must survive. The rest of our
 964         * branch should be detached before unlocking. However, if that rest
 965         * of branch is all ours and does not grow immediately from the inode
 966         * it's easier to cheat and just decrement partial->p.
 967         */
 968        if (p == chain + k - 1 && p > chain) {
 969                p->p--;
 970        } else {
 971                *top = *p->p;
 972                *p->p = 0;
 973        }
 974        write_unlock(&EXT2_I(inode)->i_meta_lock);
 975
 976        while(partial > p)
 977        {
 978                brelse(partial->bh);
 979                partial--;
 980        }
 981no_top:
 982        return partial;
 983}
 984
 985/**
 986 *      ext2_free_data - free a list of data blocks
 987 *      @inode: inode we are dealing with
 988 *      @p:     array of block numbers
 989 *      @q:     points immediately past the end of array
 990 *
 991 *      We are freeing all blocks referred from that array (numbers are
 992 *      stored as little-endian 32-bit) and updating @inode->i_blocks
 993 *      appropriately.
 994 */
 995static inline void ext2_free_data(struct inode *inode, __le32 *p, __le32 *q)
 996{
 997        unsigned long block_to_free = 0, count = 0;
 998        unsigned long nr;
 999
1000        for ( ; p < q ; p++) {
1001                nr = le32_to_cpu(*p);
1002                if (nr) {
1003                        *p = 0;
1004                        /* accumulate blocks to free if they're contiguous */
1005                        if (count == 0)
1006                                goto free_this;
1007                        else if (block_to_free == nr - count)
1008                                count++;
1009                        else {
1010                                ext2_free_blocks (inode, block_to_free, count);
1011                                mark_inode_dirty(inode);
1012                        free_this:
1013                                block_to_free = nr;
1014                                count = 1;
1015                        }
1016                }
1017        }
1018        if (count > 0) {
1019                ext2_free_blocks (inode, block_to_free, count);
1020                mark_inode_dirty(inode);
1021        }
1022}
1023
1024/**
1025 *      ext2_free_branches - free an array of branches
1026 *      @inode: inode we are dealing with
1027 *      @p:     array of block numbers
1028 *      @q:     pointer immediately past the end of array
1029 *      @depth: depth of the branches to free
1030 *
1031 *      We are freeing all blocks referred from these branches (numbers are
1032 *      stored as little-endian 32-bit) and updating @inode->i_blocks
1033 *      appropriately.
1034 */
1035static void ext2_free_branches(struct inode *inode, __le32 *p, __le32 *q, int depth)
1036{
1037        struct buffer_head * bh;
1038        unsigned long nr;
1039
1040        if (depth--) {
1041                int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1042                for ( ; p < q ; p++) {
1043                        nr = le32_to_cpu(*p);
1044                        if (!nr)
1045                                continue;
1046                        *p = 0;
1047                        bh = sb_bread(inode->i_sb, nr);
1048                        /*
1049                         * A read failure? Report error and clear slot
1050                         * (should be rare).
1051                         */ 
1052                        if (!bh) {
1053                                ext2_error(inode->i_sb, "ext2_free_branches",
1054                                        "Read failure, inode=%ld, block=%ld",
1055                                        inode->i_ino, nr);
1056                                continue;
1057                        }
1058                        ext2_free_branches(inode,
1059                                           (__le32*)bh->b_data,
1060                                           (__le32*)bh->b_data + addr_per_block,
1061                                           depth);
1062                        bforget(bh);
1063                        ext2_free_blocks(inode, nr, 1);
1064                        mark_inode_dirty(inode);
1065                }
1066        } else
1067                ext2_free_data(inode, p, q);
1068}
1069
1070static void __ext2_truncate_blocks(struct inode *inode, loff_t offset)
1071{
1072        __le32 *i_data = EXT2_I(inode)->i_data;
1073        struct ext2_inode_info *ei = EXT2_I(inode);
1074        int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1075        int offsets[4];
1076        Indirect chain[4];
1077        Indirect *partial;
1078        __le32 nr = 0;
1079        int n;
1080        long iblock;
1081        unsigned blocksize;
1082        blocksize = inode->i_sb->s_blocksize;
1083        iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
1084
1085        n = ext2_block_to_path(inode, iblock, offsets, NULL);
1086        if (n == 0)
1087                return;
1088
1089        /*
1090         * From here we block out all ext2_get_block() callers who want to
1091         * modify the block allocation tree.
1092         */
1093        mutex_lock(&ei->truncate_mutex);
1094
1095        if (n == 1) {
1096                ext2_free_data(inode, i_data+offsets[0],
1097                                        i_data + EXT2_NDIR_BLOCKS);
1098                goto do_indirects;
1099        }
1100
1101        partial = ext2_find_shared(inode, n, offsets, chain, &nr);
1102        /* Kill the top of shared branch (already detached) */
1103        if (nr) {
1104                if (partial == chain)
1105                        mark_inode_dirty(inode);
1106                else
1107                        mark_buffer_dirty_inode(partial->bh, inode);
1108                ext2_free_branches(inode, &nr, &nr+1, (chain+n-1) - partial);
1109        }
1110        /* Clear the ends of indirect blocks on the shared branch */
1111        while (partial > chain) {
1112                ext2_free_branches(inode,
1113                                   partial->p + 1,
1114                                   (__le32*)partial->bh->b_data+addr_per_block,
1115                                   (chain+n-1) - partial);
1116                mark_buffer_dirty_inode(partial->bh, inode);
1117                brelse (partial->bh);
1118                partial--;
1119        }
1120do_indirects:
1121        /* Kill the remaining (whole) subtrees */
1122        switch (offsets[0]) {
1123                default:
1124                        nr = i_data[EXT2_IND_BLOCK];
1125                        if (nr) {
1126                                i_data[EXT2_IND_BLOCK] = 0;
1127                                mark_inode_dirty(inode);
1128                                ext2_free_branches(inode, &nr, &nr+1, 1);
1129                        }
1130                case EXT2_IND_BLOCK:
1131                        nr = i_data[EXT2_DIND_BLOCK];
1132                        if (nr) {
1133                                i_data[EXT2_DIND_BLOCK] = 0;
1134                                mark_inode_dirty(inode);
1135                                ext2_free_branches(inode, &nr, &nr+1, 2);
1136                        }
1137                case EXT2_DIND_BLOCK:
1138                        nr = i_data[EXT2_TIND_BLOCK];
1139                        if (nr) {
1140                                i_data[EXT2_TIND_BLOCK] = 0;
1141                                mark_inode_dirty(inode);
1142                                ext2_free_branches(inode, &nr, &nr+1, 3);
1143                        }
1144                case EXT2_TIND_BLOCK:
1145                        ;
1146        }
1147
1148        ext2_discard_reservation(inode);
1149
1150        mutex_unlock(&ei->truncate_mutex);
1151}
1152
1153static void ext2_truncate_blocks(struct inode *inode, loff_t offset)
1154{
1155        /*
1156         * XXX: it seems like a bug here that we don't allow
1157         * IS_APPEND inode to have blocks-past-i_size trimmed off.
1158         * review and fix this.
1159         *
1160         * Also would be nice to be able to handle IO errors and such,
1161         * but that's probably too much to ask.
1162         */
1163        if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1164            S_ISLNK(inode->i_mode)))
1165                return;
1166        if (ext2_inode_is_fast_symlink(inode))
1167                return;
1168        if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1169                return;
1170        __ext2_truncate_blocks(inode, offset);
1171}
1172
1173static int ext2_setsize(struct inode *inode, loff_t newsize)
1174{
1175        int error;
1176
1177        if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1178            S_ISLNK(inode->i_mode)))
1179                return -EINVAL;
1180        if (ext2_inode_is_fast_symlink(inode))
1181                return -EINVAL;
1182        if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1183                return -EPERM;
1184
1185        inode_dio_wait(inode);
1186
1187        if (mapping_is_xip(inode->i_mapping))
1188                error = xip_truncate_page(inode->i_mapping, newsize);
1189        else if (test_opt(inode->i_sb, NOBH))
1190                error = nobh_truncate_page(inode->i_mapping,
1191                                newsize, ext2_get_block);
1192        else
1193                error = block_truncate_page(inode->i_mapping,
1194                                newsize, ext2_get_block);
1195        if (error)
1196                return error;
1197
1198        truncate_setsize(inode, newsize);
1199        __ext2_truncate_blocks(inode, newsize);
1200
1201        inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
1202        if (inode_needs_sync(inode)) {
1203                sync_mapping_buffers(inode->i_mapping);
1204                sync_inode_metadata(inode, 1);
1205        } else {
1206                mark_inode_dirty(inode);
1207        }
1208
1209        return 0;
1210}
1211
1212static struct ext2_inode *ext2_get_inode(struct super_block *sb, ino_t ino,
1213                                        struct buffer_head **p)
1214{
1215        struct buffer_head * bh;
1216        unsigned long block_group;
1217        unsigned long block;
1218        unsigned long offset;
1219        struct ext2_group_desc * gdp;
1220
1221        *p = NULL;
1222        if ((ino != EXT2_ROOT_INO && ino < EXT2_FIRST_INO(sb)) ||
1223            ino > le32_to_cpu(EXT2_SB(sb)->s_es->s_inodes_count))
1224                goto Einval;
1225
1226        block_group = (ino - 1) / EXT2_INODES_PER_GROUP(sb);
1227        gdp = ext2_get_group_desc(sb, block_group, NULL);
1228        if (!gdp)
1229                goto Egdp;
1230        /*
1231         * Figure out the offset within the block group inode table
1232         */
1233        offset = ((ino - 1) % EXT2_INODES_PER_GROUP(sb)) * EXT2_INODE_SIZE(sb);
1234        block = le32_to_cpu(gdp->bg_inode_table) +
1235                (offset >> EXT2_BLOCK_SIZE_BITS(sb));
1236        if (!(bh = sb_bread(sb, block)))
1237                goto Eio;
1238
1239        *p = bh;
1240        offset &= (EXT2_BLOCK_SIZE(sb) - 1);
1241        return (struct ext2_inode *) (bh->b_data + offset);
1242
1243Einval:
1244        ext2_error(sb, "ext2_get_inode", "bad inode number: %lu",
1245                   (unsigned long) ino);
1246        return ERR_PTR(-EINVAL);
1247Eio:
1248        ext2_error(sb, "ext2_get_inode",
1249                   "unable to read inode block - inode=%lu, block=%lu",
1250                   (unsigned long) ino, block);
1251Egdp:
1252        return ERR_PTR(-EIO);
1253}
1254
1255void ext2_set_inode_flags(struct inode *inode)
1256{
1257        unsigned int flags = EXT2_I(inode)->i_flags;
1258
1259        inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
1260        if (flags & EXT2_SYNC_FL)
1261                inode->i_flags |= S_SYNC;
1262        if (flags & EXT2_APPEND_FL)
1263                inode->i_flags |= S_APPEND;
1264        if (flags & EXT2_IMMUTABLE_FL)
1265                inode->i_flags |= S_IMMUTABLE;
1266        if (flags & EXT2_NOATIME_FL)
1267                inode->i_flags |= S_NOATIME;
1268        if (flags & EXT2_DIRSYNC_FL)
1269                inode->i_flags |= S_DIRSYNC;
1270}
1271
1272/* Propagate flags from i_flags to EXT2_I(inode)->i_flags */
1273void ext2_get_inode_flags(struct ext2_inode_info *ei)
1274{
1275        unsigned int flags = ei->vfs_inode.i_flags;
1276
1277        ei->i_flags &= ~(EXT2_SYNC_FL|EXT2_APPEND_FL|
1278                        EXT2_IMMUTABLE_FL|EXT2_NOATIME_FL|EXT2_DIRSYNC_FL);
1279        if (flags & S_SYNC)
1280                ei->i_flags |= EXT2_SYNC_FL;
1281        if (flags & S_APPEND)
1282                ei->i_flags |= EXT2_APPEND_FL;
1283        if (flags & S_IMMUTABLE)
1284                ei->i_flags |= EXT2_IMMUTABLE_FL;
1285        if (flags & S_NOATIME)
1286                ei->i_flags |= EXT2_NOATIME_FL;
1287        if (flags & S_DIRSYNC)
1288                ei->i_flags |= EXT2_DIRSYNC_FL;
1289}
1290
1291struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
1292{
1293        struct ext2_inode_info *ei;
1294        struct buffer_head * bh;
1295        struct ext2_inode *raw_inode;
1296        struct inode *inode;
1297        long ret = -EIO;
1298        int n;
1299        uid_t i_uid;
1300        gid_t i_gid;
1301
1302        inode = iget_locked(sb, ino);
1303        if (!inode)
1304                return ERR_PTR(-ENOMEM);
1305        if (!(inode->i_state & I_NEW))
1306                return inode;
1307
1308        ei = EXT2_I(inode);
1309        ei->i_block_alloc_info = NULL;
1310
1311        raw_inode = ext2_get_inode(inode->i_sb, ino, &bh);
1312        if (IS_ERR(raw_inode)) {
1313                ret = PTR_ERR(raw_inode);
1314                goto bad_inode;
1315        }
1316
1317        inode->i_mode = le16_to_cpu(raw_inode->i_mode);
1318        i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
1319        i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
1320        if (!(test_opt (inode->i_sb, NO_UID32))) {
1321                i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
1322                i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
1323        }
1324        i_uid_write(inode, i_uid);
1325        i_gid_write(inode, i_gid);
1326        set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
1327        inode->i_size = le32_to_cpu(raw_inode->i_size);
1328        inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
1329        inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
1330        inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
1331        inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = 0;
1332        ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
1333        /* We now have enough fields to check if the inode was active or not.
1334         * This is needed because nfsd might try to access dead inodes
1335         * the test is that same one that e2fsck uses
1336         * NeilBrown 1999oct15
1337         */
1338        if (inode->i_nlink == 0 && (inode->i_mode == 0 || ei->i_dtime)) {
1339                /* this inode is deleted */
1340                brelse (bh);
1341                ret = -ESTALE;
1342                goto bad_inode;
1343        }
1344        inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
1345        ei->i_flags = le32_to_cpu(raw_inode->i_flags);
1346        ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
1347        ei->i_frag_no = raw_inode->i_frag;
1348        ei->i_frag_size = raw_inode->i_fsize;
1349        ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
1350        ei->i_dir_acl = 0;
1351        if (S_ISREG(inode->i_mode))
1352                inode->i_size |= ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
1353        else
1354                ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
1355        ei->i_dtime = 0;
1356        inode->i_generation = le32_to_cpu(raw_inode->i_generation);
1357        ei->i_state = 0;
1358        ei->i_block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
1359        ei->i_dir_start_lookup = 0;
1360
1361        /*
1362         * NOTE! The in-memory inode i_data array is in little-endian order
1363         * even on big-endian machines: we do NOT byteswap the block numbers!
1364         */
1365        for (n = 0; n < EXT2_N_BLOCKS; n++)
1366                ei->i_data[n] = raw_inode->i_block[n];
1367
1368        if (S_ISREG(inode->i_mode)) {
1369                inode->i_op = &ext2_file_inode_operations;
1370                if (ext2_use_xip(inode->i_sb)) {
1371                        inode->i_mapping->a_ops = &ext2_aops_xip;
1372                        inode->i_fop = &ext2_xip_file_operations;
1373                } else if (test_opt(inode->i_sb, NOBH)) {
1374                        inode->i_mapping->a_ops = &ext2_nobh_aops;
1375                        inode->i_fop = &ext2_file_operations;
1376                } else {
1377                        inode->i_mapping->a_ops = &ext2_aops;
1378                        inode->i_fop = &ext2_file_operations;
1379                }
1380        } else if (S_ISDIR(inode->i_mode)) {
1381                inode->i_op = &ext2_dir_inode_operations;
1382                inode->i_fop = &ext2_dir_operations;
1383                if (test_opt(inode->i_sb, NOBH))
1384                        inode->i_mapping->a_ops = &ext2_nobh_aops;
1385                else
1386                        inode->i_mapping->a_ops = &ext2_aops;
1387        } else if (S_ISLNK(inode->i_mode)) {
1388                if (ext2_inode_is_fast_symlink(inode)) {
1389                        inode->i_op = &ext2_fast_symlink_inode_operations;
1390                        nd_terminate_link(ei->i_data, inode->i_size,
1391                                sizeof(ei->i_data) - 1);
1392                } else {
1393                        inode->i_op = &ext2_symlink_inode_operations;
1394                        if (test_opt(inode->i_sb, NOBH))
1395                                inode->i_mapping->a_ops = &ext2_nobh_aops;
1396                        else
1397                                inode->i_mapping->a_ops = &ext2_aops;
1398                }
1399        } else {
1400                inode->i_op = &ext2_special_inode_operations;
1401                if (raw_inode->i_block[0])
1402                        init_special_inode(inode, inode->i_mode,
1403                           old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
1404                else 
1405                        init_special_inode(inode, inode->i_mode,
1406                           new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
1407        }
1408        brelse (bh);
1409        ext2_set_inode_flags(inode);
1410        unlock_new_inode(inode);
1411        return inode;
1412        
1413bad_inode:
1414        iget_failed(inode);
1415        return ERR_PTR(ret);
1416}
1417
1418static int __ext2_write_inode(struct inode *inode, int do_sync)
1419{
1420        struct ext2_inode_info *ei = EXT2_I(inode);
1421        struct super_block *sb = inode->i_sb;
1422        ino_t ino = inode->i_ino;
1423        uid_t uid = i_uid_read(inode);
1424        gid_t gid = i_gid_read(inode);
1425        struct buffer_head * bh;
1426        struct ext2_inode * raw_inode = ext2_get_inode(sb, ino, &bh);
1427        int n;
1428        int err = 0;
1429
1430        if (IS_ERR(raw_inode))
1431                return -EIO;
1432
1433        /* For fields not not tracking in the in-memory inode,
1434         * initialise them to zero for new inodes. */
1435        if (ei->i_state & EXT2_STATE_NEW)
1436                memset(raw_inode, 0, EXT2_SB(sb)->s_inode_size);
1437
1438        ext2_get_inode_flags(ei);
1439        raw_inode->i_mode = cpu_to_le16(inode->i_mode);
1440        if (!(test_opt(sb, NO_UID32))) {
1441                raw_inode->i_uid_low = cpu_to_le16(low_16_bits(uid));
1442                raw_inode->i_gid_low = cpu_to_le16(low_16_bits(gid));
1443/*
1444 * Fix up interoperability with old kernels. Otherwise, old inodes get
1445 * re-used with the upper 16 bits of the uid/gid intact
1446 */
1447                if (!ei->i_dtime) {
1448                        raw_inode->i_uid_high = cpu_to_le16(high_16_bits(uid));
1449                        raw_inode->i_gid_high = cpu_to_le16(high_16_bits(gid));
1450                } else {
1451                        raw_inode->i_uid_high = 0;
1452                        raw_inode->i_gid_high = 0;
1453                }
1454        } else {
1455                raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(uid));
1456                raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(gid));
1457                raw_inode->i_uid_high = 0;
1458                raw_inode->i_gid_high = 0;
1459        }
1460        raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
1461        raw_inode->i_size = cpu_to_le32(inode->i_size);
1462        raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
1463        raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
1464        raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
1465
1466        raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
1467        raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
1468        raw_inode->i_flags = cpu_to_le32(ei->i_flags);
1469        raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
1470        raw_inode->i_frag = ei->i_frag_no;
1471        raw_inode->i_fsize = ei->i_frag_size;
1472        raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
1473        if (!S_ISREG(inode->i_mode))
1474                raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
1475        else {
1476                raw_inode->i_size_high = cpu_to_le32(inode->i_size >> 32);
1477                if (inode->i_size > 0x7fffffffULL) {
1478                        if (!EXT2_HAS_RO_COMPAT_FEATURE(sb,
1479                                        EXT2_FEATURE_RO_COMPAT_LARGE_FILE) ||
1480                            EXT2_SB(sb)->s_es->s_rev_level ==
1481                                        cpu_to_le32(EXT2_GOOD_OLD_REV)) {
1482                               /* If this is the first large file
1483                                * created, add a flag to the superblock.
1484                                */
1485                                spin_lock(&EXT2_SB(sb)->s_lock);
1486                                ext2_update_dynamic_rev(sb);
1487                                EXT2_SET_RO_COMPAT_FEATURE(sb,
1488                                        EXT2_FEATURE_RO_COMPAT_LARGE_FILE);
1489                                spin_unlock(&EXT2_SB(sb)->s_lock);
1490                                ext2_write_super(sb);
1491                        }
1492                }
1493        }
1494        
1495        raw_inode->i_generation = cpu_to_le32(inode->i_generation);
1496        if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1497                if (old_valid_dev(inode->i_rdev)) {
1498                        raw_inode->i_block[0] =
1499                                cpu_to_le32(old_encode_dev(inode->i_rdev));
1500                        raw_inode->i_block[1] = 0;
1501                } else {
1502                        raw_inode->i_block[0] = 0;
1503                        raw_inode->i_block[1] =
1504                                cpu_to_le32(new_encode_dev(inode->i_rdev));
1505                        raw_inode->i_block[2] = 0;
1506                }
1507        } else for (n = 0; n < EXT2_N_BLOCKS; n++)
1508                raw_inode->i_block[n] = ei->i_data[n];
1509        mark_buffer_dirty(bh);
1510        if (do_sync) {
1511                sync_dirty_buffer(bh);
1512                if (buffer_req(bh) && !buffer_uptodate(bh)) {
1513                        printk ("IO error syncing ext2 inode [%s:%08lx]\n",
1514                                sb->s_id, (unsigned long) ino);
1515                        err = -EIO;
1516                }
1517        }
1518        ei->i_state &= ~EXT2_STATE_NEW;
1519        brelse (bh);
1520        return err;
1521}
1522
1523int ext2_write_inode(struct inode *inode, struct writeback_control *wbc)
1524{
1525        return __ext2_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
1526}
1527
1528int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
1529{
1530        struct inode *inode = dentry->d_inode;
1531        int error;
1532
1533        error = inode_change_ok(inode, iattr);
1534        if (error)
1535                return error;
1536
1537        if (is_quota_modification(inode, iattr))
1538                dquot_initialize(inode);
1539        if ((iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) ||
1540            (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))) {
1541                error = dquot_transfer(inode, iattr);
1542                if (error)
1543                        return error;
1544        }
1545        if (iattr->ia_valid & ATTR_SIZE && iattr->ia_size != inode->i_size) {
1546                error = ext2_setsize(inode, iattr->ia_size);
1547                if (error)
1548                        return error;
1549        }
1550        setattr_copy(inode, iattr);
1551        if (iattr->ia_valid & ATTR_MODE)
1552                error = ext2_acl_chmod(inode);
1553        mark_inode_dirty(inode);
1554
1555        return error;
1556}
1557
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.