use-new-return-type-vm_fault_t

   1 ext4: use new return type vm_fault_t
   2
   3 From: Souptick Joarder <jrdr.linux@gmail.com>
   4
   5 Use new return type vm_fault_t for fault handler
   6 ext4_filemap_fault.
   7
   8 Signed-off-by: Souptick Joarder <jrdr.linux@gmail.com>
   9 Signed-off-by: Theodore Ts'o <tytso@mit.edu>
  10 ---
  11  fs/ext4/ext4.h              |  4 ++--
  12  fs/ext4/inode.c             | 28 ++++++++++++++--------------
  13  include/linux/buffer_head.h |  3 ++-
  14  3 files changed, 18 insertions(+), 17 deletions(-)
  15
  16 diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
  17 index 6d7dec48372b..21fb1964a672 100644
  18 --- a/fs/ext4/ext4.h
  19 +++ b/fs/ext4/ext4.h
  20 @@ -2468,8 +2468,8 @@ extern int ext4_writepage_trans_blocks(struct inode *);
  21  extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
  22  extern int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
  23                              loff_t lstart, loff_t lend);
  24 -extern int ext4_page_mkwrite(struct vm_fault *vmf);
  25 -extern int ext4_filemap_fault(struct vm_fault *vmf);
  26 +extern vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf);
  27 +extern vm_fault_t ext4_filemap_fault(struct vm_fault *vmf);
  28  extern qsize_t *ext4_get_reserved_space(struct inode *inode);
  29  extern int ext4_get_projid(struct inode *inode, kprojid_t *projid);
  30  extern void ext4_da_update_reserve_space(struct inode *inode,
  31 diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
  32 index ba0de19fb1ad..ef227862bf28 100644
  33 --- a/fs/ext4/inode.c
  34 +++ b/fs/ext4/inode.c
  35 @@ -6107,27 +6107,27 @@ static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
  36         return !buffer_mapped(bh);
  37  }
  38
  39 -int ext4_page_mkwrite(struct vm_fault *vmf)
  40 +vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
  41  {
  42         struct vm_area_struct *vma = vmf->vma;
  43         struct page *page = vmf->page;
  44         loff_t size;
  45         unsigned long len;
  46 -       int ret;
  47 +       vm_fault_t ret;
  48         struct file *file = vma->vm_file;
  49         struct inode *inode = file_inode(file);
  50         struct address_space *mapping = inode->i_mapping;
  51         handle_t *handle;
  52         get_block_t *get_block;
  53 -       int retries = 0;
  54 +       int retries = 0, err;
  55
  56         sb_start_pagefault(inode->i_sb);
  57         file_update_time(vma->vm_file);
  58
  59         down_read(&EXT4_I(inode)->i_mmap_sem);
  60
  61 -       ret = ext4_convert_inline_data(inode);
  62 -       if (ret)
  63 +       err = ext4_convert_inline_data(inode);
  64 +       if (err)
  65                 goto out_ret;
  66
  67         /* Delalloc case is easy... */
  68 @@ -6137,9 +6137,9 @@ int ext4_page_mkwrite(struct vm_fault *vmf)
  69                 do {
  70                         ret = block_page_mkwrite(vma, vmf,
  71                                                    ext4_da_get_block_prep);
  72 -               } while (ret == -ENOSPC &&
  73 +               } while (ret == VM_FAULT_SIGBUS &&
  74                        ext4_should_retry_alloc(inode->i_sb, &retries));
  75 -               goto out_ret;
  76 +               goto out;
  77         }
  78
  79         lock_page(page);
  80 @@ -6187,31 +6187,31 @@ int ext4_page_mkwrite(struct vm_fault *vmf)
  81                 if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
  82                           PAGE_SIZE, NULL, do_journal_get_write_access)) {
  83                         unlock_page(page);
  84 -                       ret = VM_FAULT_SIGBUS;
  85                         ext4_journal_stop(handle);
  86                         goto out;
  87                 }
  88                 ext4_set_inode_state(inode, EXT4_STATE_JDATA);
  89         }
  90         ext4_journal_stop(handle);
  91 -       if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
  92 +       if (ret == VM_FAULT_SIGBUS &&
  93 +               ext4_should_retry_alloc(inode->i_sb, &retries))
  94                 goto retry_alloc;
  95  out_ret:
  96 -       ret = block_page_mkwrite_return(ret);
  97 +       ret = block_page_mkwrite_return(err);
  98  out:
  99         up_read(&EXT4_I(inode)->i_mmap_sem);
 100         sb_end_pagefault(inode->i_sb);
 101         return ret;
 102  }
 103
 104 -int ext4_filemap_fault(struct vm_fault *vmf)
 105 +vm_fault_t ext4_filemap_fault(struct vm_fault *vmf)
 106  {
 107         struct inode *inode = file_inode(vmf->vma->vm_file);
 108 -       int err;
 109 +       vm_fault_t ret;
 110
 111         down_read(&EXT4_I(inode)->i_mmap_sem);
 112 -       err = filemap_fault(vmf);
 113 +       ret = filemap_fault(vmf);
 114         up_read(&EXT4_I(inode)->i_mmap_sem);
 115
 116 -       return err;
 117 +       return ret;
 118  }
 119 diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
 120 index 96225a77c112..ed7a81b8f7cc 100644
 121 --- a/include/linux/buffer_head.h
 122 +++ b/include/linux/buffer_head.h
 123 @@ -14,6 +14,7 @@
 124  #include <linux/pagemap.h>
 125  #include <linux/wait.h>
 126  #include <linux/atomic.h>
 127 +#include <linux/mm_types.h>
 128
 129  #ifdef CONFIG_BLOCK
 130
 131 @@ -242,7 +243,7 @@ int block_commit_write(struct page *page, unsigned from, unsigned to);
 132  int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
 133                                 get_block_t get_block);
 134  /* Convert errno to return value from ->page_mkwrite() call */
 135 -static inline int block_page_mkwrite_return(int err)
 136 +static inline vm_fault_t block_page_mkwrite_return(int err)
 137  {
 138         if (err == 0)
 139                 return VM_FAULT_LOCKED;