udf: cache struct udf_inode_info
authorMarcin Slusarz <marcin.slusarz@gmail.com>
Fri, 8 Feb 2008 12:20:44 +0000 (04:20 -0800)
committerLinus Torvalds <torvalds@woody.linux-foundation.org>
Fri, 8 Feb 2008 17:22:35 +0000 (09:22 -0800)
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>
fs/udf/balloc.c
fs/udf/dir.c
fs/udf/directory.c
fs/udf/file.c
fs/udf/ialloc.c
fs/udf/inode.c
fs/udf/misc.c
fs/udf/namei.c
fs/udf/partition.c
fs/udf/symlink.c
fs/udf/truncate.c

index 7b95b3f46211db068ee5f5be8bc15a8d459a8e5f..d721a1af19721fc0202ba9985b1278a04871b039 100644 (file)
@@ -436,6 +436,7 @@ static void udf_table_free_blocks(struct super_block *sb,
        struct extent_position oepos, epos;
        int8_t etype;
        int i;
+       struct udf_inode_info *iinfo;
 
        mutex_lock(&sbi->s_alloc_mutex);
        if (bloc.logicalBlockNum < 0 ||
@@ -448,6 +449,7 @@ static void udf_table_free_blocks(struct super_block *sb,
                goto error_return;
        }
 
+       iinfo = UDF_I(table);
        /* We do this up front - There are some error conditions that
           could occure, but.. oh well */
        if (inode)
@@ -460,7 +462,7 @@ static void udf_table_free_blocks(struct super_block *sb,
 
        epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
        elen = 0;
-       epos.block = oepos.block = UDF_I(table)->i_location;
+       epos.block = oepos.block = iinfo->i_location;
        epos.bh = oepos.bh = NULL;
 
        while (count &&
@@ -539,11 +541,11 @@ static void udf_table_free_blocks(struct super_block *sb,
                elen = EXT_RECORDED_ALLOCATED |
                        (count << sb->s_blocksize_bits);
 
-               if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) {
+               if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                        adsize = sizeof(short_ad);
-               } else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG) {
+               else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                        adsize = sizeof(long_ad);
-               else {
+               else {
                        brelse(oepos.bh);
                        brelse(epos.bh);
                        goto error_return;
@@ -573,7 +575,7 @@ static void udf_table_free_blocks(struct super_block *sb,
                        if (epos.offset + adsize > sb->s_blocksize) {
                                loffset = epos.offset;
                                aed->lengthAllocDescs = cpu_to_le32(adsize);
-                               sptr = UDF_I(table)->i_ext.i_data + epos.offset
+                               sptr = iinfo->i_ext.i_data + epos.offset
                                                                - adsize;
                                dptr = epos.bh->b_data +
                                        sizeof(struct allocExtDesc);
@@ -592,9 +594,9 @@ static void udf_table_free_blocks(struct super_block *sb,
                                                        aed->lengthAllocDescs) +
                                                                adsize);
                                } else {
-                                       sptr = UDF_I(table)->i_ext.i_data +
+                                       sptr = iinfo->i_ext.i_data +
                                                                epos.offset;
-                                       UDF_I(table)->i_lenAlloc += adsize;
+                                       iinfo->i_lenAlloc += adsize;
                                        mark_inode_dirty(table);
                                }
                                epos.offset = sizeof(struct allocExtDesc);
@@ -608,7 +610,7 @@ static void udf_table_free_blocks(struct super_block *sb,
                                            2, 1, epos.block.logicalBlockNum,
                                            sizeof(tag));
 
-                       switch (UDF_I(table)->i_alloc_type) {
+                       switch (iinfo->i_alloc_type) {
                        case ICBTAG_FLAG_AD_SHORT:
                                sad = (short_ad *)sptr;
                                sad->extLength = cpu_to_le32(
@@ -639,7 +641,7 @@ static void udf_table_free_blocks(struct super_block *sb,
                        udf_write_aext(table, &epos, eloc, elen, 1);
 
                        if (!epos.bh) {
-                               UDF_I(table)->i_lenAlloc += adsize;
+                               iinfo->i_lenAlloc += adsize;
                                mark_inode_dirty(table);
                        } else {
                                aed = (struct allocExtDesc *)epos.bh->b_data;
@@ -672,21 +674,23 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
        kernel_lb_addr eloc;
        struct extent_position epos;
        int8_t etype = -1;
+       struct udf_inode_info *iinfo;
 
        if (first_block < 0 ||
                first_block >= sbi->s_partmaps[partition].s_partition_len)
                return 0;
 
-       if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+       iinfo = UDF_I(table);
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                adsize = sizeof(short_ad);
-       else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
+       else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                adsize = sizeof(long_ad);
        else
                return 0;
 
        mutex_lock(&sbi->s_alloc_mutex);
        epos.offset = sizeof(struct unallocSpaceEntry);
-       epos.block = UDF_I(table)->i_location;
+       epos.block = iinfo->i_location;
        epos.bh = NULL;
        eloc.logicalBlockNum = 0xFFFFFFFF;
 
@@ -739,12 +743,13 @@ static int udf_table_new_block(struct super_block *sb,
        kernel_lb_addr eloc, uninitialized_var(goal_eloc);
        struct extent_position epos, goal_epos;
        int8_t etype;
+       struct udf_inode_info *iinfo = UDF_I(table);
 
        *err = -ENOSPC;
 
-       if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                adsize = sizeof(short_ad);
-       else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
+       else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                adsize = sizeof(long_ad);
        else
                return newblock;
@@ -759,7 +764,7 @@ static int udf_table_new_block(struct super_block *sb,
           of the current closest match and use that when we are done.
         */
        epos.offset = sizeof(struct unallocSpaceEntry);
-       epos.block = UDF_I(table)->i_location;
+       epos.block = iinfo->i_location;
        epos.bh = goal_epos.bh = NULL;
 
        while (spread &&
index 6fd831413c9ade7855640a124150e6e064794c50..4d9b2153f68678428529430124a3e7c7810afc7d 100644 (file)
@@ -117,6 +117,7 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
        int i, num;
        unsigned int dt_type;
        struct extent_position epos = { NULL, 0, {0, 0} };
+       struct udf_inode_info *iinfo;
 
        if (nf_pos >= size)
                return 0;
@@ -125,15 +126,16 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
                nf_pos = (udf_ext0_offset(dir) >> 2);
 
        fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+       iinfo = UDF_I(dir);
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
                fibh.sbh = fibh.ebh = NULL;
        } else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
                              &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
                block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
-                       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+                       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                                epos.offset -= sizeof(short_ad);
-                       else if (UDF_I(dir)->i_alloc_type ==
+                       else if (iinfo->i_alloc_type ==
                                        ICBTAG_FLAG_AD_LONG)
                                epos.offset -= sizeof(long_ad);
                } else {
index 949a5930f6d4480cfb87aadf65fe2c7308aabd42..d8ceb44f4f220c1d11cfcd575fae59faeb168b0f 100644 (file)
@@ -81,12 +81,13 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,
        struct fileIdentDesc *fi;
        int i, num, block;
        struct buffer_head *tmp, *bha[16];
+       struct udf_inode_info *iinfo = UDF_I(dir);
 
        fibh->soffset = fibh->eoffset;
 
-       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
-               fi = udf_get_fileident(UDF_I(dir)->i_ext.i_data -
-                                      (UDF_I(dir)->i_efe ?
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+               fi = udf_get_fileident(iinfo->i_ext.i_data -
+                                      (iinfo->i_efe ?
                                        sizeof(struct extendedFileEntry) :
                                        sizeof(struct fileEntry)),
                                       dir->i_sb->s_blocksize,
index a1e07a13162377a0b961af4ffe3d2ffab110af92..97c71ae7c68922f3cbe2f2ea48f0fb8a623fbc1d 100644 (file)
@@ -45,13 +45,13 @@ static int udf_adinicb_readpage(struct file *file, struct page *page)
 {
        struct inode *inode = page->mapping->host;
        char *kaddr;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
        BUG_ON(!PageLocked(page));
 
        kaddr = kmap(page);
        memset(kaddr, 0, PAGE_CACHE_SIZE);
-       memcpy(kaddr, UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr,
-                                                               inode->i_size);
+       memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr, inode->i_size);
        flush_dcache_page(page);
        SetPageUptodate(page);
        kunmap(page);
@@ -65,12 +65,12 @@ static int udf_adinicb_writepage(struct page *page,
 {
        struct inode *inode = page->mapping->host;
        char *kaddr;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
        BUG_ON(!PageLocked(page));
 
        kaddr = kmap(page);
-       memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, kaddr,
-                                                               inode->i_size);
+       memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr, kaddr, inode->i_size);
        mark_inode_dirty(inode);
        SetPageUptodate(page);
        kunmap(page);
@@ -87,9 +87,10 @@ static int udf_adinicb_write_end(struct file *file,
        struct inode *inode = mapping->host;
        unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
        char *kaddr;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
        kaddr = kmap_atomic(page, KM_USER0);
-       memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr + offset,
+       memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,
                kaddr + offset, copied);
        kunmap_atomic(kaddr, KM_USER0);
 
@@ -112,8 +113,9 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
        struct inode *inode = file->f_path.dentry->d_inode;
        int err, pos;
        size_t count = iocb->ki_left;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
-       if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
                if (file->f_flags & O_APPEND)
                        pos = inode->i_size;
                else
@@ -123,16 +125,15 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
                                (udf_file_entry_alloc_offset(inode) +
                                                pos + count)) {
                        udf_expand_file_adinicb(inode, pos + count, &err);
-                       if (UDF_I(inode)->i_alloc_type ==
-                                                       ICBTAG_FLAG_AD_IN_ICB) {
+                       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
                                udf_debug("udf_expand_adinicb: err=%d\n", err);
                                return err;
                        }
                } else {
                        if (pos + count > inode->i_size)
-                               UDF_I(inode)->i_lenAlloc = pos + count;
+                               iinfo->i_lenAlloc = pos + count;
                        else
-                               UDF_I(inode)->i_lenAlloc = inode->i_size;
+                               iinfo->i_lenAlloc = inode->i_size;
                }
        }
 
index 5ed8cda1c53e9c9ac0cd032020e4fcfbf063aceb..84360315aca2083001727f1defc0d453b4c07779 100644 (file)
@@ -67,6 +67,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
        struct inode *inode;
        int block;
        uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;
+       struct udf_inode_info *iinfo;
+       struct udf_inode_info *dinfo = UDF_I(dir);
 
        inode = new_inode(sb);
 
@@ -76,14 +78,15 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
        }
        *err = -ENOSPC;
 
-       UDF_I(inode)->i_unique = 0;
-       UDF_I(inode)->i_lenExtents = 0;
-       UDF_I(inode)->i_next_alloc_block = 0;
-       UDF_I(inode)->i_next_alloc_goal = 0;
-       UDF_I(inode)->i_strat4096 = 0;
+       iinfo = UDF_I(inode);
+       iinfo->i_unique = 0;
+       iinfo->i_lenExtents = 0;
+       iinfo->i_next_alloc_block = 0;
+       iinfo->i_next_alloc_goal = 0;
+       iinfo->i_strat4096 = 0;
 
        block = udf_new_block(dir->i_sb, NULL,
-                             UDF_I(dir)->i_location.partitionReferenceNum,
+                             dinfo->i_location.partitionReferenceNum,
                              start, err);
        if (*err) {
                iput(inode);
@@ -107,7 +110,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
                else
                        lvidiu->numFiles =
                                cpu_to_le32(le32_to_cpu(lvidiu->numFiles) + 1);
-               UDF_I(inode)->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID);
+               iinfo->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID);
                if (!(++uniqueID & 0x00000000FFFFFFFFUL))
                        uniqueID += 16;
                lvhd->uniqueID = cpu_to_le64(uniqueID);
@@ -123,41 +126,41 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
                inode->i_gid = current->fsgid;
        }
 
-       UDF_I(inode)->i_location.logicalBlockNum = block;
-       UDF_I(inode)->i_location.partitionReferenceNum =
-                               UDF_I(dir)->i_location.partitionReferenceNum;
-       inode->i_ino = udf_get_lb_pblock(sb, UDF_I(inode)->i_location, 0);
+       iinfo->i_location.logicalBlockNum = block;
+       iinfo->i_location.partitionReferenceNum =
+                               dinfo->i_location.partitionReferenceNum;
+       inode->i_ino = udf_get_lb_pblock(sb, iinfo->i_location, 0);
        inode->i_blocks = 0;
-       UDF_I(inode)->i_lenEAttr = 0;
-       UDF_I(inode)->i_lenAlloc = 0;
-       UDF_I(inode)->i_use = 0;
+       iinfo->i_lenEAttr = 0;
+       iinfo->i_lenAlloc = 0;
+       iinfo->i_use = 0;
        if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
-               UDF_I(inode)->i_efe = 1;
+               iinfo->i_efe = 1;
                if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)
                        sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE;
-               UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
+               iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
                                            sizeof(struct extendedFileEntry),
                                            GFP_KERNEL);
        } else {
-               UDF_I(inode)->i_efe = 0;
-               UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
+               iinfo->i_efe = 0;
+               iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
                                            sizeof(struct fileEntry),
                                            GFP_KERNEL);
        }
-       if (!UDF_I(inode)->i_ext.i_data) {
+       if (!iinfo->i_ext.i_data) {
                iput(inode);
                *err = -ENOMEM;
                mutex_unlock(&sbi->s_alloc_mutex);
                return NULL;
        }
        if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))
-               UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
+               iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
        else 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_mtime = inode->i_atime = inode->i_ctime =
-               UDF_I(inode)->i_crtime = current_fs_time(inode->i_sb);
+               iinfo->i_crtime = current_fs_time(inode->i_sb);
        insert_inode_hash(inode);
        mark_inode_dirty(inode);
        mutex_unlock(&sbi->s_alloc_mutex);
index f746b9f1c03ca7d6c1dfc1c338b8d5d96a31e955..6b4409f501964a4c29199b0c967431b439909d2b 100644 (file)
@@ -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;
index 2af44702633b4e587dbfa3bca98db9aa2d85a80f..a1d6da0caf7132121e7b5d69ea880aeeb97d1875 100644 (file)
@@ -51,17 +51,18 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
        uint8_t *ea = NULL, *ad = NULL;
        int offset;
        uint16_t crclen;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
-       ea = UDF_I(inode)->i_ext.i_data;
-       if (UDF_I(inode)->i_lenEAttr) {
-               ad = UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr;
+       ea = iinfo->i_ext.i_data;
+       if (iinfo->i_lenEAttr) {
+               ad = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
        } else {
                ad = ea;
                size += sizeof(struct extendedAttrHeaderDesc);
        }
 
        offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
-               UDF_I(inode)->i_lenAlloc;
+               iinfo->i_lenAlloc;
 
        /* TODO - Check for FreeEASpace */
 
@@ -69,21 +70,21 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
                struct extendedAttrHeaderDesc *eahd;
                eahd = (struct extendedAttrHeaderDesc *)ea;
 
-               if (UDF_I(inode)->i_lenAlloc)
-                       memmove(&ad[size], ad, UDF_I(inode)->i_lenAlloc);
+               if (iinfo->i_lenAlloc)
+                       memmove(&ad[size], ad, iinfo->i_lenAlloc);
 
-               if (UDF_I(inode)->i_lenEAttr) {
+               if (iinfo->i_lenEAttr) {
                        /* check checksum/crc */
                        if (eahd->descTag.tagIdent !=
                                        cpu_to_le16(TAG_IDENT_EAHD) ||
                            le32_to_cpu(eahd->descTag.tagLocation) !=
-                                       UDF_I(inode)->i_location.logicalBlockNum)
+                                       iinfo->i_location.logicalBlockNum)
                                return NULL;
                } else {
                        struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
 
                        size -= sizeof(struct extendedAttrHeaderDesc);
-                       UDF_I(inode)->i_lenEAttr +=
+                       iinfo->i_lenEAttr +=
                                sizeof(struct extendedAttrHeaderDesc);
                        eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
                        if (sbi->s_udfrev >= 0x0200)
@@ -93,15 +94,15 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
                        eahd->descTag.tagSerialNum =
                                        cpu_to_le16(sbi->s_serial_number);
                        eahd->descTag.tagLocation = cpu_to_le32(
-                               UDF_I(inode)->i_location.logicalBlockNum);
+                                       iinfo->i_location.logicalBlockNum);
                        eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
                        eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
                }
 
-               offset = UDF_I(inode)->i_lenEAttr;
+               offset = iinfo->i_lenEAttr;
                if (type < 2048) {
                        if (le32_to_cpu(eahd->appAttrLocation) <
-                                       UDF_I(inode)->i_lenEAttr) {
+                                       iinfo->i_lenEAttr) {
                                uint32_t aal =
                                        le32_to_cpu(eahd->appAttrLocation);
                                memmove(&ea[offset - aal + size],
@@ -111,7 +112,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
                                                cpu_to_le32(aal + size);
                        }
                        if (le32_to_cpu(eahd->impAttrLocation) <
-                                       UDF_I(inode)->i_lenEAttr) {
+                                       iinfo->i_lenEAttr) {
                                uint32_t ial =
                                        le32_to_cpu(eahd->impAttrLocation);
                                memmove(&ea[offset - ial + size],
@@ -122,7 +123,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
                        }
                } else if (type < 65536) {
                        if (le32_to_cpu(eahd->appAttrLocation) <
-                                       UDF_I(inode)->i_lenEAttr) {
+                                       iinfo->i_lenEAttr) {
                                uint32_t aal =
                                        le32_to_cpu(eahd->appAttrLocation);
                                memmove(&ea[offset - aal + size],
@@ -138,7 +139,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
                eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
                                                sizeof(tag), crclen, 0));
                eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag);
-               UDF_I(inode)->i_lenEAttr += size;
+               iinfo->i_lenEAttr += size;
                return (struct genericFormat *)&ea[offset];
        }
        if (loc & 0x02)
@@ -153,10 +154,11 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
        struct genericFormat *gaf;
        uint8_t *ea = NULL;
        uint32_t offset;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
-       ea = UDF_I(inode)->i_ext.i_data;
+       ea = iinfo->i_ext.i_data;
 
-       if (UDF_I(inode)->i_lenEAttr) {
+       if (iinfo->i_lenEAttr) {
                struct extendedAttrHeaderDesc *eahd;
                eahd = (struct extendedAttrHeaderDesc *)ea;
 
@@ -164,7 +166,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
                if (eahd->descTag.tagIdent !=
                                cpu_to_le16(TAG_IDENT_EAHD) ||
                    le32_to_cpu(eahd->descTag.tagLocation) !=
-                               UDF_I(inode)->i_location.logicalBlockNum)
+                               iinfo->i_location.logicalBlockNum)
                        return NULL;
 
                if (type < 2048)
@@ -174,7 +176,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
                else
                        offset = le32_to_cpu(eahd->appAttrLocation);
 
-               while (offset < UDF_I(inode)->i_lenEAttr) {
+               while (offset < iinfo->i_lenEAttr) {
                        gaf = (struct genericFormat *)&ea[offset];
                        if (le32_to_cpu(gaf->attrType) == type &&
                                        gaf->attrSubtype == subtype)
index 23e530659fa5d3d19d37c22017cd4b6dbef1ad5b..35e5bebe4fab4bd5fe796615675db0131e358d67 100644 (file)
@@ -158,23 +158,23 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
        uint32_t elen;
        sector_t offset;
        struct extent_position epos = {};
+       struct udf_inode_info *dinfo = UDF_I(dir);
 
        size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
        f_pos = (udf_ext0_offset(dir) >> 2);
 
        fibh->soffset = fibh->eoffset =
                (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+       if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                fibh->sbh = fibh->ebh = NULL;
        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
                              &epos, &eloc, &elen, &offset) ==
                                        (EXT_RECORDED_ALLOCATED >> 30)) {
                block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
-                       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+                       if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                                epos.offset -= sizeof(short_ad);
-                       else if (UDF_I(dir)->i_alloc_type ==
-                                                       ICBTAG_FLAG_AD_LONG)
+                       else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                                epos.offset -= sizeof(long_ad);
                } else
                        offset = 0;
@@ -351,6 +351,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
        uint32_t elen;
        sector_t offset;
        struct extent_position epos = {};
+       struct udf_inode_info *dinfo;
 
        if (dentry) {
                if (!dentry->d_name.len) {
@@ -373,17 +374,17 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
 
        fibh->soffset = fibh->eoffset =
                        (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+       dinfo = UDF_I(dir);
+       if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                fibh->sbh = fibh->ebh = NULL;
        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
                              &epos, &eloc, &elen, &offset) ==
                                        (EXT_RECORDED_ALLOCATED >> 30)) {
                block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
-                       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+                       if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                                epos.offset -= sizeof(short_ad);
-                       else if (UDF_I(dir)->i_alloc_type ==
-                                                       ICBTAG_FLAG_AD_LONG)
+                       else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                                epos.offset -= sizeof(long_ad);
                } else
                        offset = 0;
@@ -395,10 +396,10 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                        return NULL;
                }
 
-               block = UDF_I(dir)->i_location.logicalBlockNum;
+               block = dinfo->i_location.logicalBlockNum;
 
        } else {
-               block = udf_get_lb_pblock(dir->i_sb, UDF_I(dir)->i_location, 0);
+               block = udf_get_lb_pblock(dir->i_sb, dinfo->i_location, 0);
                fibh->sbh = fibh->ebh = NULL;
                fibh->soffset = fibh->eoffset = sb->s_blocksize;
                goto add;
@@ -477,7 +478,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
 add:
        f_pos += nfidlen;
 
-       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
+       if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
            sb->s_blocksize - fibh->eoffset < nfidlen) {
                brelse(epos.bh);
                epos.bh = NULL;
@@ -491,15 +492,15 @@ add:
                                udf_expand_dir_adinicb(dir, &block, err);
                if (!fibh->sbh)
                        return NULL;
-               epos.block = UDF_I(dir)->i_location;
+               epos.block = dinfo->i_location;
                eloc.logicalBlockNum = block;
                eloc.partitionReferenceNum =
-                               UDF_I(dir)->i_location.partitionReferenceNum;
+                               dinfo->i_location.partitionReferenceNum;
                elen = dir->i_sb->s_blocksize;
                epos.offset = udf_file_entry_alloc_offset(dir);
-               if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+               if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                        epos.offset += sizeof(short_ad);
-               else if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
+               else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                        epos.offset += sizeof(long_ad);
        }
 
@@ -511,13 +512,13 @@ add:
                        fibh->sbh = fibh->ebh;
                }
 
-               if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
-                       block = UDF_I(dir)->i_location.logicalBlockNum;
+               if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+                       block = dinfo->i_location.logicalBlockNum;
                        fi = (struct fileIdentDesc *)
-                                       (UDF_I(dir)->i_ext.i_data +
+                                       (dinfo->i_ext.i_data +
                                         fibh->soffset -
                                         udf_ext0_offset(dir) +
-                                        UDF_I(dir)->i_lenEAttr);
+                                        dinfo->i_lenEAttr);
                } else {
                        block = eloc.logicalBlockNum +
                                        ((elen - 1) >>
@@ -575,8 +576,8 @@ add:
        if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
                brelse(epos.bh);
                dir->i_size += nfidlen;
-               if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
-                       UDF_I(dir)->i_lenAlloc += nfidlen;
+               if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+                       dinfo->i_lenAlloc += nfidlen;
                mark_inode_dirty(dir);
                return fi;
        } else {
@@ -608,6 +609,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
        struct inode *inode;
        struct fileIdentDesc cfi, *fi;
        int err;
+       struct udf_inode_info *iinfo;
 
        lock_kernel();
        inode = udf_new_inode(dir, mode, &err);
@@ -616,7 +618,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
                return err;
        }
 
-       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)
                inode->i_data.a_ops = &udf_adinicb_aops;
        else
                inode->i_data.a_ops = &udf_aops;
@@ -634,9 +637,9 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
                return err;
        }
        cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-       cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
+       cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
        *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-               cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL);
+               cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
        udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
        if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                mark_inode_dirty(dir);
@@ -656,6 +659,7 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
        struct udf_fileident_bh fibh;
        struct fileIdentDesc cfi, *fi;
        int err;
+       struct udf_inode_info *iinfo;
 
        if (!old_valid_dev(rdev))
                return -EINVAL;
@@ -666,6 +670,7 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
        if (!inode)
                goto out;
 
+       iinfo = UDF_I(inode);
        inode->i_uid = current->fsuid;
        init_special_inode(inode, mode, rdev);
        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
@@ -677,9 +682,9 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
                return err;
        }
        cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-       cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
+       cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
        *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-               cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL);
+               cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
        udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
        if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                mark_inode_dirty(dir);
@@ -702,6 +707,8 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        struct udf_fileident_bh fibh;
        struct fileIdentDesc cfi, *fi;
        int err;
+       struct udf_inode_info *dinfo = UDF_I(dir);
+       struct udf_inode_info *iinfo;
 
        lock_kernel();
        err = -EMLINK;
@@ -713,6 +720,7 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        if (!inode)
                goto out;
 
+       iinfo = UDF_I(inode);
        inode->i_op = &udf_dir_inode_operations;
        inode->i_fop = &udf_dir_operations;
        fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
@@ -724,9 +732,9 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        }
        inode->i_nlink = 2;
        cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-       cfi.icb.extLocation = cpu_to_lelb(UDF_I(dir)->i_location);
+       cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location);
        *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-               cpu_to_le32(UDF_I(dir)->i_unique & 0x00000000FFFFFFFFUL);
+               cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL);
        cfi.fileCharacteristics =
                        FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
        udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
