udf: cache struct udf_inode_info

cache UDF_I(struct inode *) return values when there are
at least 2 uses in one function

Signed-off-by: Marcin Slusarz <marcin.slusarz@gmail.com>
Acked-by: Jan Kara <jack@suse.cz>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 162 insertions, 143 deletions

diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index f746b9f1c03c..6b4409f50196 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -112,6 +112,7 @@ no_delete:
  */
 void udf_clear_inode(struct inode *inode)
 {
+        struct udf_inode_info *iinfo;
         if (!(inode->i_sb->s_flags & MS_RDONLY)) {
                 lock_kernel();
                 /* Discard preallocation for directories, symlinks, etc. */
@@ -120,8 +121,9 @@ void udf_clear_inode(struct inode *inode)
                 unlock_kernel();
                 write_inode_now(inode, 1);
         }
-        kfree(UDF_I(inode)->i_ext.i_data);
-        UDF_I(inode)->i_ext.i_data = NULL;
+        iinfo = UDF_I(inode);
+        kfree(iinfo->i_ext.i_data);
+        iinfo->i_ext.i_data = NULL;
 }
 
 static int udf_writepage(struct page *page, struct writeback_control *wbc)
@@ -161,6 +163,7 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
 {
         struct page *page;
         char *kaddr;
+        struct udf_inode_info *iinfo = UDF_I(inode);
         struct writeback_control udf_wbc = {
                 .sync_mode = WB_SYNC_NONE,
                 .nr_to_write = 1,
@@ -169,11 +172,11 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
         /* from now on we have normal address_space methods */
         inode->i_data.a_ops = &udf_aops;
 
-        if (!UDF_I(inode)->i_lenAlloc) {
+        if (!iinfo->i_lenAlloc) {
                 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
-                        UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
+                        iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
                 else
-                        UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG;
+                        iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
                 mark_inode_dirty(inode);
                 return;
         }
@@ -183,21 +186,21 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
 
         if (!PageUptodate(page)) {
                 kaddr = kmap(page);
-                memset(kaddr + UDF_I(inode)->i_lenAlloc, 0x00,
-                       PAGE_CACHE_SIZE - UDF_I(inode)->i_lenAlloc);
-                memcpy(kaddr, UDF_I(inode)->i_ext.i_data +
-                        UDF_I(inode)->i_lenEAttr, UDF_I(inode)->i_lenAlloc);
+                memset(kaddr + iinfo->i_lenAlloc, 0x00,
+                       PAGE_CACHE_SIZE - iinfo->i_lenAlloc);
+                memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr,
+                        iinfo->i_lenAlloc);
                 flush_dcache_page(page);
                 SetPageUptodate(page);
                 kunmap(page);
         }
-        memset(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, 0x00,
-               UDF_I(inode)->i_lenAlloc);
-        UDF_I(inode)->i_lenAlloc = 0;
+        memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00,
+               iinfo->i_lenAlloc);
+        iinfo->i_lenAlloc = 0;
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
-                UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
         else
-                UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG;
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
 
         inode->i_data.a_ops->writepage(page, &udf_wbc);
         page_cache_release(page);
@@ -219,6 +222,7 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
         loff_t f_pos = udf_ext0_offset(inode) >> 2;
         int size = (udf_ext0_offset(inode) + inode->i_size) >> 2;
         struct fileIdentDesc cfi, *sfi, *dfi;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
                 alloctype = ICBTAG_FLAG_AD_SHORT;
@@ -226,19 +230,19 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
                 alloctype = ICBTAG_FLAG_AD_LONG;
 
         if (!inode->i_size) {
-                UDF_I(inode)->i_alloc_type = alloctype;
+                iinfo->i_alloc_type = alloctype;
                 mark_inode_dirty(inode);
                 return NULL;
         }
 
         /* alloc block, and copy data to it */
         *block = udf_new_block(inode->i_sb, inode,
-                               UDF_I(inode)->i_location.partitionReferenceNum,
-                               UDF_I(inode)->i_location.logicalBlockNum, err);
+                               iinfo->i_location.partitionReferenceNum,
+                               iinfo->i_location.logicalBlockNum, err);
         if (!(*block))
                 return NULL;
         newblock = udf_get_pblock(inode->i_sb, *block,
-                                UDF_I(inode)->i_location.partitionReferenceNum,
+                                  iinfo->i_location.partitionReferenceNum,
                                 0);
         if (!newblock)
                 return NULL;
