8 files changed, 85 insertions, 95 deletions

diff --git a/fs/ext2/balloc.c b/fs/ext2/balloc.c
index e7b2bafa1dd9..10bb02c3f25c 100644
--- a/fs/ext2/balloc.c
+++ b/fs/ext2/balloc.c
@@ -106,7 +106,7 @@ static int ext2_valid_block_bitmap(struct super_block *sb,
                 return 1;
 
 err_out:
-        ext2_error(sb, __FUNCTION__,
+        ext2_error(sb, __func__,
                         "Invalid block bitmap - "
                         "block_group = %d, block = %lu",
                         block_group, bitmap_blk);
@@ -132,7 +132,7 @@ read_block_bitmap(struct super_block *sb, unsigned int block_group)
         bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
         bh = sb_getblk(sb, bitmap_blk);
         if (unlikely(!bh)) {
-                ext2_error(sb, __FUNCTION__,
+                ext2_error(sb, __func__,
                             "Cannot read block bitmap - "
                             "block_group = %d, block_bitmap = %u",
                             block_group, le32_to_cpu(desc->bg_block_bitmap));
@@ -143,17 +143,18 @@ read_block_bitmap(struct super_block *sb, unsigned int block_group)
 
         if (bh_submit_read(bh) < 0) {
                 brelse(bh);
-                ext2_error(sb, __FUNCTION__,
+                ext2_error(sb, __func__,
                             "Cannot read block bitmap - "
                             "block_group = %d, block_bitmap = %u",
                             block_group, le32_to_cpu(desc->bg_block_bitmap));
                 return NULL;
         }
-        if (!ext2_valid_block_bitmap(sb, desc, block_group, bh)) {
-                brelse(bh);
-                return NULL;
-        }
 
+        ext2_valid_block_bitmap(sb, desc, block_group, bh);
+        /*
+         * file system mounted not to panic on error, continue with corrupt
+         * bitmap
+         */
         return bh;
 }
 
@@ -245,11 +246,10 @@ restart:
                 prev = rsv;
         }
         printk("Window map complete.\n");
-        if (bad)
-                BUG();
+        BUG_ON(bad);
 }
 #define rsv_window_dump(root, verbose) \
-        __rsv_window_dump((root), (verbose), __FUNCTION__)
+        __rsv_window_dump((root), (verbose), __func__)
 #else
 #define rsv_window_dump(root, verbose) do {} while (0)
 #endif
@@ -548,7 +548,7 @@ do_more:
         for (i = 0, group_freed = 0; i < count; i++) {
                 if (!ext2_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
                                                 bit + i, bitmap_bh->b_data)) {
-                        ext2_error(sb, __FUNCTION__,
+                        ext2_error(sb, __func__,
                                 "bit already cleared for block %lu", block + i);
                 } else {
                         group_freed++;
@@ -1381,7 +1381,12 @@ allocated:
                             "Allocating block in system zone - "
                             "blocks from "E2FSBLK", length %lu",
                             ret_block, num);
-                goto out;
+                /*
+                 * ext2_try_to_allocate marked the blocks we allocated as in
+                 * use.  So we may want to selectively mark some of the blocks
+                 * as free
+                 */
+                goto retry_alloc;
         }
 
         performed_allocation = 1;
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 8dededd80fe2..a78c6b4af060 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -41,8 +41,8 @@ static inline __le16 ext2_rec_len_to_disk(unsigned len)
 {
         if (len == (1 << 16))
                 return cpu_to_le16(EXT2_MAX_REC_LEN);
-        else if (len > (1 << 16))
-                BUG();
+        else
+                BUG_ON(len > (1 << 16));
         return cpu_to_le16(len);
 }
 
@@ -295,11 +295,11 @@ ext2_readdir (struct file * filp, void * dirent, filldir_t filldir)
                 struct page *page = ext2_get_page(inode, n);
 
                 if (IS_ERR(page)) {
-                        ext2_error(sb, __FUNCTION__,
+                        ext2_error(sb, __func__,
                                    "bad page in #%lu",
                                    inode->i_ino);
                         filp->f_pos += PAGE_CACHE_SIZE - offset;
-                        return -EIO;
+                        return PTR_ERR(page);
                 }
                 kaddr = page_address(page);
                 if (unlikely(need_revalidate)) {
@@ -314,7 +314,7 @@ ext2_readdir (struct file * filp, void * dirent, filldir_t filldir)
                 limit = kaddr + ext2_last_byte(inode, n) - EXT2_DIR_REC_LEN(1);
                 for ( ;(char*)de <= limit; de = ext2_next_entry(de)) {
                         if (de->rec_len == 0) {
-                                ext2_error(sb, __FUNCTION__,
+                                ext2_error(sb, __func__,
                                         "zero-length directory entry");
                                 ext2_put_page(page);
                                 return -EIO;
@@ -381,7 +381,7 @@ struct ext2_dir_entry_2 * ext2_find_entry (struct inode * dir,
                         kaddr += ext2_last_byte(dir, n) - reclen;
                         while ((char *) de <= kaddr) {
                                 if (de->rec_len == 0) {
-                                        ext2_error(dir->i_sb, __FUNCTION__,
+                                        ext2_error(dir->i_sb, __func__,
                                                 "zero-length directory entry");
                                         ext2_put_page(page);
                                         goto out;
@@ -396,7 +396,7 @@ struct ext2_dir_entry_2 * ext2_find_entry (struct inode * dir,
                         n = 0;
                 /* next page is past the blocks we've got */
                 if (unlikely(n > (dir->i_blocks >> (PAGE_CACHE_SHIFT - 9)))) {
-                        ext2_error(dir->i_sb, __FUNCTION__,
+                        ext2_error(dir->i_sb, __func__,
                                 "dir %lu size %lld exceeds block count %llu",
                                 dir->i_ino, dir->i_size,
                                 (unsigned long long)dir->i_blocks);
@@ -506,7 +506,7 @@ int ext2_add_link (struct dentry *dentry, struct inode *inode)
                                 goto got_it;
                         }
                         if (de->rec_len == 0) {
-                                ext2_error(dir->i_sb, __FUNCTION__,
+                                ext2_error(dir->i_sb, __func__,
                                         "zero-length directory entry");
                                 err = -EIO;
                                 goto out_unlock;
@@ -578,7 +578,7 @@ int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
 
         while ((char*)de < (char*)dir) {
                 if (de->rec_len == 0) {
-                        ext2_error(inode->i_sb, __FUNCTION__,
+                        ext2_error(inode->i_sb, __func__,
                                 "zero-length directory entry");
                         err = -EIO;
                         goto out;
@@ -670,7 +670,7 @@ int ext2_empty_dir (struct inode * inode)
 
                 while ((char *)de <= kaddr) {
                         if (de->rec_len == 0) {
-                                ext2_error(inode->i_sb, __FUNCTION__,
+                                ext2_error(inode->i_sb, __func__,
                                         "zero-length directory entry");
                                 printk("kaddr=%p, de=%p\n", kaddr, de);
                                 goto not_empty;
diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index 08f647d8188d..f59741346760 100644
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -75,11 +75,9 @@ static void ext2_release_inode(struct super_block *sb, int group, int dir)
         }
 
         spin_lock(sb_bgl_lock(EXT2_SB(sb), group));
-        desc->bg_free_inodes_count =
-                cpu_to_le16(le16_to_cpu(desc->bg_free_inodes_count) + 1);
+        le16_add_cpu(&desc->bg_free_inodes_count, 1);
         if (dir)
-                desc->bg_used_dirs_count =
-                        cpu_to_le16(le16_to_cpu(desc->bg_used_dirs_count) - 1);
+                le16_add_cpu(&desc->bg_used_dirs_count, -1);
         spin_unlock(sb_bgl_lock(EXT2_SB(sb), group));
         if (dir)
                 percpu_counter_dec(&EXT2_SB(sb)->s_dirs_counter);
@@ -539,13 +537,11 @@ got:
                 percpu_counter_inc(&sbi->s_dirs_counter);
 
         spin_lock(sb_bgl_lock(sbi, group));
-        gdp->bg_free_inodes_count =
-                cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);
+        le16_add_cpu(&gdp->bg_free_inodes_count, -1);
         if (S_ISDIR(mode)) {
                 if (sbi->s_debts[group] < 255)
                         sbi->s_debts[group]++;
-                gdp->bg_used_dirs_count =
-                        cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);
+                le16_add_cpu(&gdp->bg_used_dirs_count, 1);
         } else {
                 if (sbi->s_debts[group])
                         sbi->s_debts[group]--;
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index b8a2990bab83..384fc0d1dd74 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -254,13 +254,13 @@ no_block:
  *      Caller must make sure that @ind is valid and will stay that way.
  */
 
-static unsigned long ext2_find_near(struct inode *inode, Indirect *ind)
+static ext2_fsblk_t ext2_find_near(struct inode *inode, Indirect *ind)
 {
         struct ext2_inode_info *ei = EXT2_I(inode);
         __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
         __le32 *p;
-        unsigned long bg_start;
-        unsigned long colour;
+        ext2_fsblk_t bg_start;
+        ext2_fsblk_t colour;
 
         /* Try to find previous block */
         for (p = ind->p - 1; p >= start; p--)
@@ -275,8 +275,7 @@ static unsigned long ext2_find_near(struct inode *inode, Indirect *ind)
          * It is going to be refered from inode itself? OK, just put it into
          * the same cylinder group then.
          */
-        bg_start = (ei->i_block_group * EXT2_BLOCKS_PER_GROUP(inode->i_sb)) +
-                le32_to_cpu(EXT2_SB(inode->i_sb)->s_es->s_first_data_block);
+        bg_start = ext2_group_first_block_no(inode->i_sb, ei->i_block_group);
         colour = (current->pid % 16) *
                         (EXT2_BLOCKS_PER_GROUP(inode->i_sb) / 16);
         return bg_start + colour;
@@ -291,8 +290,8 @@ static unsigned long ext2_find_near(struct inode *inode, Indirect *ind)
  *      Returns preferred place for a block (the goal).
  */
 
-static inline int ext2_find_goal(struct inode *inode, long block,
-                                 Indirect *partial)
+static inline ext2_fsblk_t ext2_find_goal(struct inode *inode, long block,
+                                          Indirect *partial)
 {
         struct ext2_block_alloc_info *block_i;
 
@@ -796,7 +795,7 @@ const struct address_space_operations ext2_aops = {
 
 const struct address_space_operations ext2_aops_xip = {
         .bmap                   = ext2_bmap,
-        .get_xip_page           = ext2_get_xip_page,
+        .get_xip_mem            = ext2_get_xip_mem,
 };
 
 const struct address_space_operations ext2_nobh_aops = {
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 088b011bb97e..ef50cbc792db 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -51,8 +51,7 @@ void ext2_error (struct super_block * sb, const char * function,
 
         if (!(sb->s_flags & MS_RDONLY)) {
                 sbi->s_mount_state |= EXT2_ERROR_FS;
-                es->s_state =
-                        cpu_to_le16(le16_to_cpu(es->s_state) | EXT2_ERROR_FS);
+                es->s_state |= cpu_to_le16(EXT2_ERROR_FS);
                 ext2_sync_super(sb, es);
         }
 
@@ -90,7 +89,7 @@ void ext2_update_dynamic_rev(struct super_block *sb)
         if (le32_to_cpu(es->s_rev_level) > EXT2_GOOD_OLD_REV)
                 return;
 
-        ext2_warning(sb, __FUNCTION__,
+        ext2_warning(sb, __func__,
                      "updating to rev %d because of new feature flag, "
                      "running e2fsck is recommended",
                      EXT2_DYNAMIC_REV);
@@ -604,7 +603,7 @@ static int ext2_setup_super (struct super_block * sb,
                         "running e2fsck is recommended\n");
         if (!le16_to_cpu(es->s_max_mnt_count))
                 es->s_max_mnt_count = cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);
-        es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
+        le16_add_cpu(&es->s_mnt_count, 1);
         ext2_write_super(sb);
         if (test_opt (sb, DEBUG))
                 printk ("[EXT II FS %s, %s, bs=%lu, fs=%lu, gc=%lu, "
@@ -622,13 +621,13 @@ static int ext2_check_descriptors(struct super_block *sb)
 {
         int i;
         struct ext2_sb_info *sbi = EXT2_SB(sb);
-        unsigned long first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
-        unsigned long last_block;
 
         ext2_debug ("Checking group descriptors");
 
         for (i = 0; i < sbi->s_groups_count; i++) {
                 struct ext2_group_desc *gdp = ext2_get_group_desc(sb, i, NULL);
+                ext2_fsblk_t first_block = ext2_group_first_block_no(sb, i);
+                ext2_fsblk_t last_block;
 
                 if (i == sbi->s_groups_count - 1)
                         last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
@@ -664,7 +663,6 @@ static int ext2_check_descriptors(struct super_block *sb)
                                     i, (unsigned long) le32_to_cpu(gdp->bg_inode_table));
                         return 0;
                 }
-                first_block += EXT2_BLOCKS_PER_GROUP(sb);
         }
         return 1;
 }
@@ -721,10 +719,9 @@ static unsigned long descriptor_loc(struct super_block *sb,
                                     int nr)
 {
         struct ext2_sb_info *sbi = EXT2_SB(sb);
-        unsigned long bg, first_data_block, first_meta_bg;
+        unsigned long bg, first_meta_bg;
         int has_super = 0;
         
-        first_data_block = le32_to_cpu(sbi->s_es->s_first_data_block);
         first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
 
         if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_META_BG) ||
@@ -733,7 +730,8 @@ static unsigned long descriptor_loc(struct super_block *sb,
         bg = sbi->s_desc_per_block * nr;
         if (ext2_bg_has_super(sb, bg))
                 has_super = 1;
-        return (first_data_block + has_super + (bg * sbi->s_blocks_per_group));
+
+        return ext2_group_first_block_no(sb, bg) + has_super;
 }
 
 static int ext2_fill_super(struct super_block *sb, void *data, int silent)
@@ -1062,7 +1060,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
                 goto failed_mount3;
         }
         if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
-                ext2_warning(sb, __FUNCTION__,
+                ext2_warning(sb, __func__,
                         "mounting ext3 filesystem as ext2");
         ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);
         return 0;
@@ -1126,10 +1124,9 @@ void ext2_write_super (struct super_block * sb)
         if (!(sb->s_flags & MS_RDONLY)) {
                 es = EXT2_SB(sb)->s_es;
 
-                if (le16_to_cpu(es->s_state) & EXT2_VALID_FS) {
+                if (es->s_state & cpu_to_le16(EXT2_VALID_FS)) {
                         ext2_debug ("setting valid to 0\n");
-                        es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) &
-                                                  ~EXT2_VALID_FS);
+                        es->s_state &= cpu_to_le16(~EXT2_VALID_FS);
                         es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
                         es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
                         es->s_mtime = cpu_to_le32(get_seconds());
@@ -1180,7 +1177,7 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data)
         if (((sbi->s_mount_opt & EXT2_MOUNT_XIP) !=
             (old_mount_opt & EXT2_MOUNT_XIP)) &&
             invalidate_inodes(sb))
-                ext2_warning(sb, __FUNCTION__, "busy inodes while remounting "\
+                ext2_warning(sb, __func__, "busy inodes while remounting "\
                              "xip remain in cache (no functional problem)");
         if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
                 return 0;
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index a99d46f3b26e..987a5261cc2e 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -646,8 +646,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                                         unlock_buffer(new_bh);
                                         goto cleanup;
                                 }
-                                HDR(new_bh)->h_refcount = cpu_to_le32(1 +
-                                        le32_to_cpu(HDR(new_bh)->h_refcount));
+                                le32_add_cpu(&HDR(new_bh)->h_refcount, 1);
                                 ea_bdebug(new_bh, "refcount now=%d",
                                         le32_to_cpu(HDR(new_bh)->h_refcount));
                         }
@@ -660,10 +659,8 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                         ext2_xattr_cache_insert(new_bh);
                 } else {
                         /* We need to allocate a new block */
-                        int goal = le32_to_cpu(EXT2_SB(sb)->s_es->
-                                                           s_first_data_block) +
-                                   EXT2_I(inode)->i_block_group *
-                                   EXT2_BLOCKS_PER_GROUP(sb);
+                        ext2_fsblk_t goal = ext2_group_first_block_no(sb,
+                                                EXT2_I(inode)->i_block_group);
                         int block = ext2_new_block(inode, goal, &error);
                         if (error)
                                 goto cleanup;
@@ -731,8 +728,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                         bforget(old_bh);
                 } else {
                         /* Decrement the refcount only. */
-                        HDR(old_bh)->h_refcount = cpu_to_le32(
-                                le32_to_cpu(HDR(old_bh)->h_refcount) - 1);
+                        le32_add_cpu(&HDR(old_bh)->h_refcount, -1);
                         if (ce)
                                 mb_cache_entry_release(ce);
                         DQUOT_FREE_BLOCK(inode, 1);
@@ -789,8 +785,7 @@ ext2_xattr_delete_inode(struct inode *inode)
                 bforget(bh);
                 unlock_buffer(bh);
         } else {
-                HDR(bh)->h_refcount = cpu_to_le32(
-                        le32_to_cpu(HDR(bh)->h_refcount) - 1);
+                le32_add_cpu(&HDR(bh)->h_refcount, -1);
                 if (ce)
                         mb_cache_entry_release(ce);
                 ea_bdebug(bh, "refcount now=%d",
diff --git a/fs/ext2/xip.c b/fs/ext2/xip.c
index ca7f00312388..4fb94c20041b 100644
--- a/fs/ext2/xip.c
+++ b/fs/ext2/xip.c
@@ -15,24 +15,28 @@
 #include "xip.h"
 
 static inline int
-__inode_direct_access(struct inode *inode, sector_t sector,
-                      unsigned long *data)
+__inode_direct_access(struct inode *inode, sector_t block,
+                      void **kaddr, unsigned long *pfn)
 {
-        BUG_ON(!inode->i_sb->s_bdev->bd_disk->fops->direct_access);
-        return inode->i_sb->s_bdev->bd_disk->fops
-                ->direct_access(inode->i_sb->s_bdev,sector,data);
+        struct block_device *bdev = inode->i_sb->s_bdev;
+        struct block_device_operations *ops = bdev->bd_disk->fops;
+        sector_t sector;
+
+        sector = block * (PAGE_SIZE / 512); /* ext2 block to bdev sector */
+
+        BUG_ON(!ops->direct_access);
+        return ops->direct_access(bdev, sector, kaddr, pfn);
 }
 
 static inline int
-__ext2_get_sector(struct inode *inode, sector_t offset, int create,
+__ext2_get_block(struct inode *inode, pgoff_t pgoff, int create,
                    sector_t *result)
 {
         struct buffer_head tmp;
         int rc;
 
         memset(&tmp, 0, sizeof(struct buffer_head));
-        rc = ext2_get_block(inode, offset/ (PAGE_SIZE/512), &tmp,
-                            create);
+        rc = ext2_get_block(inode, pgoff, &tmp, create);
         *result = tmp.b_blocknr;
 
         /* did we get a sparse block (hole in the file)? */
@@ -45,15 +49,15 @@ __ext2_get_sector(struct inode *inode, sector_t offset, int create,
 }
 
 int
-ext2_clear_xip_target(struct inode *inode, int block)
+ext2_clear_xip_target(struct inode *inode, sector_t block)
 {
-        sector_t sector = block * (PAGE_SIZE/512);
-        unsigned long data;
+        void *kaddr;
+        unsigned long pfn;
         int rc;
 
-        rc = __inode_direct_access(inode, sector, &data);
+        rc = __inode_direct_access(inode, block, &kaddr, &pfn);
         if (!rc)
-                clear_page((void*)data);
+                clear_page(kaddr);
         return rc;
 }
 
@@ -64,30 +68,23 @@ void ext2_xip_verify_sb(struct super_block *sb)
         if ((sbi->s_mount_opt & EXT2_MOUNT_XIP) &&
             !sb->s_bdev->bd_disk->fops->direct_access) {
                 sbi->s_mount_opt &= (~EXT2_MOUNT_XIP);
-                ext2_warning(sb, __FUNCTION__,
+                ext2_warning(sb, __func__,
                              "ignoring xip option - not supported by bdev");
         }
 }
 
-struct page *
-ext2_get_xip_page(struct address_space *mapping, sector_t offset,
-                   int create)
+int ext2_get_xip_mem(struct address_space *mapping, pgoff_t pgoff, int create,
+                                void **kmem, unsigned long *pfn)
 {
         int rc;
-        unsigned long data;
-        sector_t sector;
+        sector_t block;
 
         /* first, retrieve the sector number */
-        rc = __ext2_get_sector(mapping->host, offset, create, &sector);
+        rc = __ext2_get_block(mapping->host, pgoff, create, &block);
         if (rc)
-                goto error;
+                return rc;
 
         /* retrieve address of the target data */
-        rc = __inode_direct_access
-                (mapping->host, sector * (PAGE_SIZE/512), &data);
-        if (!rc)
-                return virt_to_page(data);
-
- error:
-        return ERR_PTR(rc);
+        rc = __inode_direct_access(mapping->host, block, kmem, pfn);
+        return rc;
 }
diff --git a/fs/ext2/xip.h b/fs/ext2/xip.h
index aa85331d6c56..18b34d2f31b3 100644
--- a/fs/ext2/xip.h
+++ b/fs/ext2/xip.h
@@ -7,19 +7,20 @@
 
 #ifdef CONFIG_EXT2_FS_XIP
 extern void ext2_xip_verify_sb (struct super_block *);
-extern int ext2_clear_xip_target (struct inode *, int);
+extern int ext2_clear_xip_target (struct inode *, sector_t);
 
 static inline int ext2_use_xip (struct super_block *sb)
 {
         struct ext2_sb_info *sbi = EXT2_SB(sb);
         return (sbi->s_mount_opt & EXT2_MOUNT_XIP);
 }
-struct page* ext2_get_xip_page (struct address_space *, sector_t, int);
-#define mapping_is_xip(map) unlikely(map->a_ops->get_xip_page)
+int ext2_get_xip_mem(struct address_space *, pgoff_t, int,
+                                void **, unsigned long *);
+#define mapping_is_xip(map) unlikely(map->a_ops->get_xip_mem)
 #else
 #define mapping_is_xip(map)                     0
 #define ext2_xip_verify_sb(sb)                  do { } while (0)
 #define ext2_use_xip(sb)                        0
 #define ext2_clear_xip_target(inode, chain)     0
-#define ext2_get_xip_page                       NULL
+#define ext2_get_xip_mem                        NULL
 #endif