@@ -744,9 +752,9 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
                goto out;
        }
        cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-       cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
+       cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
        *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-               cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL);
+               cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
        cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
        udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
        inc_nlink(dir);
@@ -773,23 +781,23 @@ static int empty_dir(struct inode *dir)
        uint32_t elen;
        sector_t offset;
        struct extent_position epos = {};
+       struct udf_inode_info *dinfo = UDF_I(dir);
 
        f_pos = (udf_ext0_offset(dir) >> 2);
 
        fibh.soffset = fibh.eoffset =
                        (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
 
-       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+       if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                fibh.sbh = fibh.ebh = NULL;
        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
                              &epos, &eloc, &elen, &offset) ==
                                        (EXT_RECORDED_ALLOCATED >> 30)) {
                block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
-                       if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+                       if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                                epos.offset -= sizeof(short_ad);
-                       else if (UDF_I(dir)->i_alloc_type ==
-                                                       ICBTAG_FLAG_AD_LONG)
+                       else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                                epos.offset -= sizeof(long_ad);
                } else
                        offset = 0;
@@ -939,38 +947,40 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
        char name[UDF_NAME_LEN];
        int namelen;
        struct buffer_head *bh;
+       struct udf_inode_info *iinfo;
 
        lock_kernel();
        inode = udf_new_inode(dir, S_IFLNK, &err);
        if (!inode)
                goto out;
 
