Merge git://git.linux-xtensa.org/kernel/xtensa-feed

[sfrench/cifs-2.6.git] / fs / ext4 / inode.c

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index fbff4b9e122a91781f84cef27db159b9b8534746..0bcf62a750ffe29f788b5eb9d1c9b209ec8d3f54 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -27,7 +27,6 @@
 #include <linux/time.h>
 #include <linux/ext4_jbd2.h>
 #include <linux/jbd2.h>
-#include <linux/smp_lock.h>
 #include <linux/highuid.h>
 #include <linux/pagemap.h>
 #include <linux/quotaops.h>
@@ -256,8 +255,8 @@ static int verify_chain(Indirect *from, Indirect *to)
  *     @inode: inode in question (we are only interested in its superblock)
  *     @i_block: block number to be parsed
  *     @offsets: array to store the offsets in
- *      @boundary: set this non-zero if the referred-to block is likely to be
- *             followed (on disk) by an indirect block.
+ *     @boundary: set this non-zero if the referred-to block is likely to be
+ *            followed (on disk) by an indirect block.
  *
  *     To store the locations of file's data ext4 uses a data structure common
  *     for UNIX filesystems - tree of pointers anchored in the inode, with
@@ -1147,102 +1146,37 @@ static int do_journal_get_write_access(handle_t *handle,
        return ext4_journal_get_write_access(handle, bh);
 }
 
-/*
- * The idea of this helper function is following:
- * if prepare_write has allocated some blocks, but not all of them, the
- * transaction must include the content of the newly allocated blocks.
- * This content is expected to be set to zeroes by block_prepare_write().
- * 2006/10/14  SAW
- */
-static int ext4_prepare_failure(struct file *file, struct page *page,
-                               unsigned from, unsigned to)
-{
-       struct address_space *mapping;
-       struct buffer_head *bh, *head, *next;
-       unsigned block_start, block_end;
-       unsigned blocksize;
-       int ret;
-       handle_t *handle = ext4_journal_current_handle();
-
-       mapping = page->mapping;
-       if (ext4_should_writeback_data(mapping->host)) {
-               /* optimization: no constraints about data */
-skip:
-               return ext4_journal_stop(handle);
-       }
-
-       head = page_buffers(page);
-       blocksize = head->b_size;
-       for (   bh = head, block_start = 0;
-               bh != head || !block_start;
-               block_start = block_end, bh = next)
-       {
-               next = bh->b_this_page;
-               block_end = block_start + blocksize;
-               if (block_end <= from)
-                       continue;
-               if (block_start >= to) {
-                       block_start = to;
-                       break;
-               }
-               if (!buffer_mapped(bh))
-               /* prepare_write failed on this bh */
-                       break;
-               if (ext4_should_journal_data(mapping->host)) {
-                       ret = do_journal_get_write_access(handle, bh);
-                       if (ret) {
-                               ext4_journal_stop(handle);
-                               return ret;
-                       }
-               }
-       /*
-        * block_start here becomes the first block where the current iteration
-        * of prepare_write failed.
-        */
-       }
-       if (block_start <= from)
-               goto skip;
-
-       /* commit allocated and zeroed buffers */
-       return mapping->a_ops->commit_write(file, page, from, block_start);
-}
-
 static int ext4_prepare_write(struct file *file, struct page *page,
                              unsigned from, unsigned to)
 {
        struct inode *inode = page->mapping->host;
-       int ret, ret2;
-       int needed_blocks = ext4_writepage_trans_blocks(inode);
+       int ret, needed_blocks = ext4_writepage_trans_blocks(inode);
        handle_t *handle;
        int retries = 0;
 
 retry:
        handle = ext4_journal_start(inode, needed_blocks);
-       if (IS_ERR(handle))
-               return PTR_ERR(handle);
+       if (IS_ERR(handle)) {
+               ret = PTR_ERR(handle);
+               goto out;
+       }
        if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode))
                ret = nobh_prepare_write(page, from, to, ext4_get_block);
        else
                ret = block_prepare_write(page, from, to, ext4_get_block);
        if (ret)
-               goto failure;
+               goto prepare_write_failed;
 
        if (ext4_should_journal_data(inode)) {
                ret = walk_page_buffers(handle, page_buffers(page),
                                from, to, NULL, do_journal_get_write_access);
-               if (ret)
-                       /* fatal error, just put the handle and return */
-                       ext4_journal_stop(handle);
        }
-       return ret;
-
-failure:
-       ret2 = ext4_prepare_failure(file, page, from, to);
-       if (ret2 < 0)
-               return ret2;
+prepare_write_failed:
+       if (ret)
+               ext4_journal_stop(handle);
        if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
                goto retry;
-       /* retry number exceeded, or other error like -EDQUOT */
+out:
        return ret;
 }
 
@@ -2676,9 +2610,9 @@ void ext4_read_inode(struct inode * inode)
        }
        inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
        inode->i_size = le32_to_cpu(raw_inode->i_size);
-       inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
-       inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
-       inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
+       inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
+       inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
+       inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
        inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
 
        ei->i_state = 0;