@@ -257,14 +261,14 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
         dfibh.soffset = dfibh.eoffset = 0;
         dfibh.sbh = dfibh.ebh = dbh;
         while ((f_pos < size)) {
-                UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
                 sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
                                          NULL, NULL, NULL);
                 if (!sfi) {
                         brelse(dbh);
                         return NULL;
                 }
-                UDF_I(inode)->i_alloc_type = alloctype;
+                iinfo->i_alloc_type = alloctype;
                 sfi->descTag.tagLocation = cpu_to_le32(*block);
                 dfibh.soffset = dfibh.eoffset;
                 dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
@@ -272,23 +276,23 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
                 if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
                                  sfi->fileIdent +
                                         le16_to_cpu(sfi->lengthOfImpUse))) {
-                        UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
+                        iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
                         brelse(dbh);
                         return NULL;
                 }
         }
         mark_buffer_dirty_inode(dbh, inode);
 
-        memset(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, 0,
-                UDF_I(inode)->i_lenAlloc);
-        UDF_I(inode)->i_lenAlloc = 0;
+        memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0,
+                iinfo->i_lenAlloc);
+        iinfo->i_lenAlloc = 0;
         eloc.logicalBlockNum = *block;
         eloc.partitionReferenceNum =
-                                UDF_I(inode)->i_location.partitionReferenceNum;
+                                iinfo->i_location.partitionReferenceNum;
         elen = inode->i_size;
-        UDF_I(inode)->i_lenExtents = elen;
+        iinfo->i_lenExtents = elen;
         epos.bh = NULL;
-        epos.block = UDF_I(inode)->i_location;
+        epos.block = iinfo->i_location;
         epos.offset = udf_file_entry_alloc_offset(inode);
         udf_add_aext(inode, &epos, eloc, elen, 0);
         /* UniqueID stuff */
