LCOV - code coverage report
Current view: top level - lkbce/fs/ext2 - inode.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 491 696 70.5 %
Date: 2017-01-25 Functions: 27 37 73.0 %

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

Generated by: LCOV version 1.10