+       iinfo = UDF_I(inode);
        inode->i_mode = S_IFLNK | S_IRWXUGO;
        inode->i_data.a_ops = &udf_symlink_aops;
        inode->i_op = &page_symlink_inode_operations;
 
-       if (UDF_I(inode)->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
+       if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
                kernel_lb_addr eloc;
                uint32_t elen;
 
                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)
                        goto out_no_entry;
-               epos.block = UDF_I(inode)->i_location;
+               epos.block = iinfo->i_location;
                epos.offset = udf_file_entry_alloc_offset(inode);
                epos.bh = NULL;
                eloc.logicalBlockNum = block;
                eloc.partitionReferenceNum =
-                               UDF_I(inode)->i_location.partitionReferenceNum;
+                               iinfo->i_location.partitionReferenceNum;
                elen = inode->i_sb->s_blocksize;
-               UDF_I(inode)->i_lenExtents = elen;
+               iinfo->i_lenExtents = elen;
                udf_add_aext(inode, &epos, eloc, elen, 0);
                brelse(epos.bh);
 
                block = udf_get_pblock(inode->i_sb, block,
-                               UDF_I(inode)->i_location.partitionReferenceNum,
+                               iinfo->i_location.partitionReferenceNum,
                                0);
                epos.bh = udf_tread(inode->i_sb, block);
                lock_buffer(epos.bh);