@@ -304,6 +308,7 @@ static int udf_get_block(struct inode *inode, sector_t block,
         int err, new;
         struct buffer_head *bh;
         unsigned long phys;
+        struct udf_inode_info *iinfo;
 
         if (!create) {
                 phys = udf_block_map(inode, block);
@@ -321,9 +326,10 @@ static int udf_get_block(struct inode *inode, sector_t block,
         if (block < 0)
                 goto abort_negative;
 
-        if (block == UDF_I(inode)->i_next_alloc_block + 1) {
-                UDF_I(inode)->i_next_alloc_block++;
-                UDF_I(inode)->i_next_alloc_goal++;
+        iinfo = UDF_I(inode);
+        if (block == iinfo->i_next_alloc_block + 1) {
+                iinfo->i_next_alloc_block++;
+                iinfo->i_next_alloc_goal++;
         }
 
         err = 0;
@@ -380,20 +386,22 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
         struct super_block *sb = inode->i_sb;
         kernel_lb_addr prealloc_loc = {};
         int prealloc_len = 0;
+        struct udf_inode_info *iinfo;
 
         /* The previous extent is fake and we should not extend by anything
          * - there's nothing to do... */
         if (!blocks && fake)
                 return 0;
 
+        iinfo = UDF_I(inode);
         /* Round the last extent up to a multiple of block size */
         if (last_ext->extLength & (sb->s_blocksize - 1)) {
                 last_ext->extLength =
                         (last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
                         (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
                           sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
-                UDF_I(inode)->i_lenExtents =
-                        (UDF_I(inode)->i_lenExtents + sb->s_blocksize - 1) &
+                iinfo->i_lenExtents =
+                        (iinfo->i_lenExtents + sb->s_blocksize - 1) &
                         ~(sb->s_blocksize - 1);
         }
 
@@ -470,9 +478,9 @@ out:
         }
 
         /* last_pos should point to the last written extent... */
-        if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 last_pos->offset -= sizeof(short_ad);
-        else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 last_pos->offset -= sizeof(long_ad);
         else
                 return -1;
@@ -495,11 +503,12 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         uint32_t newblocknum, newblock;
         sector_t offset = 0;
         int8_t etype;
-        int goal = 0, pgoal = UDF_I(inode)->i_location.logicalBlockNum;
+        struct udf_inode_info *iinfo = UDF_I(inode);
+        int goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
         int lastblock = 0;
 
         prev_epos.offset = udf_file_entry_alloc_offset(inode);
-        prev_epos.block = UDF_I(inode)->i_location;
+        prev_epos.block = iinfo->i_location;
         prev_epos.bh = NULL;
         cur_epos = next_epos = prev_epos;
         b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
@@ -649,24 +658,23 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
                 newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
         else { /* otherwise, allocate a new block */
-                if (UDF_I(inode)->i_next_alloc_block == block)
-                        goal = UDF_I(inode)->i_next_alloc_goal;
+                if (iinfo->i_next_alloc_block == block)
+                        goal = iinfo->i_next_alloc_goal;
 
                 if (!goal) {
                         if (!(goal = pgoal)) /* XXX: what was intended here? */
-                                goal = UDF_I(inode)->
-                                                i_location.logicalBlockNum + 1;
+                                goal = iinfo->i_location.logicalBlockNum + 1;
                 }
 
                 newblocknum = udf_new_block(inode->i_sb, inode,
-                                UDF_I(inode)->i_location.partitionReferenceNum,
+                                iinfo->i_location.partitionReferenceNum,
                                 goal, err);
                 if (!newblocknum) {
                         brelse(prev_epos.bh);
                         *err = -ENOSPC;
                         return NULL;
                 }
-                UDF_I(inode)->i_lenExtents += inode->i_sb->s_blocksize;
+                iinfo->i_lenExtents += inode->i_sb->s_blocksize;
         }
 
         /* if the extent the requsted block is located in contains multiple
@@ -691,14 +699,14 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         brelse(prev_epos.bh);
 
         newblock = udf_get_pblock(inode->i_sb, newblocknum,
-                        UDF_I(inode)->i_location.partitionReferenceNum, 0);
+                                iinfo->i_location.partitionReferenceNum, 0);
         if (!newblock)
                 return NULL;
         *phys = newblock;
         *err = 0;
         *new = 1;
-        UDF_I(inode)->i_next_alloc_block = block;
-        UDF_I(inode)->i_next_alloc_goal = newblocknum;
+        iinfo->i_next_alloc_block = block;
+        iinfo->i_next_alloc_goal = newblocknum;
         inode->i_ctime = current_fs_time(inode->i_sb);
 
         if (IS_SYNC(inode))
@@ -1027,6 +1035,7 @@ void udf_truncate(struct inode *inode)
 {
         int offset;
         int err;
+        struct udf_inode_info *iinfo;
 
         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
               S_ISLNK(inode->i_mode)))
@@ -1035,25 +1044,24 @@ void udf_truncate(struct inode *inode)
                 return;
 
         lock_kernel();
-        if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+        iinfo = UDF_I(inode);
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
                 if (inode->i_sb->s_blocksize <
                                 (udf_file_entry_alloc_offset(inode) +
                                  inode->i_size)) {
                         udf_expand_file_adinicb(inode, inode->i_size, &err);
-                        if (UDF_I(inode)->i_alloc_type ==
-                                                        ICBTAG_FLAG_AD_IN_ICB) {
-                                inode->i_size = UDF_I(inode)->i_lenAlloc;
+                        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+                                inode->i_size = iinfo->i_lenAlloc;
                                 unlock_kernel();
                                 return;
                         } else
                                 udf_truncate_extents(inode);
                 } else {
                         offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
-                        memset(UDF_I(inode)->i_ext.i_data +
-                                UDF_I(inode)->i_lenEAttr + offset,
+                        memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,
                                 0x00, inode->i_sb->s_blocksize -
                                 offset - udf_file_entry_alloc_offset(inode));
-                        UDF_I(inode)->i_lenAlloc = inode->i_size;
+                        iinfo->i_lenAlloc = inode->i_size;
                 }
         } else {
                 block_truncate_page(inode->i_mapping, inode->i_size,
@@ -1074,6 +1082,7 @@ static void __udf_read_inode(struct inode *inode)
         struct buffer_head *bh = NULL;
         struct fileEntry *fe;
         uint16_t ident;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         /*
          * Set defaults, but the inode is still incomplete!
@@ -1087,7 +1096,7 @@ static void __udf_read_inode(struct inode *inode)
          *      i_nlink = 1
          *      i_op = NULL;
          */
-        bh = udf_read_ptagged(inode->i_sb, UDF_I(inode)->i_location, 0, &ident);
+        bh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 0, &ident);
         if (!bh) {
                 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
                        inode->i_ino);
@@ -1110,7 +1119,7 @@ static void __udf_read_inode(struct inode *inode)
                 struct buffer_head *ibh = NULL, *nbh = NULL;
                 struct indirectEntry *ie;
 
-                ibh = udf_read_ptagged(inode->i_sb, UDF_I(inode)->i_location, 1,
+                ibh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 1,
                                         &ident);
                 if (ident == TAG_IDENT_IE) {
                         if (ibh) {
@@ -1124,7 +1133,7 @@ static void __udf_read_inode(struct inode *inode)
                                                             &ident))) {
                                         if (ident == TAG_IDENT_FE ||
                                             ident == TAG_IDENT_EFE) {
-                                                memcpy(&UDF_I(inode)->i_location,
+                                                memcpy(&iinfo->i_location,
                                                        &loc,
                                                        sizeof(kernel_lb_addr));
                                                 brelse(bh);
@@ -1163,50 +1172,51 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         long convtime_usec;
         int offset;
         struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         fe = (struct fileEntry *)bh->b_data;
         efe = (struct extendedFileEntry *)bh->b_data;
 
         if (fe->icbTag.strategyType == cpu_to_le16(4))
-                UDF_I(inode)->i_strat4096 = 0;
+                iinfo->i_strat4096 = 0;
         else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
-                UDF_I(inode)->i_strat4096 = 1;
+                iinfo->i_strat4096 = 1;
 
-        UDF_I(inode)->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
+        iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
                                                         ICBTAG_FLAG_AD_MASK;
-        UDF_I(inode)->i_unique = 0;
-        UDF_I(inode)->i_lenEAttr = 0;
-        UDF_I(inode)->i_lenExtents = 0;
-        UDF_I(inode)->i_lenAlloc = 0;
-        UDF_I(inode)->i_next_alloc_block = 0;
-        UDF_I(inode)->i_next_alloc_goal = 0;
+        iinfo->i_unique = 0;
+        iinfo->i_lenEAttr = 0;
+        iinfo->i_lenExtents = 0;
+        iinfo->i_lenAlloc = 0;
+        iinfo->i_next_alloc_block = 0;
+        iinfo->i_next_alloc_goal = 0;
         if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
-                UDF_I(inode)->i_efe = 1;
-                UDF_I(inode)->i_use = 0;
+                iinfo->i_efe = 1;
+                iinfo->i_use = 0;
                 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
                                         sizeof(struct extendedFileEntry))) {
                         make_bad_inode(inode);
                         return;
                 }
-                memcpy(UDF_I(inode)->i_ext.i_data,
+                memcpy(iinfo->i_ext.i_data,
                        bh->b_data + sizeof(struct extendedFileEntry),
                        inode->i_sb->s_blocksize -
                                         sizeof(struct extendedFileEntry));
         } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
-                UDF_I(inode)->i_efe = 0;
-                UDF_I(inode)->i_use = 0;
+                iinfo->i_efe = 0;
+                iinfo->i_use = 0;
                 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
                                                 sizeof(struct fileEntry))) {
                         make_bad_inode(inode);
                         return;
                 }
-                memcpy(UDF_I(inode)->i_ext.i_data,
+                memcpy(iinfo->i_ext.i_data,
                        bh->b_data + sizeof(struct fileEntry),
                        inode->i_sb->s_blocksize - sizeof(struct fileEntry));
         } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
-                UDF_I(inode)->i_efe = 0;
-                UDF_I(inode)->i_use = 1;
-                UDF_I(inode)->i_lenAlloc = le32_to_cpu(
+                iinfo->i_efe = 0;
+                iinfo->i_use = 1;
+                iinfo->i_lenAlloc = le32_to_cpu(
                                 ((struct unallocSpaceEntry *)bh->b_data)->
                                  lengthAllocDescs);
                 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
@@ -1214,7 +1224,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         make_bad_inode(inode);
                         return;
                 }
-                memcpy(UDF_I(inode)->i_ext.i_data,
+                memcpy(iinfo->i_ext.i_data,
                        bh->b_data + sizeof(struct unallocSpaceEntry),
                        inode->i_sb->s_blocksize -
                                         sizeof(struct unallocSpaceEntry));
@@ -1238,12 +1248,12 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                 inode->i_nlink = 1;
 
         inode->i_size = le64_to_cpu(fe->informationLength);
-        UDF_I(inode)->i_lenExtents = inode->i_size;
+        iinfo->i_lenExtents = inode->i_size;
 
         inode->i_mode = udf_convert_permissions(fe);
         inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
 
-        if (UDF_I(inode)->i_efe == 0) {
+        if (iinfo->i_efe == 0) {
                 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
                         (inode->i_sb->s_blocksize_bits - 9);
 
@@ -1271,10 +1281,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         inode->i_ctime = sbi->s_record_time;
                 }
 
-                UDF_I(inode)->i_unique = le64_to_cpu(fe->uniqueID);
-                UDF_I(inode)->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
-                UDF_I(inode)->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
-                offset = sizeof(struct fileEntry) + UDF_I(inode)->i_lenEAttr;
+                iinfo->i_unique = le64_to_cpu(fe->uniqueID);
+                iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
+                iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
+                offset = sizeof(struct fileEntry) + iinfo->i_lenEAttr;
         } else {
                 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
                     (inode->i_sb->s_blocksize_bits - 9);
@@ -1297,10 +1307,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
 
                 if (udf_stamp_to_time(&convtime, &convtime_usec,
                                       lets_to_cpu(efe->createTime))) {
-                        UDF_I(inode)->i_crtime.tv_sec = convtime;
-                        UDF_I(inode)->i_crtime.tv_nsec = convtime_usec * 1000;
+                        iinfo->i_crtime.tv_sec = convtime;
+                        iinfo->i_crtime.tv_nsec = convtime_usec * 1000;
                 } else {
-                        UDF_I(inode)->i_crtime = sbi->s_record_time;
+                        iinfo->i_crtime = sbi->s_record_time;
                 }
 
                 if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1311,11 +1321,11 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         inode->i_ctime = sbi->s_record_time;
                 }
 
-                UDF_I(inode)->i_unique = le64_to_cpu(efe->uniqueID);
-                UDF_I(inode)->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
-                UDF_I(inode)->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
+                iinfo->i_unique = le64_to_cpu(efe->uniqueID);
+                iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
+                iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
                 offset = sizeof(struct extendedFileEntry) +
-                                                UDF_I(inode)->i_lenEAttr;
+                                                        iinfo->i_lenEAttr;
         }
 
         switch (fe->icbTag.fileType) {
@@ -1328,7 +1338,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         case ICBTAG_FILE_TYPE_REALTIME:
         case ICBTAG_FILE_TYPE_REGULAR:
         case ICBTAG_FILE_TYPE_UNDEF:
-                if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+                if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                         inode->i_data.a_ops = &udf_adinicb_aops;
                 else
                         inode->i_data.a_ops = &udf_aops;
@@ -1375,9 +1385,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
 
 static int udf_alloc_i_data(struct inode *inode, size_t size)
 {
-        UDF_I(inode)->i_ext.i_data = kmalloc(size, GFP_KERNEL);
+        struct udf_inode_info *iinfo = UDF_I(inode);
+        iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
 
-        if (!UDF_I(inode)->i_ext.i_data) {
+        if (!iinfo->i_ext.i_data) {
                 printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) "
                                 "no free memory\n", inode->i_ino);
                 return -ENOMEM;
@@ -1448,10 +1459,11 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         int err = 0;
         struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
         unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         bh = udf_tread(inode->i_sb,
                         udf_get_lb_pblock(inode->i_sb,
-                                          UDF_I(inode)->i_location, 0));
+                                          iinfo->i_location, 0));
         if (!bh) {
                 udf_debug("bread failure\n");
                 return -EIO;
@@ -1466,14 +1478,14 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 struct unallocSpaceEntry *use =
                         (struct unallocSpaceEntry *)bh->b_data;
 
-                use->lengthAllocDescs = cpu_to_le32(UDF_I(inode)->i_lenAlloc);
+                use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
                 memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
-                       UDF_I(inode)->i_ext.i_data, inode->i_sb->s_blocksize -
+                       iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
                                         sizeof(struct unallocSpaceEntry));
                 crclen = sizeof(struct unallocSpaceEntry) +
-                                UDF_I(inode)->i_lenAlloc - sizeof(tag);
+                                iinfo->i_lenAlloc - sizeof(tag);
                 use->descTag.tagLocation = cpu_to_le32(
-                                                UDF_I(inode)->i_location.
+                                                iinfo->i_location.
                                                         logicalBlockNum);
                 use->descTag.descCRCLength = cpu_to_le16(crclen);
                 use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use +
@@ -1538,9 +1550,9 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
         }
 
-        if (UDF_I(inode)->i_efe == 0) {
+        if (iinfo->i_efe == 0) {
                 memcpy(bh->b_data + sizeof(struct fileEntry),
-                       UDF_I(inode)->i_ext.i_data,
+                       iinfo->i_ext.i_data,
                        inode->i_sb->s_blocksize - sizeof(struct fileEntry));
                 fe->logicalBlocksRecorded = cpu_to_le64(
                         (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
@@ -1556,14 +1568,14 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
                 fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
                 fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
-                fe->uniqueID = cpu_to_le64(UDF_I(inode)->i_unique);
-                fe->lengthExtendedAttr = cpu_to_le32(UDF_I(inode)->i_lenEAttr);
-                fe->lengthAllocDescs = cpu_to_le32(UDF_I(inode)->i_lenAlloc);
+                fe->uniqueID = cpu_to_le64(iinfo->i_unique);
+                fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
+                fe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
                 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
                 crclen = sizeof(struct fileEntry);
         } else {
                 memcpy(bh->b_data + sizeof(struct extendedFileEntry),
-                       UDF_I(inode)->i_ext.i_data,
+                       iinfo->i_ext.i_data,
                        inode->i_sb->s_blocksize -
                                         sizeof(struct extendedFileEntry));
                 efe->objectSize = cpu_to_le64(inode->i_size);
@@ -1571,26 +1583,26 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                         (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
                         (blocksize_bits - 9));
 
-                if (UDF_I(inode)->i_crtime.tv_sec > inode->i_atime.tv_sec ||
-                    (UDF_I(inode)->i_crtime.tv_sec == inode->i_atime.tv_sec &&
-                     UDF_I(inode)->i_crtime.tv_nsec > inode->i_atime.tv_nsec))
-                        UDF_I(inode)->i_crtime = inode->i_atime;
+                if (iinfo->i_crtime.tv_sec > inode->i_atime.tv_sec ||
+                    (iinfo->i_crtime.tv_sec == inode->i_atime.tv_sec &&
+                     iinfo->i_crtime.tv_nsec > inode->i_atime.tv_nsec))
+                        iinfo->i_crtime = inode->i_atime;
 
-                if (UDF_I(inode)->i_crtime.tv_sec > inode->i_mtime.tv_sec ||
-                    (UDF_I(inode)->i_crtime.tv_sec == inode->i_mtime.tv_sec &&
-                     UDF_I(inode)->i_crtime.tv_nsec > inode->i_mtime.tv_nsec))
-                        UDF_I(inode)->i_crtime = inode->i_mtime;
+                if (iinfo->i_crtime.tv_sec > inode->i_mtime.tv_sec ||
+                    (iinfo->i_crtime.tv_sec == inode->i_mtime.tv_sec &&
+                     iinfo->i_crtime.tv_nsec > inode->i_mtime.tv_nsec))
+                        iinfo->i_crtime = inode->i_mtime;
 
-                if (UDF_I(inode)->i_crtime.tv_sec > inode->i_ctime.tv_sec ||
-                    (UDF_I(inode)->i_crtime.tv_sec == inode->i_ctime.tv_sec &&
-                     UDF_I(inode)->i_crtime.tv_nsec > inode->i_ctime.tv_nsec))
-                        UDF_I(inode)->i_crtime = inode->i_ctime;
+                if (iinfo->i_crtime.tv_sec > inode->i_ctime.tv_sec ||
+                    (iinfo->i_crtime.tv_sec == inode->i_ctime.tv_sec &&
+                     iinfo->i_crtime.tv_nsec > inode->i_ctime.tv_nsec))
+                        iinfo->i_crtime = inode->i_ctime;
 
                 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
                         efe->accessTime = cpu_to_lets(cpu_time);
                 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
                         efe->modificationTime = cpu_to_lets(cpu_time);
-                if (udf_time_to_stamp(&cpu_time, UDF_I(inode)->i_crtime))
+                if (udf_time_to_stamp(&cpu_time, iinfo->i_crtime))
                         efe->createTime = cpu_to_lets(cpu_time);
                 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
                         efe->attrTime = cpu_to_lets(cpu_time);
@@ -1599,13 +1611,13 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
                 efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
                 efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
-                efe->uniqueID = cpu_to_le64(UDF_I(inode)->i_unique);
-                efe->lengthExtendedAttr = cpu_to_le32(UDF_I(inode)->i_lenEAttr);
-                efe->lengthAllocDescs = cpu_to_le32(UDF_I(inode)->i_lenAlloc);
+                efe->uniqueID = cpu_to_le64(iinfo->i_unique);
+                efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
+                efe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
                 efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
                 crclen = sizeof(struct extendedFileEntry);
         }
-        if (UDF_I(inode)->i_strat4096) {
+        if (iinfo->i_strat4096) {
                 fe->icbTag.strategyType = cpu_to_le16(4096);
                 fe->icbTag.strategyParameter = cpu_to_le16(1);
                 fe->icbTag.numEntries = cpu_to_le16(2);
@@ -1629,7 +1641,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         else if (S_ISSOCK(inode->i_mode))
                 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;
 
-        icbflags =      UDF_I(inode)->i_alloc_type |
+        icbflags =      iinfo->i_alloc_type |
                         ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
                         ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
                         ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
@@ -1644,8 +1656,8 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 fe->descTag.descVersion = cpu_to_le16(2);
         fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
         fe->descTag.tagLocation = cpu_to_le32(
-                                      UDF_I(inode)->i_location.logicalBlockNum);
-        crclen += UDF_I(inode)->i_lenEAttr + UDF_I(inode)->i_lenAlloc -
+                                        iinfo->i_location.logicalBlockNum);
+        crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc -
                                                                 sizeof(tag);
         fe->descTag.descCRCLength = cpu_to_le16(crclen);
         fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag),
@@ -1709,17 +1721,18 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
         struct allocExtDesc *aed;
         int8_t etype;
         uint8_t *ptr;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         if (!epos->bh)
-                ptr = UDF_I(inode)->i_ext.i_data + epos->offset -
+                ptr = iinfo->i_ext.i_data + epos->offset -
                         udf_file_entry_alloc_offset(inode) +
-                        UDF_I(inode)->i_lenEAttr;
+                        iinfo->i_lenEAttr;
         else
                 ptr = epos->bh->b_data + epos->offset;
 
-        if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 return -1;
@@ -1769,7 +1782,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
                                         cpu_to_le32(le32_to_cpu(
                                         aed->lengthAllocDescs) + adsize);
                         } else {
-                                UDF_I(inode)->i_lenAlloc += adsize;
+                                iinfo->i_lenAlloc += adsize;
                                 mark_inode_dirty(inode);
                         }
                 }
@@ -1779,7 +1792,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
                 else
                         udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
                                     epos->block.logicalBlockNum, sizeof(tag));
-                switch (UDF_I(inode)->i_alloc_type) {
+                switch (iinfo->i_alloc_type) {
                 case ICBTAG_FLAG_AD_SHORT:
                         sad = (short_ad *)sptr;
                         sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
@@ -1813,7 +1826,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
         etype = udf_write_aext(inode, epos, eloc, elen, inc);
 
         if (!epos->bh) {
-                UDF_I(inode)->i_lenAlloc += adsize;
+                iinfo->i_lenAlloc += adsize;
                 mark_inode_dirty(inode);
         } else {
                 aed = (struct allocExtDesc *)epos->bh->b_data;
@@ -1840,15 +1853,16 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
         uint8_t *ptr;
         short_ad *sad;
         long_ad *lad;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         if (!epos->bh)
-                ptr = UDF_I(inode)->i_ext.i_data + epos->offset -
+                ptr = iinfo->i_ext.i_data + epos->offset -
                         udf_file_entry_alloc_offset(inode) +
-                        UDF_I(inode)->i_lenEAttr;
+                        iinfo->i_lenEAttr;
         else
                 ptr = epos->bh->b_data + epos->offset;
 
-        switch (UDF_I(inode)->i_alloc_type) {
+        switch (iinfo->i_alloc_type) {
         case ICBTAG_FLAG_AD_SHORT:
                 sad = (short_ad *)ptr;
                 sad->extLength = cpu_to_le32(elen);
@@ -1916,15 +1930,16 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
         uint8_t *ptr;
         short_ad *sad;
         long_ad *lad;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         if (!epos->bh) {
                 if (!epos->offset)
                         epos->offset = udf_file_entry_alloc_offset(inode);
-                ptr = UDF_I(inode)->i_ext.i_data + epos->offset -
+                ptr = iinfo->i_ext.i_data + epos->offset -
                         udf_file_entry_alloc_offset(inode) +
-                        UDF_I(inode)->i_lenEAttr;
+                        iinfo->i_lenEAttr;
                 alen = udf_file_entry_alloc_offset(inode) +
-                                                UDF_I(inode)->i_lenAlloc;
+                                                        iinfo->i_lenAlloc;
         } else {
                 if (!epos->offset)
                         epos->offset = sizeof(struct allocExtDesc);
@@ -1934,7 +1949,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
                                                         lengthAllocDescs);
         }
 
-        switch (UDF_I(inode)->i_alloc_type) {
+        switch (iinfo->i_alloc_type) {
         case ICBTAG_FLAG_AD_SHORT:
                 sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
                 if (!sad)
@@ -1942,7 +1957,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
                 etype = le32_to_cpu(sad->extLength) >> 30;
                 eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
                 eloc->partitionReferenceNum =
-                                UDF_I(inode)->i_location.partitionReferenceNum;
+                                iinfo->i_location.partitionReferenceNum;
                 *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
                 break;
         case ICBTAG_FLAG_AD_LONG:
@@ -1955,7 +1970,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
                 break;
         default:
                 udf_debug("alloc_type = %d unsupported\n",
-                                UDF_I(inode)->i_alloc_type);
+                                iinfo->i_alloc_type);
                 return -1;
         }
 
@@ -1990,15 +2005,17 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
         int adsize;
         int8_t etype;
         struct allocExtDesc *aed;
+        struct udf_inode_info *iinfo;
 
         if (epos.bh) {
                 get_bh(epos.bh);
                 get_bh(epos.bh);
         }
 
-        if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+        iinfo = UDF_I(inode);
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 adsize = 0;
@@ -2025,7 +2042,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
                 udf_write_aext(inode, &oepos, eloc, elen, 1);
                 udf_write_aext(inode, &oepos, eloc, elen, 1);
                 if (!oepos.bh) {
-                        UDF_I(inode)->i_lenAlloc -= (adsize * 2);
+                        iinfo->i_lenAlloc -= (adsize * 2);
                         mark_inode_dirty(inode);
                 } else {
                         aed = (struct allocExtDesc *)oepos.bh->b_data;
@@ -2044,7 +2061,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
         } else {
                 udf_write_aext(inode, &oepos, eloc, elen, 1);
                 if (!oepos.bh) {
-                        UDF_I(inode)->i_lenAlloc -= adsize;
+                        iinfo->i_lenAlloc -= adsize;
                         mark_inode_dirty(inode);
                 } else {
                         aed = (struct allocExtDesc *)oepos.bh->b_data;
@@ -2076,14 +2093,16 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
         loff_t lbcount = 0, bcount =
             (loff_t) block << blocksize_bits;
         int8_t etype;
+        struct udf_inode_info *iinfo;
 
         if (block < 0) {
                 printk(KERN_ERR "udf: inode_bmap: block < 0\n");
                 return -1;
         }
 
+        iinfo = UDF_I(inode);
         pos->offset = 0;
-        pos->block = UDF_I(inode)->i_location;
+        pos->block = iinfo->i_location;
         pos->bh = NULL;
         *elen = 0;
 
@@ -2091,7 +2110,7 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
                 etype = udf_next_aext(inode, pos, eloc, elen, 1);
                 if (etype == -1) {
                         *offset = (bcount - lbcount) >> blocksize_bits;
-                        UDF_I(inode)->i_lenExtents = lbcount;
+                        iinfo->i_lenExtents = lbcount;
                         return -1;
                 }
                 lbcount += *elen;