@@ -979,9 +989,8 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
                unlock_buffer(epos.bh);
                mark_buffer_dirty_inode(epos.bh, inode);
                ea = epos.bh->b_data + udf_ext0_offset(inode);
-       } else {
-               ea = UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr;
-       }
+       } else
+               ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
 
        eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
        pc = (struct pathComponent *)ea;
@@ -1049,15 +1058,15 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
 
        brelse(epos.bh);
        inode->i_size = elen;
-       if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
-               UDF_I(inode)->i_lenAlloc = inode->i_size;
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+               iinfo->i_lenAlloc = inode->i_size;
        mark_inode_dirty(inode);
 
        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
        if (!fi)
                goto out_no_entry;
        cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-       cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
+       cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
        bh = UDF_SB(inode->i_sb)->s_lvid_bh;
        if (bh) {
                struct logicalVolIntegrityDesc *lvid =
@@ -1162,6 +1171,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct buffer_head *dir_bh = NULL;
        int retval = -ENOENT;
        kernel_lb_addr tloc;
+       struct udf_inode_info *old_iinfo = UDF_I(old_inode);
 
        lock_kernel();
        ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi);
@@ -1193,10 +1203,10 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
                                goto end_rename;
                }
                retval = -EIO;
-               if (UDF_I(old_inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+               if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
                        dir_fi = udf_get_fileident(
-                                       UDF_I(old_inode)->i_ext.i_data -
-                                         (UDF_I(old_inode)->i_efe ?
+                                       old_iinfo->i_ext.i_data -
+                                         (old_iinfo->i_efe ?
                                           sizeof(struct extendedFileEntry) :
                                           sizeof(struct fileEntry)),
                                        old_inode->i_sb->s_blocksize, &offset);
@@ -1258,7 +1268,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
                udf_update_tag((char *)dir_fi,
                                (sizeof(struct fileIdentDesc) +
                                le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
-               if (UDF_I(old_inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+               if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                        mark_inode_dirty(old_inode);
                else
                        mark_buffer_dirty_inode(dir_bh, old_inode);
index cfe213fd3113506fa4a70b148a214dab915724f4..fc533345ab89198a12fb472765f7c9073a356970 100644 (file)
@@ -55,6 +55,7 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
        struct udf_sb_info *sbi = UDF_SB(sb);
        struct udf_part_map *map;
        struct udf_virtual_data *vdata;
+       struct udf_inode_info *iinfo;
 
        map = &sbi->s_partmaps[partition];
        vdata = &map->s_type_specific.s_virtual;
@@ -88,15 +89,14 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
 
        brelse(bh);
 
-       if (UDF_I(sbi->s_vat_inode)->i_location.partitionReferenceNum ==
-                                                               partition) {
+       iinfo = UDF_I(sbi->s_vat_inode);
+       if (iinfo->i_location.partitionReferenceNum == partition) {
                udf_debug("recursive call to udf_get_pblock!\n");
                return 0xFFFFFFFF;
        }
 
        return udf_get_pblock(sb, loc,
-                             UDF_I(sbi->s_vat_inode)->i_location.
-                                                       partitionReferenceNum,
+                             iinfo->i_location.partitionReferenceNum,
                              offset);
 }
 
index d55989c871d4661b01f7304d36991b20d1e0cafb..6ec99221e50c6c02dd90df64e8b0a39d9bc771b8 100644 (file)
@@ -79,10 +79,12 @@ static int udf_symlink_filler(struct file *file, struct page *page)
        char *symlink;
        int err = -EIO;
        char *p = kmap(page);
+       struct udf_inode_info *iinfo;
 
        lock_kernel();
-       if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
-               symlink = UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr;
+       iinfo = UDF_I(inode);
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+               symlink = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
        } else {
                bh = sb_bread(inode->i_sb, udf_block_map(inode, 0));
 
index 8eb1d24ce5cee3d7a1123022c4c589614af4f079..fe61be17cdab93315f5f66b32d5add96b20b1d23 100644 (file)
@@ -74,17 +74,18 @@ void udf_truncate_tail_extent(struct inode *inode)
        uint64_t lbcount = 0;
        int8_t etype = -1, netype;
        int adsize;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
-       if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
-           inode->i_size == UDF_I(inode)->i_lenExtents)
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
+           inode->i_size == iinfo->i_lenExtents)
                return;
        /* Are we going to delete the file anyway? */
        if (inode->i_nlink == 0)
                return;
 
-       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
                BUG();
@@ -117,7 +118,7 @@ void udf_truncate_tail_extent(struct inode *inode)
        }
        /* This inode entry is in-memory only and thus we don't have to mark
         * the inode dirty */
-       UDF_I(inode)->i_lenExtents = inode->i_size;
+       iinfo->i_lenExtents = inode->i_size;
        brelse(epos.bh);
 }
 
@@ -129,19 +130,20 @@ void udf_discard_prealloc(struct inode *inode)
        uint64_t lbcount = 0;
        int8_t etype = -1, netype;
        int adsize;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
-       if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
-           inode->i_size == UDF_I(inode)->i_lenExtents)
+       if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
+           inode->i_size == iinfo->i_lenExtents)
                return;
 
-       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
                adsize = 0;
 
-       epos.block = UDF_I(inode)->i_location;
+       epos.block = iinfo->i_location;
 
        /* Find the last extent in the file */
        while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
@@ -153,7 +155,7 @@ void udf_discard_prealloc(struct inode *inode)
                lbcount -= elen;
                extent_trunc(inode, &epos, eloc, etype, elen, 0);
                if (!epos.bh) {
-                       UDF_I(inode)->i_lenAlloc =
+                       iinfo->i_lenAlloc =
                                epos.offset -
                                udf_file_entry_alloc_offset(inode);
                        mark_inode_dirty(inode);
@@ -174,7 +176,7 @@ void udf_discard_prealloc(struct inode *inode)
        }
        /* This inode entry is in-memory only and thus we don't have to mark
         * the inode dirty */
-       UDF_I(inode)->i_lenExtents = lbcount;
+       iinfo->i_lenExtents = lbcount;
        brelse(epos.bh);
 }
 
@@ -189,10 +191,11 @@ void udf_truncate_extents(struct inode *inode)
        sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;
        loff_t byte_offset;
        int adsize;
+       struct udf_inode_info *iinfo = UDF_I(inode);
 
-       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
                BUG();
@@ -227,7 +230,7 @@ void udf_truncate_extents(struct inode *inode)
                                                        0, indirect_ext_len);
                                } else {
                                        if (!epos.bh) {
-                                               UDF_I(inode)->i_lenAlloc =
+                                               iinfo->i_lenAlloc =
                                                                lenalloc;
                                                mark_inode_dirty(inode);
                                        } else {
@@ -275,7 +278,7 @@ void udf_truncate_extents(struct inode *inode)
                                        indirect_ext_len);
                } else {
                        if (!epos.bh) {
-                               UDF_I(inode)->i_lenAlloc = lenalloc;
+                               iinfo->i_lenAlloc = lenalloc;
                                mark_inode_dirty(inode);
                        } else {
                                struct allocExtDesc *aed =
@@ -325,7 +328,7 @@ void udf_truncate_extents(struct inode *inode)
                                                (sb->s_blocksize - 1)) != 0));
                }
        }
-       UDF_I(inode)->i_lenExtents = inode->i_size;
+       iinfo->i_lenExtents = inode->i_size;
 
        brelse(epos.bh);
 }