[PATCH 00/16] udf: cleanup - Kernel

This is a discussion on [PATCH 00/16] udf: cleanup - Kernel ; remove macros: - UDF_SB_PARTMAPS - UDF_SB_PARTTYPE - UDF_SB_PARTROOT - UDF_SB_PARTLEN - UDF_SB_PARTVSN - UDF_SB_PARTNUM - UDF_SB_TYPESPAR - UDF_SB_TYPEVIRT - UDF_SB_PARTFUNC - UDF_SB_PARTFLAGS - UDF_SB_VOLIDENT - UDF_SB_NUMPARTS - UDF_SB_PARTITION - UDF_SB_SESSION - UDF_SB_ANCHOR - UDF_SB_LASTBLOCK - UDF_SB_LVIDBH - UDF_SB_LVID - UDF_SB_UMASK ...

+ Reply to Thread
Page 1 of 2 1 2 LastLast
Results 1 to 20 of 21

Thread: [PATCH 00/16] udf: cleanup

  1. [PATCH 02/16] udf: remove some ugly macros

    remove macros:
    - UDF_SB_PARTMAPS
    - UDF_SB_PARTTYPE
    - UDF_SB_PARTROOT
    - UDF_SB_PARTLEN
    - UDF_SB_PARTVSN
    - UDF_SB_PARTNUM
    - UDF_SB_TYPESPAR
    - UDF_SB_TYPEVIRT
    - UDF_SB_PARTFUNC
    - UDF_SB_PARTFLAGS
    - UDF_SB_VOLIDENT
    - UDF_SB_NUMPARTS
    - UDF_SB_PARTITION
    - UDF_SB_SESSION
    - UDF_SB_ANCHOR
    - UDF_SB_LASTBLOCK
    - UDF_SB_LVIDBH
    - UDF_SB_LVID
    - UDF_SB_UMASK
    - UDF_SB_GID
    - UDF_SB_UID
    - UDF_SB_RECORDTIME
    - UDF_SB_SERIALNUM
    - UDF_SB_UDFREV
    - UDF_SB_FLAGS
    - UDF_SB_VAT
    - UDF_UPDATE_UDFREV
    - UDF_SB_FREE
    and open code them

    convert UDF_SB_LVIDIU macro to udf_sb_lvidiu function

    rename some struct udf_sb_info fields:
    - s_volident to s_volume_ident
    - s_lastblock to s_last_block
    - s_lvidbh to s_lvid_bh
    - s_recordtime to s_record_time
    - s_serialnum to s_serial_number;
    - s_vat to s_vat_inode;

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    Acked-by: Christoph Hellwig
    ---
    fs/udf/balloc.c | 136 ++++++-----
    fs/udf/file.c | 2 +-
    fs/udf/ialloc.c | 33 ++--
    fs/udf/inode.c | 34 ++--
    fs/udf/misc.c | 15 +-
    fs/udf/namei.c | 24 ++-
    fs/udf/partition.c | 67 ++++---
    fs/udf/super.c | 548 +++++++++++++++++++++++++--------------------
    fs/udf/truncate.c | 7 +-
    fs/udf/udf_sb.h | 75 ++-----
    include/linux/udf_fs_sb.h | 12 +-
    11 files changed, 510 insertions(+), 443 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index ab26176..8c0c279 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -88,7 +88,7 @@ static int read_block_bitmap(struct super_block *sb,
    kernel_lb_addr loc;

    loc.logicalBlockNum = bitmap->s_extPosition;
    - loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
    + loc.partitionReferenceNum = UDF_SB(sb)->s_partition;

    bh = udf_tread(sb, udf_get_lb_pblock(sb, loc, block));
    if (!bh) {
    @@ -155,10 +155,10 @@ static void udf_bitmap_free_blocks(struct super_block *sb,

    mutex_lock(&sbi->s_alloc_mutex);
    if (bloc.logicalBlockNum < 0 ||
    - (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
    + (bloc.logicalBlockNum + count) > sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {
    udf_debug("%d < %d || %d + %d > %d\n",
    bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
    - UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
    + sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len);
    goto error_return;
    }

    @@ -188,9 +188,10 @@ do_more:
    } else {
    if (inode)
    DQUOT_FREE_BLOCK(inode, 1);
    - if (UDF_SB_LVIDBH(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + 1);
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + lvid->freeSpaceTable[sbi->s_partition] =
    + cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[sbi->s_partition]) + 1);
    }
    }
    }
    @@ -202,8 +203,8 @@ do_more:
    }
    error_return:
    sb->s_dirt = 1;
    - if (UDF_SB_LVIDBH(sb))
    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + if (sbi->s_lvid_bh)
    + mark_buffer_dirty(sbi->s_lvid_bh);
    mutex_unlock(&sbi->s_alloc_mutex);
    return;
    }
    @@ -219,16 +220,18 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    int bit, block, block_group, group_start;
    int nr_groups, bitmap_nr;
    struct buffer_head *bh;
    + __u32 part_len;

    mutex_lock(&sbi->s_alloc_mutex);
    - if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
    + part_len = sbi->s_partmaps[partition].s_partition_len;
    + if (first_block < 0 || first_block >= part_len)
    goto out;

    - if (first_block + block_count > UDF_SB_PARTLEN(sb, partition))
    - block_count = UDF_SB_PARTLEN(sb, partition) - first_block;
    + if (first_block + block_count > part_len)
    + block_count = part_len - first_block;

    repeat:
    - nr_groups = (UDF_SB_PARTLEN(sb, partition) +
    + nr_groups = (sbi->s_partmaps[partition].s_partition_len +
    (sizeof(struct spaceBitmapDesc) << 3) +
    (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
    block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
    @@ -261,10 +264,11 @@ repeat:
    if (block_count > 0)
    goto repeat;
    out:
    - if (UDF_SB_LVIDBH(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[partition] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + lvid->freeSpaceTable[partition] =
    + cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - alloc_count);
    + mark_buffer_dirty(sbi->s_lvid_bh);
    }
    sb->s_dirt = 1;
    mutex_unlock(&sbi->s_alloc_mutex);
    @@ -287,7 +291,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
    mutex_lock(&sbi->s_alloc_mutex);

    repeat:
    - if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
    + if (goal < 0 || goal >= sbi->s_partmaps[partition].s_partition_len)
    goal = 0;

    nr_groups = bitmap->s_nr_groups;
    @@ -389,10 +393,11 @@ got_block:

    mark_buffer_dirty(bh);

    - if (UDF_SB_LVIDBH(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[partition] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + lvid->freeSpaceTable[partition] =
    + cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - 1);
    + mark_buffer_dirty(sbi->s_lvid_bh);
    }
    sb->s_dirt = 1;
    mutex_unlock(&sbi->s_alloc_mutex);
    @@ -421,10 +426,10 @@ static void udf_table_free_blocks(struct super_block *sb,

    mutex_lock(&sbi->s_alloc_mutex);
    if (bloc.logicalBlockNum < 0 ||
    - (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
    + (bloc.logicalBlockNum + count) > sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {
    udf_debug("%d < %d || %d + %d > %d\n",
    bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
    - UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
    + sbi->s_partmaps[bloc.partitionReferenceNum]->s_partition_len);
    goto error_return;
    }

    @@ -432,10 +437,11 @@ static void udf_table_free_blocks(struct super_block *sb,
    but.. oh well */
    if (inode)
    DQUOT_FREE_BLOCK(inode, count);
    - if (UDF_SB_LVIDBH(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + count);
    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + lvid->freeSpaceTable[sbi->s_partition] =
    + cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[sbi->s_partition]) + count);
    + mark_buffer_dirty(sbi->s_lvid_bh);
    }

    start = bloc.logicalBlockNum + offset;
    @@ -559,7 +565,7 @@ static void udf_table_free_blocks(struct super_block *sb,
    }
    epos.offset = sizeof(struct allocExtDesc);
    }
    - if (UDF_SB_UDFREV(sb) >= 0x0200)
    + if (sbi->s_udfrev >= 0x0200)
    udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
    epos.block.logicalBlockNum, sizeof(tag));
    else
    @@ -627,7 +633,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
    struct extent_position epos;
    int8_t etype = -1;

    - if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
    + if (first_block < 0 || first_block >= sbi->s_partmaps[partition].s_partition_len)
    return 0;

    if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
    @@ -670,10 +676,11 @@ static int udf_table_prealloc_blocks(struct super_block *sb,

    brelse(epos.bh);

    - if (alloc_count && UDF_SB_LVIDBH(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[partition] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + if (alloc_count && sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + lvid->freeSpaceTable[partition] =
    + cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - alloc_count);
    + mark_buffer_dirty(sbi->s_lvid_bh);
    sb->s_dirt = 1;
    }
    mutex_unlock(&sbi->s_alloc_mutex);
    @@ -703,7 +710,7 @@ static int udf_table_new_block(struct super_block *sb,
    return newblock;

    mutex_lock(&sbi->s_alloc_mutex);
    - if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
    + if (goal < 0 || goal >= sbi->s_partmaps[partition].s_partition_len)
    goal = 0;

    /* We search for the closest matching block to goal. If we find a exact hit,
    @@ -771,10 +778,11 @@ static int udf_table_new_block(struct super_block *sb,
    udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
    brelse(goal_epos.bh);

    - if (UDF_SB_LVIDBH(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[partition] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + lvid->freeSpaceTable[partition] =
    + cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - 1);
    + mark_buffer_dirty(sbi->s_lvid_bh);
    }

    sb->s_dirt = 1;
    @@ -789,22 +797,23 @@ inline void udf_free_blocks(struct super_block *sb,
    uint32_t count)
    {
    uint16_t partition = bloc.partitionReferenceNum;
    + struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];

    - if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
    return udf_bitmap_free_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
    + map->s_uspace.s_bitmap,
    bloc, offset, count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_free_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
    + map->s_uspace.s_table,
    bloc, offset, count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_free_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
    + map->s_fspace.s_bitmap,
    bloc, offset, count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_free_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
    + map->s_fspace.s_table,
    bloc, offset, count);
    } else {
    return;
    @@ -816,21 +825,23 @@ inline int udf_prealloc_blocks(struct super_block *sb,
    uint16_t partition, uint32_t first_block,
    uint32_t block_count)
    {
    - if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
    +
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
    return udf_bitmap_prealloc_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
    + map->s_uspace.s_bitmap,
    partition, first_block, block_count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_prealloc_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
    + map->s_uspace.s_table,
    partition, first_block, block_count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_prealloc_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
    + map->s_fspace.s_bitmap,
    partition, first_block, block_count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_prealloc_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
    + map->s_fspace.s_table,
    partition, first_block, block_count);
    } else {
    return 0;
    @@ -842,23 +853,24 @@ inline int udf_new_block(struct super_block *sb,
    uint16_t partition, uint32_t goal, int *err)
    {
    int ret;
    + struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];

    - if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
    ret = udf_bitmap_new_block(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
    + map->s_uspace.s_bitmap,
    partition, goal, err);
    return ret;
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_new_block(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
    + map->s_uspace.s_table,
    partition, goal, err);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_new_block(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
    + map->s_fspace.s_bitmap,
    partition, goal, err);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_new_block(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
    + map->s_fspace.s_table,
    partition, goal, err);
    } else {
    *err = -EIO;
    diff --git a/fs/udf/file.c b/fs/udf/file.c
    index 7c7a1b3..3bd5068 100644
    --- a/fs/udf/file.c
    +++ b/fs/udf/file.c
    @@ -192,7 +192,7 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
    switch (cmd) {
    case UDF_GETVOLIDENT:
    return copy_to_user((char __user *)arg,
    - UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;
    + UDF_SB(inode->i_sb)->s_volume_ident, 32) ? -EFAULT : 0;
    case UDF_RELOCATE_BLOCKS:
    if (!capable(CAP_SYS_ADMIN))
    return -EACCES;
    diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
    index 636d8f6..8145e94 100644
    --- a/fs/udf/ialloc.c
    +++ b/fs/udf/ialloc.c
    @@ -43,15 +43,17 @@ void udf_free_inode(struct inode *inode)
    clear_inode(inode);

    mutex_lock(&sbi->s_alloc_mutex);
    - if (sbi->s_lvidbh) {
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDescImpUse *lvidiu =
    + udf_sb_lvidiu(sbi);
    if (S_ISDIR(inode->i_mode))
    - UDF_SB_LVIDIU(sb)->numDirs =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) - 1);
    + lvidiu->numDirs =
    + cpu_to_le32(le32_to_cpu(lvidiu->numDirs) - 1);
    else
    - UDF_SB_LVIDIU(sb)->numFiles =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) - 1);
    + lvidiu->numFiles =
    + cpu_to_le32(le32_to_cpu(lvidiu->numFiles) - 1);

    - mark_buffer_dirty(sbi->s_lvidbh);
    + mark_buffer_dirty(sbi->s_lvid_bh);
    }
    mutex_unlock(&sbi->s_alloc_mutex);

    @@ -88,21 +90,23 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    }

    mutex_lock(&sbi->s_alloc_mutex);
    - if (UDF_SB_LVIDBH(sb)) {
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + struct logicalVolIntegrityDescImpUse *lvidiu = udf_sb_lvidiu(sbi);
    struct logicalVolHeaderDesc *lvhd;
    uint64_t uniqueID;
    - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->logicalVolContentsUse);
    + lvhd = (struct logicalVolHeaderDesc *)(lvid->logicalVolContentsUse);
    if (S_ISDIR(mode))
    - UDF_SB_LVIDIU(sb)->numDirs =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) + 1);
    + lvidiu->numDirs =
    + cpu_to_le32(le32_to_cpu(lvidiu->numDirs) + 1);
    else
    - UDF_SB_LVIDIU(sb)->numFiles =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) + 1);
    + lvidiu->numFiles =
    + cpu_to_le32(le32_to_cpu(lvidiu->numFiles) + 1);
    UDF_I_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);
    if (!(++uniqueID & 0x00000000FFFFFFFFUL))
    uniqueID += 16;
    lvhd->uniqueID = cpu_to_le64(uniqueID);
    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + mark_buffer_dirty(sbi->s_lvid_bh);
    }
    inode->i_mode = mode;
    inode->i_uid = current->fsuid;
    @@ -123,7 +127,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    UDF_I_USE(inode) = 0;
    if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
    UDF_I_EFE(inode) = 1;
    - UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);
    + if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)
    + sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE;
    UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
    } else {
    UDF_I_EFE(inode) = 0;
    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index 1178ae0..3886313 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -1081,6 +1081,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    time_t convtime;
    long convtime_usec;
    int offset;
    + struct udf_sb_info *sbi = UDF_SB(inode->i_sb);

    fe = (struct fileEntry *)bh->b_data;
    efe = (struct extendedFileEntry *)bh->b_data;
    @@ -1160,7 +1161,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    inode->i_atime.tv_sec = convtime;
    inode->i_atime.tv_nsec = convtime_usec * 1000;
    } else {
    - inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
    + inode->i_atime = sbi->s_record_time;
    }

    if (udf_stamp_to_time(&convtime, &convtime_usec,
    @@ -1168,7 +1169,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    inode->i_mtime.tv_sec = convtime;
    inode->i_mtime.tv_nsec = convtime_usec * 1000;
    } else {
    - inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
    + inode->i_mtime = sbi->s_record_time;
    }

    if (udf_stamp_to_time(&convtime, &convtime_usec,
    @@ -1176,7 +1177,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    inode->i_ctime.tv_sec = convtime;
    inode->i_ctime.tv_nsec = convtime_usec * 1000;
    } else {
    - inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
    + inode->i_ctime = sbi->s_record_time;
    }

    UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID);
    @@ -1192,7 +1193,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    inode->i_atime.tv_sec = convtime;
    inode->i_atime.tv_nsec = convtime_usec * 1000;
    } else {
    - inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
    + inode->i_atime = sbi->s_record_time;
    }

    if (udf_stamp_to_time(&convtime, &convtime_usec,
    @@ -1200,7 +1201,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    inode->i_mtime.tv_sec = convtime;
    inode->i_mtime.tv_nsec = convtime_usec * 1000;
    } else {
    - inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
    + inode->i_mtime = sbi->s_record_time;
    }

    if (udf_stamp_to_time(&convtime, &convtime_usec,
    @@ -1208,7 +1209,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    UDF_I_CRTIME(inode).tv_sec = convtime;
    UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000;
    } else {
    - UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb);
    + UDF_I_CRTIME(inode) = sbi->s_record_time;
    }

    if (udf_stamp_to_time(&convtime, &convtime_usec,
    @@ -1216,7 +1217,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    inode->i_ctime.tv_sec = convtime;
    inode->i_ctime.tv_nsec = convtime_usec * 1000;
    } else {
    - inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
    + inode->i_ctime = sbi->s_record_time;
    }

    UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
    @@ -1353,6 +1354,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    int i;
    kernel_timestamp cpu_time;
    int err = 0;
    + struct udf_sb_info *sbi = UDF_SB(inode->i_sb);

    bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0));
    if (!bh) {
    @@ -1537,11 +1539,11 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));

    fe->icbTag.flags = cpu_to_le16(icbflags);
    - if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
    + if (sbi->s_udfrev >= 0x0200)
    fe->descTag.descVersion = cpu_to_le16(3);
    else
    fe->descTag.descVersion = cpu_to_le16(2);
    - fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
    + fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
    fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum) ;
    crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
    fe->descTag.descCRCLength = cpu_to_le16(crclen);
    @@ -1585,7 +1587,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
    if (is_bad_inode(inode))
    goto out_iput;

    - if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
    + if (ino.logicalBlockNum >= UDF_SB(sb)->s_partmaps[ino.partitionReferenceNum].s_partition_len) {
    udf_debug("block=%d, partition=%d out of range\n",
    ino.logicalBlockNum, ino.partitionReferenceNum);
    make_bad_inode(inode);
    @@ -1667,7 +1669,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
    mark_inode_dirty(inode);
    }
    }
    - if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
    + if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200)
    udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
    epos->block.logicalBlockNum, sizeof(tag));
    else
    @@ -1690,7 +1692,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
    }
    if (epos->bh) {
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
    udf_update_tag(epos->bh->b_data, loffset);
    else
    udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
    @@ -1711,7 +1713,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
    aed = (struct allocExtDesc *)epos->bh->b_data;
    aed->lengthAllocDescs =
    cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
    - if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
    udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize));
    else
    udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
    @@ -1754,7 +1756,7 @@ int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,

    if (epos->bh) {
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201) {
    + UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
    struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;
    udf_update_tag(epos->bh->b_data,
    le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
    @@ -1907,7 +1909,7 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
    aed->lengthAllocDescs =
    cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2 * adsize));
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
    udf_update_tag(oepos.bh->b_data, oepos.offset - (2 * adsize));
    else
    udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
    @@ -1923,7 +1925,7 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
    aed->lengthAllocDescs =
    cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
    udf_update_tag(oepos.bh->b_data, epos.offset - adsize);
    else
    udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
    diff --git a/fs/udf/misc.c b/fs/udf/misc.c
    index 15297de..7cecb30 100644
    --- a/fs/udf/misc.c
    +++ b/fs/udf/misc.c
    @@ -81,14 +81,16 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    return NULL;
    }
    } else {
    + struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
    +
    size -= sizeof(struct extendedAttrHeaderDesc);
    UDF_I_LENEATTR(inode) += sizeof(struct extendedAttrHeaderDesc);
    eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
    - if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
    + if (sbi->s_udfrev >= 0x0200)
    eahd->descTag.descVersion = cpu_to_le16(3);
    else
    eahd->descTag.descVersion = cpu_to_le16(2);
    - eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
    + eahd->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
    eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum) ;
    eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
    eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
    @@ -192,15 +194,16 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
    struct buffer_head *bh = NULL;
    register uint8_t checksum;
    register int i;
    + struct udf_sb_info *sbi = UDF_SB(sb);

    /* Read the block */
    if (block == 0xFFFFFFFF)
    return NULL;

    - bh = udf_tread(sb, block + UDF_SB_SESSION(sb));
    + bh = udf_tread(sb, block + sbi->s_session);
    if (!bh) {
    udf_debug("block=%d, location=%d: read failed\n",
    - block + UDF_SB_SESSION(sb), location);
    + block + sbi->s_session, location);
    return NULL;
    }

    @@ -210,7 +213,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,

    if (location != le32_to_cpu(tag_p->tagLocation)) {
    udf_debug("location mismatch block %u, tag %u != %u\n",
    - block + UDF_SB_SESSION(sb), le32_to_cpu(tag_p->tagLocation), location);
    + block + sbi->s_session, le32_to_cpu(tag_p->tagLocation), location);
    goto error_out;
    }

    @@ -240,7 +243,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
    return bh;
    }
    udf_debug("Crc failure block %d: crc = %d, crclen = %d\n",
    - block + UDF_SB_SESSION(sb), le16_to_cpu(tag_p->descCRC),
    + block + sbi->s_session, le16_to_cpu(tag_p->descCRC),
    le16_to_cpu(tag_p->descCRCLength));

    error_out:
    diff --git a/fs/udf/namei.c b/fs/udf/namei.c
    index 066153f..a9bd7fe 100644
    --- a/fs/udf/namei.c
    +++ b/fs/udf/namei.c
    @@ -325,7 +325,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
    struct udf_fileident_bh *fibh,
    struct fileIdentDesc *cfi, int *err)
    {
    - struct super_block *sb;
    + struct super_block *sb = dir->i_sb;
    struct fileIdentDesc *fi = NULL;
    char name[UDF_NAME_LEN], fname[UDF_NAME_LEN];
    int namelen;
    @@ -342,8 +342,6 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
    sector_t offset;
    struct extent_position epos = {};

    - sb = dir->i_sb;
    -
    if (dentry) {
    if (!dentry->d_name.len) {
    *err = -EINVAL;
    @@ -535,7 +533,7 @@ add:
    }

    memset(cfi, 0, sizeof(struct fileIdentDesc));
    - if (UDF_SB_UDFREV(sb) >= 0x0200)
    + if (UDF_SB(sb)->s_udfrev >= 0x0200)
    udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, sizeof(tag));
    else
    udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, sizeof(tag));
    @@ -901,6 +899,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
    int block;
    char name[UDF_NAME_LEN];
    int namelen;
    + struct buffer_head *bh;

    lock_kernel();
    if (!(inode = udf_new_inode(dir, S_IFLNK, &err)))
    @@ -1014,17 +1013,19 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
    goto out_no_entry;
    cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
    cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
    - if (UDF_SB_LVIDBH(inode->i_sb)) {
    + bh = UDF_SB(inode->i_sb)->s_lvid_bh;
    + if (bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
    struct logicalVolHeaderDesc *lvhd;
    uint64_t uniqueID;
    - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
    + lvhd = (struct logicalVolHeaderDesc *)(lvid->logicalVolContentsUse);
    uniqueID = le64_to_cpu(lvhd->uniqueID);
    *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
    cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
    if (!(++uniqueID & 0x00000000FFFFFFFFUL))
    uniqueID += 16;
    lvhd->uniqueID = cpu_to_le64(uniqueID);
    - mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb));
    + mark_buffer_dirty(bh);
    }
    udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
    if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
    @@ -1053,6 +1054,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
    struct udf_fileident_bh fibh;
    struct fileIdentDesc cfi, *fi;
    int err;
    + struct buffer_head *bh;

    lock_kernel();
    if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) {
    @@ -1066,17 +1068,19 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
    }
    cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
    cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
    - if (UDF_SB_LVIDBH(inode->i_sb)) {
    + bh = UDF_SB(inode->i_sb)->s_lvid_bh;
    + if (bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
    struct logicalVolHeaderDesc *lvhd;
    uint64_t uniqueID;
    - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
    + lvhd = (struct logicalVolHeaderDesc *)(lvid->logicalVolContentsUse);
    uniqueID = le64_to_cpu(lvhd->uniqueID);
    *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
    cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
    if (!(++uniqueID & 0x00000000FFFFFFFFUL))
    uniqueID += 16;
    lvhd->uniqueID = cpu_to_le64(uniqueID);
    - mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb));
    + mark_buffer_dirty(bh);
    }
    udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
    if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
    diff --git a/fs/udf/partition.c b/fs/udf/partition.c
    index aaab24c..eeb4714 100644
    --- a/fs/udf/partition.c
    +++ b/fs/udf/partition.c
    @@ -31,15 +31,18 @@
    inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
    uint16_t partition, uint32_t offset)
    {
    - if (partition >= UDF_SB_NUMPARTS(sb)) {
    + struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_part_map *map;
    + if (partition >= sbi->s_partitions) {
    udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
    block, partition, offset);
    return 0xFFFFFFFF;
    }
    - if (UDF_SB_PARTFUNC(sb, partition))
    - return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);
    + map = &sbi->s_partmaps[partition];
    + if (map->s_partition_func)
    + return map->s_partition_func(sb, block, partition, offset);
    else
    - return UDF_SB_PARTROOT(sb, partition) + block + offset;
    + return map->s_partition_root + block + offset;
    }

    uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
    @@ -49,12 +52,15 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
    uint32_t newblock;
    uint32_t index;
    uint32_t loc;
    + struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_part_map *map;

    - index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);
    + map = &sbi->s_partmaps[partition];
    + index = (sb->s_blocksize - map->s_type_specific.s_virtual.s_start_offset) / sizeof(uint32_t);

    - if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {
    + if (block > map->s_type_specific.s_virtual.s_num_entries) {
    udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
    - block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);
    + block, map->s_type_specific.s_virtual.s_num_entries);
    return 0xFFFFFFFF;
    }

    @@ -64,10 +70,10 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
    index = block % (sb->s_blocksize / sizeof(uint32_t));
    } else {
    newblock = 0;
    - index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
    + index = map->s_type_specific.s_virtual.s_start_offset / sizeof(uint32_t) + block;
    }

    - loc = udf_block_map(UDF_SB_VAT(sb), newblock);
    + loc = udf_block_map(sbi->s_vat_inode, newblock);

    if (!(bh = sb_bread(sb, loc))) {
    udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
    @@ -79,13 +85,13 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,

    brelse(bh);

    - if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReference Num == partition) {
    + if (UDF_I_LOCATION(sbi->s_vat_inode).partitionReferenceNum == partition) {
    udf_debug("recursive call to udf_get_pblock!\n");
    return 0xFFFFFFFF;
    }

    return udf_get_pblock(sb, loc,
    - UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceN um,
    + UDF_I_LOCATION(sbi->s_vat_inode).partitionReferenceNum,
    offset);
    }

    @@ -95,16 +101,21 @@ inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
    return udf_get_pblock_virt15(sb, block, partition, offset);
    }

    -uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
    +uint32_t udf_get_pblock_spar15(struct super_block *sb, uint32_t block,
    uint16_t partition, uint32_t offset)
    {
    int i;
    struct sparingTable *st = NULL;
    - uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);
    + struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_part_map *map;
    + uint32_t packet;
    +
    + map = &sbi->s_partmaps[partition];
    + packet = (block + offset) & ~(map->s_type_specific.s_sparing.s_packet_len - 1);

    for (i = 0; i < 4; i++) {
    - if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {
    - st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
    + if (map->s_type_specific.s_sparing.s_spar_map[i] != NULL) {
    + st = (struct sparingTable *)map->s_type_specific.s_sparing.s_spar_map[i]->b_data;
    break;
    }
    }
    @@ -115,14 +126,14 @@ uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
    break;
    } else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {
    return le32_to_cpu(st->mapEntry[i].mappedLocation) +
    - ((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
    + ((block + offset) & (map->s_type_specific.s_sparing.s_packet_len - 1));
    } else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
    break;
    }
    }
    }

    - return UDF_SB_PARTROOT(sb,partition) + block + offset;
    + return map->s_partition_root + block + offset;
    }

    int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    @@ -132,15 +143,17 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    struct sparingEntry mapEntry;
    uint32_t packet;
    int i, j, k, l;
    + struct udf_sb_info *sbi = UDF_SB(sb);

    - for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
    - if (old_block > UDF_SB_PARTROOT(sb,i) &&
    - old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
    - sdata = &UDF_SB_TYPESPAR(sb,i);
    - packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);
    + for (i = 0; i < sbi->s_partitions; i++) {
    + struct udf_part_map *map = &sbi->s_partmaps[i];
    + if (old_block > map->s_partition_root &&
    + old_block < map->s_partition_root + map->s_partition_len) {
    + sdata = &map->s_type_specific.s_sparing;
    + packet = (old_block - map->s_partition_root) & ~(sdata->s_packet_len - 1);

    for (j = 0; j < 4; j++) {
    - if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
    + if (map->s_type_specific.s_sparing.s_spar_map[j] != NULL) {
    st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
    break;
    }
    @@ -160,11 +173,11 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    }
    }
    *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
    - ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
    + ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
    return 0;
    } else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
    *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
    - ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
    + ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
    return 0;
    } else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
    break;
    @@ -185,7 +198,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    }
    }
    *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
    - ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
    + ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
    return 0;
    }
    }
    @@ -194,7 +207,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    } /* if old_block */
    }

    - if (i == UDF_SB_NUMPARTS(sb)) {
    + if (i == sbi->s_partitions) {
    /* outside of partitions */
    /* for now, fail =) */
    return 1;
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 57788f1..246868c 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -95,6 +95,14 @@ static void udf_close_lvid(struct super_block *);
    static unsigned int udf_count_free(struct super_block *);
    static int udf_statfs(struct dentry *, struct kstatfs *);

    +struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
    +{
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + __u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
    + __u32 offset = number_of_partitions * 2 * sizeof(uint32_t)/sizeof(uint8_t);
    + return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]);
    +}
    +
    /* UDF filesystem type */
    static int udf_get_sb(struct file_system_type *fs_type,
    int flags, const char *dev_name, void *data,
    @@ -461,22 +469,23 @@ void udf_write_super(struct super_block *sb)
    static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
    {
    struct udf_options uopt;
    + struct udf_sb_info *sbi = UDF_SB(sb);

    - uopt.flags = UDF_SB(sb)->s_flags;
    - uopt.uid = UDF_SB(sb)->s_uid;
    - uopt.gid = UDF_SB(sb)->s_gid;
    - uopt.umask = UDF_SB(sb)->s_umask;
    + uopt.flags = sbi->s_flags;
    + uopt.uid = sbi->s_uid;
    + uopt.gid = sbi->s_gid;
    + uopt.umask = sbi->s_umask;

    if (!udf_parse_options(options, &uopt))
    return -EINVAL;

    - UDF_SB(sb)->s_flags = uopt.flags;
    - UDF_SB(sb)->s_uid = uopt.uid;
    - UDF_SB(sb)->s_gid = uopt.gid;
    - UDF_SB(sb)->s_umask = uopt.umask;
    + sbi->s_flags = uopt.flags;
    + sbi->s_uid = uopt.uid;
    + sbi->s_gid = uopt.gid;
    + sbi->s_umask = uopt.umask;

    - if (UDF_SB_LVIDBH(sb)) {
    - int write_rev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
    + if (sbi->s_lvid_bh) {
    + int write_rev = le16_to_cpu(udf_sb_lvidiu(sbi)->minUDFWriteRev);
    if (write_rev > UDF_MAX_WRITE_VERSION)
    *flags |= MS_RDONLY;
    }
    @@ -538,17 +547,19 @@ static int udf_vrs(struct super_block *sb, int silent)
    int iso9660 = 0;
    int nsr02 = 0;
    int nsr03 = 0;
    + struct udf_sb_info *sbi;

    /* Block size must be a multiple of 512 */
    if (sb->s_blocksize & 511)
    return 0;
    + sbi = UDF_SB(sb);

    if (sb->s_blocksize < sizeof(struct volStructDesc))
    sectorsize = sizeof(struct volStructDesc);
    else
    sectorsize = sb->s_blocksize;

    - sector += (UDF_SB_SESSION(sb) << sb->s_blocksize_bits);
    + sector += (sbi->s_session << sb->s_blocksize_bits);

    udf_debug("Starting at sector %u (%ld byte sectors)\n",
    (sector >> sb->s_blocksize_bits), sb->s_blocksize);
    @@ -614,7 +625,7 @@ static int udf_vrs(struct super_block *sb, int silent)
    return nsr03;
    else if (nsr02)
    return nsr02;
    - else if (sector - (UDF_SB_SESSION(sb) << sb->s_blocksize_bits) == 32768)
    + else if (sector - (sbi->s_session << sb->s_blocksize_bits) == 32768)
    return -1;
    else
    return 0;
    @@ -639,11 +650,15 @@ static int udf_vrs(struct super_block *sb, int silent)
    */
    static void udf_find_anchor(struct super_block *sb)
    {
    - int lastblock = UDF_SB_LASTBLOCK(sb);
    + int lastblock;
    struct buffer_head *bh = NULL;
    uint16_t ident;
    uint32_t location;
    int i;
    + struct udf_sb_info *sbi;
    +
    + sbi = UDF_SB(sb);
    + lastblock = sbi->s_last_block;

    if (lastblock) {
    int varlastblock = udf_variable_to_fixed(lastblock);
    @@ -675,22 +690,22 @@ static void udf_find_anchor(struct super_block *sb)
    }

    if (ident == TAG_IDENT_AVDP) {
    - if (location == last[i] - UDF_SB_SESSION(sb)) {
    - lastblock = last[i] - UDF_SB_SESSION(sb);
    - UDF_SB_ANCHOR(sb)[0] = lastblock;
    - UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
    - } else if (location == udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb)) {
    + if (location == last[i] - sbi->s_session) {
    + lastblock = last[i] - sbi->s_session;
    + sbi->s_anchor[0] = lastblock;
    + sbi->s_anchor[1] = lastblock - 256;
    + } else if (location == udf_variable_to_fixed(last[i]) - sbi->s_session) {
    UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
    - lastblock = udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb);
    - UDF_SB_ANCHOR(sb)[0] = lastblock;
    - UDF_SB_ANCHOR(sb)[1] = lastblock - 256 - UDF_SB_SESSION(sb);
    + lastblock = udf_variable_to_fixed(last[i]) - sbi->s_session;
    + sbi->s_anchor[0] = lastblock;
    + sbi->s_anchor[1] = lastblock - 256 - sbi->s_session;
    } else {
    udf_debug("Anchor found at block %d, location mismatch %d.\n",
    last[i], location);
    }
    } else if (ident == TAG_IDENT_FE || ident == TAG_IDENT_EFE) {
    lastblock = last[i];
    - UDF_SB_ANCHOR(sb)[3] = 512;
    + sbi->s_anchor[3] = 512;
    } else {
    ident = location = 0;
    if (last[i] >= 256) {
    @@ -704,13 +719,13 @@ static void udf_find_anchor(struct super_block *sb)
    }

    if (ident == TAG_IDENT_AVDP &&
    - location == last[i] - 256 - UDF_SB_SESSION(sb)) {
    + location == last[i] - 256 - sbi->s_session) {
    lastblock = last[i];
    - UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
    + sbi->s_anchor[1] = last[i] - 256;
    } else {
    ident = location = 0;
    - if (last[i] >= 312 + UDF_SB_SESSION(sb)) {
    - bh = sb_bread(sb, last[i] - 312 - UDF_SB_SESSION(sb));
    + if (last[i] >= 312 + sbi->s_session) {
    + bh = sb_bread(sb, last[i] - 312 - sbi->s_session);
    if (bh) {
    tag *t = (tag *)bh->b_data;
    ident = le16_to_cpu(t->tagIdent);
    @@ -723,7 +738,7 @@ static void udf_find_anchor(struct super_block *sb)
    location == udf_variable_to_fixed(last[i]) - 256) {
    UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
    lastblock = udf_variable_to_fixed(last[i]);
    - UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
    + sbi->s_anchor[1] = lastblock - 256;
    }
    }
    }
    @@ -732,7 +747,7 @@ static void udf_find_anchor(struct super_block *sb)

    if (!lastblock) {
    /* We haven't found the lastblock. check 312 */
    - bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb));
    + bh = sb_bread(sb, 312 + sbi->s_session);
    if (bh) {
    tag *t = (tag *)bh->b_data;
    ident = le16_to_cpu(t->tagIdent);
    @@ -744,22 +759,22 @@ static void udf_find_anchor(struct super_block *sb)
    }
    }

    - for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
    - if (UDF_SB_ANCHOR(sb)[i]) {
    - bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
    - UDF_SB_ANCHOR(sb)[i], &ident);
    + for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
    + if (sbi->s_anchor[i]) {
    + bh = udf_read_tagged(sb, sbi->s_anchor[i],
    + sbi->s_anchor[i], &ident);
    if (!bh)
    - UDF_SB_ANCHOR(sb)[i] = 0;
    + sbi->s_anchor[i] = 0;
    else {
    brelse(bh);
    if ((ident != TAG_IDENT_AVDP) &&
    (i || (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE)))
    - UDF_SB_ANCHOR(sb)[i] = 0;
    + sbi->s_anchor[i] = 0;
    }
    }
    }

    - UDF_SB_LASTBLOCK(sb) = lastblock;
    + sbi->s_last_block = lastblock;
    }

    static int udf_find_fileset(struct super_block *sb,
    @@ -769,6 +784,7 @@ static int udf_find_fileset(struct super_block *sb,
    struct buffer_head *bh = NULL;
    long lastblock;
    uint16_t ident;
    + struct udf_sb_info *sbi;

    if (fileset->logicalBlockNum != 0xFFFFFFFF ||
    fileset->partitionReferenceNum != 0xFFFF) {
    @@ -783,6 +799,7 @@ static int udf_find_fileset(struct super_block *sb,

    }

    + sbi = UDF_SB(sb);
    if (!bh) {
    /* Search backwards through the partitions */
    kernel_lb_addr newfileset;
    @@ -790,13 +807,14 @@ static int udf_find_fileset(struct super_block *sb,
    /* --> cvg: FIXME - is it reasonable? */
    return 1;

    - for (newfileset.partitionReferenceNum = UDF_SB_NUMPARTS(sb) - 1;
    + for (newfileset.partitionReferenceNum = sbi->s_partitions - 1;
    (newfileset.partitionReferenceNum != 0xFFFF &&
    fileset->logicalBlockNum == 0xFFFFFFFF &&
    fileset->partitionReferenceNum == 0xFFFF);
    newfileset.partitionReferenceNum--) {
    - lastblock = UDF_SB_PARTLEN(sb,
    - newfileset.partitionReferenceNum);
    + lastblock = sbi->s_partmaps
    + [newfileset.partitionReferenceNum]
    + .s_partition_len;
    newfileset.logicalBlockNum = 0;

    do {
    @@ -840,7 +858,7 @@ static int udf_find_fileset(struct super_block *sb,
    fileset->logicalBlockNum,
    fileset->partitionReferenceNum);

    - UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;
    + sbi->s_partition = fileset->partitionReferenceNum;
    udf_load_fileset(sb, bh, root);
    brelse(bh);
    return 0;
    @@ -867,15 +885,15 @@ static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
    recording, recording_usec,
    ts.year, ts.month, ts.day, ts.hour,
    ts.minute, ts.typeAndTimezone);
    - UDF_SB_RECORDTIME(sb).tv_sec = recording;
    - UDF_SB_RECORDTIME(sb).tv_nsec = recording_usec * 1000;
    + UDF_SB(sb)->s_record_time.tv_sec = recording;
    + UDF_SB(sb)->s_record_time.tv_nsec = recording_usec * 1000;
    }

    if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32)) {
    if (udf_CS0toUTF8(&outstr, &instr)) {
    - strncpy(UDF_SB_VOLIDENT(sb), outstr.u_name,
    + strncpy(UDF_SB(sb)->s_volume_ident, outstr.u_name,
    outstr.u_len > 31 ? 31 : outstr.u_len);
    - udf_debug("volIdent[] = '%s'\n", UDF_SB_VOLIDENT(sb));
    + udf_debug("volIdent[] = '%s'\n", UDF_SB(sb)->s_volume_ident);
    }
    }

    @@ -894,7 +912,7 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,

    *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);

    - UDF_SB_SERIALNUM(sb) = le16_to_cpu(fset->descTag.tagSerialNum);
    + UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);

    udf_debug("Rootdir at block=%d, partition=%d\n",
    root->logicalBlockNum, root->partitionReferenceNum);
    @@ -904,23 +922,27 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    {
    struct partitionDesc *p;
    int i;
    + struct udf_part_map *map;
    + struct udf_sb_info *sbi;

    p = (struct partitionDesc *)bh->b_data;
    + sbi = UDF_SB(sb);

    - for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
    + for (i = 0; i < sbi->s_partitions; i++) {
    + map = &sbi->s_partmaps[i];
    udf_debug("Searching map: (%d == %d)\n",
    - UDF_SB_PARTMAPS(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
    - if (UDF_SB_PARTMAPS(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
    - UDF_SB_PARTLEN(sb, i) = le32_to_cpu(p->partitionLength); /* blocks */
    - UDF_SB_PARTROOT(sb, i) = le32_to_cpu(p->partitionStartingLocation);
    + map->s_partition_num, le16_to_cpu(p->partitionNumber));
    + if (map->s_partition_num == le16_to_cpu(p->partitionNumber)) {
    + map->s_partition_len = le32_to_cpu(p->partitionLength); /* blocks */
    + map->s_partition_root = le32_to_cpu(p->partitionStartingLocation);
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_READ_ONLY)
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_READ_ONLY;
    + map->s_partition_flags |= UDF_PART_FLAG_READ_ONLY;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_WRITE_ONCE)
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_WRITE_ONCE;
    + map->s_partition_flags |= UDF_PART_FLAG_WRITE_ONCE;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_REWRITABLE)
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_REWRITABLE;
    + map->s_partition_flags |= UDF_PART_FLAG_REWRITABLE;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_OVERWRITABLE)
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_OVERWRITABLE;
    + map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE;

    if (!strcmp(p->partitionContents.ident,
    PD_PARTITION_CONTENTS_NSR02) ||
    @@ -935,26 +957,26 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    .partitionReferenceNum = i,
    };

    - UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table =
    + map->s_uspace.s_table =
    udf_iget(sb, loc);
    - if (!UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table) {
    + if (!map->s_uspace.s_table) {
    udf_debug("cannot load unallocSpaceTable (part %d)\n", i);
    return 1;
    }
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_UNALLOC_TABLE;
    + map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
    udf_debug("unallocSpaceTable (part %d) @ %ld\n",
    - i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table->i_ino);
    + i, map->s_uspace.s_table->i_ino);
    }
    if (phd->unallocSpaceBitmap.extLength) {
    UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
    - if (UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap != NULL) {
    - UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extLength =
    + if (map->s_uspace.s_bitmap != NULL) {
    + map->s_uspace.s_bitmap->s_extLength =
    le32_to_cpu(phd->unallocSpaceBitmap.extLength);
    - UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition =
    + map->s_uspace.s_bitmap->s_extPosition =
    le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
    + map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
    udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
    - i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition);
    + i, map->s_uspace.s_bitmap->s_extPosition);
    }
    }
    if (phd->partitionIntegrityTable.extLength)
    @@ -965,41 +987,42 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    .partitionReferenceNum = i,
    };

    - UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table =
    + map->s_fspace.s_table =
    udf_iget(sb, loc);
    - if (!UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table) {
    + if (!map->s_fspace.s_table) {
    udf_debug("cannot load freedSpaceTable (part %d)\n", i);
    return 1;
    }
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_FREED_TABLE;
    + map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;
    udf_debug("freedSpaceTable (part %d) @ %ld\n",
    - i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table->i_ino);
    + i, map->s_fspace.s_table->i_ino);
    }
    if (phd->freedSpaceBitmap.extLength) {
    UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
    - if (UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap != NULL) {
    - UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extLength =
    + if (map->s_fspace.s_bitmap != NULL) {
    + map->s_fspace.s_bitmap->s_extLength =
    le32_to_cpu(phd->freedSpaceBitmap.extLength);
    - UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition =
    + map->s_fspace.s_bitmap->s_extPosition =
    le32_to_cpu(phd->freedSpaceBitmap.extPosition);
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_FREED_BITMAP;
    + map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
    udf_debug("freedSpaceBitmap (part %d) @ %d\n",
    - i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition);
    + i, map->s_fspace.s_bitmap->s_extPosition);
    }
    }
    }
    break;
    }
    }
    - if (i == UDF_SB_NUMPARTS(sb)) {
    + if (i == sbi->s_partitions) {
    udf_debug("Partition (%d) not found in partition map\n",
    le16_to_cpu(p->partitionNumber));
    } else {
    udf_debug("Partition (%d:%d type %x) starts at physical %d, "
    "block length %d\n",
    le16_to_cpu(p->partitionNumber), i,
    - UDF_SB_PARTTYPE(sb, i), UDF_SB_PARTROOT(sb, i),
    - UDF_SB_PARTLEN(sb, i));
    + map->s_partition_type,
    + map->s_partition_root,
    + map->s_partition_len);
    }
    return 0;
    }
    @@ -1010,30 +1033,32 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
    struct logicalVolDesc *lvd;
    int i, j, offset;
    uint8_t type;
    + struct udf_sb_info *sbi = UDF_SB(sb);

    lvd = (struct logicalVolDesc *)bh->b_data;

    UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps));

    for (i = 0, offset = 0;
    - i < UDF_SB_NUMPARTS(sb) && offset < le32_to_cpu(lvd->mapTableLength);
    + i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
    i++, offset += ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapLength) {
    + struct udf_part_map *map = &sbi->s_partmaps[i];
    type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;
    if (type == 1) {
    struct genericPartitionMap1 *gpm1 = (struct genericPartitionMap1 *)&(lvd->partitionMaps[offset]);
    - UDF_SB_PARTTYPE(sb, i) = UDF_TYPE1_MAP15;
    - UDF_SB_PARTVSN(sb, i) = le16_to_cpu(gpm1->volSeqNum);
    - UDF_SB_PARTNUM(sb, i) = le16_to_cpu(gpm1->partitionNum);
    - UDF_SB_PARTFUNC(sb, i) = NULL;
    + map->s_partition_type = UDF_TYPE1_MAP15;
    + map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum);
    + map->s_partition_num = le16_to_cpu(gpm1->partitionNum);
    + map->s_partition_func = NULL;
    } else if (type == 2) {
    struct udfPartitionMap2 *upm2 = (struct udfPartitionMap2 *)&(lvd->partitionMaps[offset]);
    if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL))) {
    if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0150) {
    - UDF_SB_PARTTYPE(sb, i) = UDF_VIRTUAL_MAP15;
    - UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_virt15;
    + map->s_partition_type = UDF_VIRTUAL_MAP15;
    + map->s_partition_func = udf_get_pblock_virt15;
    } else if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0200) {
    - UDF_SB_PARTTYPE(sb, i) = UDF_VIRTUAL_MAP20;
    - UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_virt20;
    + map->s_partition_type = UDF_VIRTUAL_MAP20;
    + map->s_partition_func = udf_get_pblock_virt20;
    }
    } else if (!strncmp(upm2->partIdent.ident, UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE))) {
    uint32_t loc;
    @@ -1041,33 +1066,33 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
    struct sparingTable *st;
    struct sparablePartitionMap *spm = (struct sparablePartitionMap *)&(lvd->partitionMaps[offset]);

    - UDF_SB_PARTTYPE(sb, i) = UDF_SPARABLE_MAP15;
    - UDF_SB_TYPESPAR(sb, i).s_packet_len = le16_to_cpu(spm->packetLength);
    + map->s_partition_type = UDF_SPARABLE_MAP15;
    + map->s_type_specific.s_sparing.s_packet_len = le16_to_cpu(spm->packetLength);
    for (j = 0; j < spm->numSparingTables; j++) {
    loc = le32_to_cpu(spm->locSparingTable[j]);
    - UDF_SB_TYPESPAR(sb, i).s_spar_map[j] =
    + map->s_type_specific.s_sparing.s_spar_map[j] =
    udf_read_tagged(sb, loc, loc, &ident);
    - if (UDF_SB_TYPESPAR(sb, i).s_spar_map[j] != NULL) {
    - st = (struct sparingTable *)UDF_SB_TYPESPAR(sb, i).s_spar_map[j]->b_data;
    + if (map->s_type_specific.s_sparing.s_spar_map[j] != NULL) {
    + st = (struct sparingTable *)map->s_type_specific.s_sparing.s_spar_map[j]->b_data;
    if (ident != 0 ||
    strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING))) {
    - brelse(UDF_SB_TYPESPAR(sb, i).s_spar_map[j]);
    - UDF_SB_TYPESPAR(sb, i).s_spar_map[j] = NULL;
    + brelse(map->s_type_specific.s_sparing.s_spar_map[j]);
    + map->s_type_specific.s_sparing.s_spar_map[j] = NULL;
    }
    }
    }
    - UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_spar15;
    + map->s_partition_func = udf_get_pblock_spar15;
    } else {
    udf_debug("Unknown ident: %s\n",
    upm2->partIdent.ident);
    continue;
    }
    - UDF_SB_PARTVSN(sb, i) = le16_to_cpu(upm2->volSeqNum);
    - UDF_SB_PARTNUM(sb, i) = le16_to_cpu(upm2->partitionNum);
    + map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
    + map->s_partition_num = le16_to_cpu(upm2->partitionNum);
    }
    udf_debug("Partition (%d:%d) type %d on volume %d\n",
    - i, UDF_SB_PARTNUM(sb, i), type,
    - UDF_SB_PARTVSN(sb, i));
    + i, map->s_partition_num, type,
    + map->s_volumeseqnum);
    }

    if (fileset) {
    @@ -1092,23 +1117,26 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
    {
    struct buffer_head *bh = NULL;
    uint16_t ident;
    + struct udf_sb_info *sbi = UDF_SB(sb);
    + struct logicalVolIntegrityDesc *lvid;

    while (loc.extLength > 0 &&
    (bh = udf_read_tagged(sb, loc.extLocation,
    loc.extLocation, &ident)) &&
    ident == TAG_IDENT_LVID) {
    - UDF_SB_LVIDBH(sb) = bh;
    + sbi->s_lvid_bh = bh;
    + lvid = (struct logicalVolIntegrityDesc *)bh->b_data;

    - if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength)
    + if (lvid->nextIntegrityExt.extLength)
    udf_load_logicalvolint(sb,
    - leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
    + leea_to_cpu(lvid->nextIntegrityExt));

    - if (UDF_SB_LVIDBH(sb) != bh)
    + if (sbi->s_lvid_bh != bh)
    brelse(bh);
    loc.extLength -= sb->s_blocksize;
    loc.extLocation++;
    }
    - if (UDF_SB_LVIDBH(sb) != bh)
    + if (sbi->s_lvid_bh != bh)
    brelse(bh);
    }

    @@ -1259,10 +1287,11 @@ static int udf_check_valid(struct super_block *sb, int novrs, int silent)
    else {
    block = udf_vrs(sb, silent);
    if (block == -1) {
    + struct udf_sb_info *sbi = UDF_SB(sb);
    udf_debug("Failed to read byte 32768. Assuming open "
    "disc. Skipping validity check\n");
    - if (!UDF_SB_LASTBLOCK(sb))
    - UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
    + if (!sbi->s_last_block)
    + sbi->s_last_block = udf_get_last_block(sb);
    return 0;
    } else
    return !block;
    @@ -1276,14 +1305,16 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    struct buffer_head *bh;
    long main_s, main_e, reserve_s, reserve_e;
    int i, j;
    + struct udf_sb_info *sbi;

    if (!sb)
    return 1;
    + sbi = UDF_SB(sb);

    - for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
    - if (UDF_SB_ANCHOR(sb)[i] &&
    - (bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
    - UDF_SB_ANCHOR(sb)[i], &ident))) {
    + for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
    + if (sbi->s_anchor[i] &&
    + (bh = udf_read_tagged(sb, sbi->s_anchor[i],
    + sbi->s_anchor[i], &ident))) {
    anchor = (struct anchorVolDescPtr *)bh->b_data;

    /* Locate the main sequence */
    @@ -1308,68 +1339,72 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    }
    }

    - if (i == ARRAY_SIZE(UDF_SB_ANCHOR(sb))) {
    + if (i == ARRAY_SIZE(sbi->s_anchor)) {
    udf_debug("No Anchor block found\n");
    return 1;
    } else
    - udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]);
    + udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);

    - for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
    + for (i = 0; i < sbi->s_partitions; i++) {
    kernel_lb_addr uninitialized_var(ino);
    - switch (UDF_SB_PARTTYPE(sb, i)) {
    + struct udf_part_map *map = &sbi->s_partmaps[i];
    + switch (map->s_partition_type) {
    case UDF_VIRTUAL_MAP15:
    case UDF_VIRTUAL_MAP20:
    - if (!UDF_SB_LASTBLOCK(sb)) {
    - UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
    + if (!sbi->s_last_block) {
    + sbi->s_last_block = udf_get_last_block(sb);
    udf_find_anchor(sb);
    }

    - if (!UDF_SB_LASTBLOCK(sb)) {
    + if (!sbi->s_last_block) {
    udf_debug("Unable to determine Lastblock (For "
    "Virtual Partition)\n");
    return 1;
    }

    - for (j = 0; j < UDF_SB_NUMPARTS(sb); j++) {
    + for (j = 0; j < sbi->s_partitions; j++) {
    + struct udf_part_map *map2 = &sbi->s_partmaps[j];
    if (j != i &&
    - UDF_SB_PARTVSN(sb, i) == UDF_SB_PARTVSN(sb, j) &&
    - UDF_SB_PARTNUM(sb, i) == UDF_SB_PARTNUM(sb, j)) {
    + map->s_volumeseqnum == map2->s_volumeseqnum &&
    + map->s_partition_num == map2->s_partition_num) {
    ino.partitionReferenceNum = j;
    - ino.logicalBlockNum = UDF_SB_LASTBLOCK(sb) - UDF_SB_PARTROOT(sb, j);
    + ino.logicalBlockNum = sbi->s_last_block - map2->s_partition_root;
    break;
    }
    }

    - if (j == UDF_SB_NUMPARTS(sb))
    + if (j == sbi->s_partitions)
    return 1;

    - UDF_SB_VAT(sb) = udf_iget(sb, ino);
    - if (!UDF_SB_VAT(sb))
    + sbi->s_vat_inode = udf_iget(sb, ino);
    + if (!sbi->s_vat_inode)
    return 1;

    - if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
    - UDF_SB_TYPEVIRT(sb, i).s_start_offset =
    - udf_ext0_offset(UDF_SB_VAT(sb));
    - UDF_SB_TYPEVIRT(sb, i).s_num_entries =
    - (UDF_SB_VAT(sb)->i_size - 36) >> 2;
    - } else if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP20) {
    + if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
    + map->s_type_specific.s_virtual.s_start_offset =
    + udf_ext0_offset(sbi->s_vat_inode);
    + map->s_type_specific.s_virtual.s_num_entries =
    + (sbi->s_vat_inode->i_size - 36) >> 2;
    + } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) {
    struct buffer_head *bh = NULL;
    uint32_t pos;

    - pos = udf_block_map(UDF_SB_VAT(sb), 0);
    + pos = udf_block_map(sbi->s_vat_inode, 0);
    bh = sb_bread(sb, pos);
    if (!bh)
    return 1;
    - UDF_SB_TYPEVIRT(sb, i).s_start_offset =
    + map->s_type_specific.s_virtual.s_start_offset =
    le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data +
    - udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) +
    - udf_ext0_offset(UDF_SB_VAT(sb));
    - UDF_SB_TYPEVIRT(sb, i).s_num_entries = (UDF_SB_VAT(sb)->i_size -
    - UDF_SB_TYPEVIRT(sb, i).s_start_offset) >> 2;
    + udf_ext0_offset(sbi->s_vat_inode))->lengthHeader) +
    + udf_ext0_offset(sbi->s_vat_inode);
    + map->s_type_specific.s_virtual.s_num_entries = (sbi->s_vat_inode->i_size -
    + map->s_type_specific.s_virtual.s_start_offset) >> 2;
    brelse(bh);
    }
    - UDF_SB_PARTROOT(sb, i) = udf_get_pblock(sb, 0, i, 0);
    - UDF_SB_PARTLEN(sb, i) = UDF_SB_PARTLEN(sb, ino.partitionReferenceNum);
    + map->s_partition_root = udf_get_pblock(sb, 0, i, 0);
    + map->s_partition_len =
    + sbi->s_partmaps[ino.partitionReferenceNum].
    + s_partition_len;
    }
    }
    return 0;
    @@ -1377,26 +1412,30 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)

    static void udf_open_lvid(struct super_block *sb)
    {
    - if (UDF_SB_LVIDBH(sb)) {
    + struct udf_sb_info *sbi = UDF_SB(sb);
    + struct buffer_head *bh = sbi->s_lvid_bh;
    + if (bh) {
    int i;
    kernel_timestamp cpu_time;
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
    + struct logicalVolIntegrityDescImpUse *lvidiu = udf_sb_lvidiu(sbi);

    - UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
    - UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
    + lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
    + lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
    if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
    - UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
    - UDF_SB_LVID(sb)->integrityType = LVID_INTEGRITY_TYPE_OPEN;
    + lvid->recordingDateAndTime = cpu_to_lets(cpu_time);
    + lvid->integrityType = LVID_INTEGRITY_TYPE_OPEN;

    - UDF_SB_LVID(sb)->descTag.descCRC = cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
    - le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
    + lvid->descTag.descCRC = cpu_to_le16(udf_crc((char *)lvid + sizeof(tag),
    + le16_to_cpu(lvid->descTag.descCRCLength), 0));

    - UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
    + lvid->descTag.tagChecksum = 0;
    for (i = 0; i < 16; i++)
    if (i != 4)
    - UDF_SB_LVID(sb)->descTag.tagChecksum +=
    - ((uint8_t *) &(UDF_SB_LVID(sb)->descTag))[i];
    + lvid->descTag.tagChecksum +=
    + ((uint8_t *) &(lvid->descTag))[i];

    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + mark_buffer_dirty(bh);
    }
    }

    @@ -1404,32 +1443,40 @@ static void udf_close_lvid(struct super_block *sb)
    {
    kernel_timestamp cpu_time;
    int i;
    -
    - if (UDF_SB_LVIDBH(sb) &&
    - UDF_SB_LVID(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
    - UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
    - UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
    + struct udf_sb_info *sbi = UDF_SB(sb);
    + struct buffer_head *bh = sbi->s_lvid_bh;
    + struct logicalVolIntegrityDesc *lvid;
    +
    + if (!bh)
    + return;
    +
    + lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
    +
    + if (lvid->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
    + struct logicalVolIntegrityDescImpUse *lvidiu = udf_sb_lvidiu(sbi);
    + lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
    + lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
    if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
    - UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
    - if (UDF_MAX_WRITE_VERSION > le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
    - UDF_SB_LVIDIU(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
    - if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
    - UDF_SB_LVIDIU(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    - if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
    - UDF_SB_LVIDIU(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    - UDF_SB_LVID(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
    -
    - UDF_SB_LVID(sb)->descTag.descCRC =
    - cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
    - le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
    -
    - UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
    + lvid->recordingDateAndTime = cpu_to_lets(cpu_time);
    + if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev))
    + lvidiu->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
    + if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev))
    + lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev);
    + if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev))
    + lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev);
    + lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
    +
    + lvid->descTag.descCRC =
    + cpu_to_le16(udf_crc((char *)lvid + sizeof(tag),
    + le16_to_cpu(lvid->descTag.descCRCLength), 0));
    +
    + lvid->descTag.tagChecksum = 0;
    for (i = 0; i < 16; i++)
    if (i != 4)
    - UDF_SB_LVID(sb)->descTag.tagChecksum +=
    - ((uint8_t *)&(UDF_SB_LVID(sb)->descTag))[i];
    + lvid->descTag.tagChecksum +=
    + ((uint8_t *)&(lvid->descTag))[i];

    - mark_buffer_dirty(UDF_SB_LVIDBH(sb));
    + mark_buffer_dirty(bh);
    }
    }

    @@ -1462,12 +1509,11 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    uopt.gid = -1;
    uopt.umask = 0;

    - sbi = kmalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
    + sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
    if (!sbi)
    return -ENOMEM;

    sb->s_fs_info = sbi;
    - memset(UDF_SB(sb), 0x00, sizeof(struct udf_sb_info));

    mutex_init(&sbi->s_alloc_mutex);

    @@ -1495,27 +1541,27 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    fileset.logicalBlockNum = 0xFFFFFFFF;
    fileset.partitionReferenceNum = 0xFFFF;

    - UDF_SB(sb)->s_flags = uopt.flags;
    - UDF_SB(sb)->s_uid = uopt.uid;
    - UDF_SB(sb)->s_gid = uopt.gid;
    - UDF_SB(sb)->s_umask = uopt.umask;
    - UDF_SB(sb)->s_nls_map = uopt.nls_map;
    + sbi->s_flags = uopt.flags;
    + sbi->s_uid = uopt.uid;
    + sbi->s_gid = uopt.gid;
    + sbi->s_umask = uopt.umask;
    + sbi->s_nls_map = uopt.nls_map;

    /* Set the block size for all transfers */
    if (!udf_set_blocksize(sb, uopt.blocksize))
    goto error_out;

    if (uopt.session == 0xFFFFFFFF)
    - UDF_SB_SESSION(sb) = udf_get_last_session(sb);
    + sbi->s_session = udf_get_last_session(sb);
    else
    - UDF_SB_SESSION(sb) = uopt.session;
    + sbi->s_session = uopt.session;

    - udf_debug("Multi-session=%d\n", UDF_SB_SESSION(sb));
    + udf_debug("Multi-session=%d\n", sbi->s_session);

    - UDF_SB_LASTBLOCK(sb) = uopt.lastblock;
    - UDF_SB_ANCHOR(sb)[0] = UDF_SB_ANCHOR(sb)[1] = 0;
    - UDF_SB_ANCHOR(sb)[2] = uopt.anchor;
    - UDF_SB_ANCHOR(sb)[3] = 256;
    + sbi->s_last_block = uopt.lastblock;
    + sbi->s_anchor[0] = sbi->s_anchor[1] = 0;
    + sbi->s_anchor[2] = uopt.anchor;
    + sbi->s_anchor[3] = 256;

    if (udf_check_valid(sb, uopt.novrs, silent)) {
    /* read volume recognition sequences */
    @@ -1537,23 +1583,24 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    goto error_out;
    }

    - udf_debug("Lastblock=%d\n", UDF_SB_LASTBLOCK(sb));
    + udf_debug("Lastblock=%d\n", sbi->s_last_block);

    - if (UDF_SB_LVIDBH(sb)) {
    - uint16_t minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
    - uint16_t minUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
    - /* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDescImpUse *lvidiu = udf_sb_lvidiu(sbi);
    + uint16_t minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev);
    + uint16_t minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev);
    + /* uint16_t maxUDFWriteRev = le16_to_cpu(lvidiu->maxUDFWriteRev); */

    if (minUDFReadRev > UDF_MAX_READ_VERSION) {
    printk(KERN_ERR "UDF-fs: minUDFReadRev=%x (max is %x)\n",
    - le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev),
    + le16_to_cpu(lvidiu->minUDFReadRev),
    UDF_MAX_READ_VERSION);
    goto error_out;
    } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION) {
    sb->s_flags |= MS_RDONLY;
    }

    - UDF_SB_UDFREV(sb) = minUDFWriteRev;
    + sbi->s_udfrev = minUDFWriteRev;

    if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
    UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
    @@ -1561,12 +1608,12 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
    }

    - if (!UDF_SB_NUMPARTS(sb)) {
    + if (!sbi->s_partitions) {
    printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
    goto error_out;
    }

    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_READ_ONLY) {
    + if (sbi->s_partmaps[sbi->s_partition].s_partition_flags & UDF_PART_FLAG_READ_ONLY) {
    printk(KERN_NOTICE "UDF-fs: Partition marked readonly; forcing readonly mount\n");
    sb->s_flags |= MS_RDONLY;
    }
    @@ -1578,12 +1625,12 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)

    if (!silent) {
    kernel_timestamp ts;
    - udf_time_to_stamp(&ts, UDF_SB_RECORDTIME(sb));
    + udf_time_to_stamp(&ts, sbi->s_record_time);
    udf_info("UDF %s (%s) Mounting volume '%s', "
    "timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
    UDFFS_VERSION, UDFFS_DATE,
    - UDF_SB_VOLIDENT(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute,
    - ts.typeAndTimezone);
    + sbi->s_volume_ident, ts.year, ts.month, ts.day,
    + ts.hour, ts.minute, ts.typeAndTimezone);
    }
    if (!(sb->s_flags & MS_RDONLY))
    udf_open_lvid(sb);
    @@ -1609,30 +1656,31 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    return 0;

    error_out:
    - if (UDF_SB_VAT(sb))
    - iput(UDF_SB_VAT(sb));
    - if (UDF_SB_NUMPARTS(sb)) {
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    - iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
    - iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
    - UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
    - UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
    - if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
    + if (sbi->s_vat_inode)
    + iput(sbi->s_vat_inode);
    + if (sbi->s_partitions) {
    + struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition];
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
    + iput(map->s_uspace.s_table);
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
    + iput(map->s_fspace.s_table);
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
    + UDF_SB_FREE_BITMAP(sb, sbi->s_partition, s_uspace);
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
    + UDF_SB_FREE_BITMAP(sb, sbi->s_partition, s_fspace);
    + if (map->s_partition_type == UDF_SPARABLE_MAP15)
    for (i = 0; i < 4; i++)
    - brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
    - }
    + brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
    }
    #ifdef CONFIG_UDF_NLS
    if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
    - unload_nls(UDF_SB(sb)->s_nls_map);
    + unload_nls(sbi->s_nls_map);
    #endif
    if (!(sb->s_flags & MS_RDONLY))
    udf_close_lvid(sb);
    - brelse(UDF_SB_LVIDBH(sb));
    - UDF_SB_FREE(sb);
    + brelse(sbi->s_lvid_bh);
    +
    + kfree(sbi->s_partmaps);
    kfree(sbi);
    sb->s_fs_info = NULL;

    @@ -1683,31 +1731,33 @@ void udf_warning(struct super_block *sb, const char *function,
    static void udf_put_super(struct super_block *sb)
    {
    int i;
    + struct udf_sb_info *sbi;

    - if (UDF_SB_VAT(sb))
    - iput(UDF_SB_VAT(sb));
    - if (UDF_SB_NUMPARTS(sb)) {
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    - iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
    - iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
    - UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
    - UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
    - if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
    + sbi = UDF_SB(sb);
    + if (sbi->s_vat_inode)
    + iput(sbi->s_vat_inode);
    + if (sbi->s_partitions) {
    + struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition];
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
    + iput(map->s_uspace.s_table);
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
    + iput(map->s_fspace.s_table);
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
    + UDF_SB_FREE_BITMAP(sb, sbi->s_partition, s_uspace);
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
    + UDF_SB_FREE_BITMAP(sb, sbi->s_partition, s_fspace);
    + if (map->s_partition_type == UDF_SPARABLE_MAP15)
    for (i = 0; i < 4; i++)
    - brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
    - }
    + brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
    }
    #ifdef CONFIG_UDF_NLS
    if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
    - unload_nls(UDF_SB(sb)->s_nls_map);
    + unload_nls(sbi->s_nls_map);
    #endif
    if (!(sb->s_flags & MS_RDONLY))
    udf_close_lvid(sb);
    - brelse(UDF_SB_LVIDBH(sb));
    - UDF_SB_FREE(sb);
    + brelse(sbi->s_lvid_bh);
    + kfree(sbi->s_partmaps);
    kfree(sb->s_fs_info);
    sb->s_fs_info = NULL;
    }
    @@ -1728,15 +1778,22 @@ static void udf_put_super(struct super_block *sb)
    static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
    {
    struct super_block *sb = dentry->d_sb;
    + struct udf_sb_info *sbi = UDF_SB(sb);
    + struct logicalVolIntegrityDescImpUse *lvidiu;
    +
    + if (sbi->s_lvid_bh != NULL)
    + lvidiu = udf_sb_lvidiu(sbi);
    + else
    + lvidiu = NULL;

    buf->f_type = UDF_SUPER_MAGIC;
    buf->f_bsize = sb->s_blocksize;
    - buf->f_blocks = UDF_SB_PARTLEN(sb, UDF_SB_PARTITION(sb));
    + buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len;
    buf->f_bfree = udf_count_free(sb);
    buf->f_bavail = buf->f_bfree;
    - buf->f_files = (UDF_SB_LVIDBH(sb) ?
    - (le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) +
    - le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) + buf->f_bfree;
    + buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) +
    + le32_to_cpu(lvidiu->numDirs)) : 0)
    + + buf->f_bfree;
    buf->f_ffree = buf->f_bfree;
    /* __kernel_fsid_t f_fsid */
    buf->f_namelen = UDF_NAME_LEN - 2;
    @@ -1764,7 +1821,7 @@ static unsigned int udf_count_free_bitmap(struct super_block *sb, struct udf_bit
    lock_kernel();

    loc.logicalBlockNum = bitmap->s_extPosition;
    - loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
    + loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
    bh = udf_read_ptagged(sb, loc, 0, &ident);

    if (!bh) {
    @@ -1836,10 +1893,14 @@ static unsigned int udf_count_free_table(struct super_block *sb, struct inode *t
    static unsigned int udf_count_free(struct super_block *sb)
    {
    unsigned int accum = 0;
    + struct udf_sb_info *sbi;
    + struct udf_part_map *map;

    - if (UDF_SB_LVIDBH(sb)) {
    - if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) > UDF_SB_PARTITION(sb)) {
    - accum = le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]);
    + sbi = UDF_SB(sb);
    + if (sbi->s_lvid_bh) {
    + struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    + if (le32_to_cpu(lvid->numOfPartitions) > sbi->s_partition) {
    + accum = le32_to_cpu(lvid->freeSpaceTable[sbi->s_partition]);
    if (accum == 0xFFFFFFFF)
    accum = 0;
    }
    @@ -1848,24 +1909,25 @@ static unsigned int udf_count_free(struct super_block *sb)
    if (accum)
    return accum;

    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + map = &sbi->s_partmaps[sbi->s_partition];
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
    accum += udf_count_free_bitmap(sb,
    - UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
    + map->s_uspace.s_bitmap);
    }
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) {
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
    accum += udf_count_free_bitmap(sb,
    - UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
    + map->s_fspace.s_bitmap);
    }
    if (accum)
    return accum;

    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
    accum += udf_count_free_table(sb,
    - UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    + map->s_uspace.s_table);
    }
    - if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) {
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
    accum += udf_count_free_table(sb,
    - UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    + map->s_fspace.s_table);
    }

    return accum;
    diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
    index 7fc3912..6931f6b 100644
    --- a/fs/udf/truncate.c
    +++ b/fs/udf/truncate.c
    @@ -163,7 +163,7 @@ void udf_discard_prealloc(struct inode *inode)
    cpu_to_le32(epos.offset -
    sizeof(struct allocExtDesc));
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
    udf_update_tag(epos.bh->b_data, epos.offset);
    else
    udf_update_tag(epos.bh->b_data,
    @@ -184,6 +184,7 @@ void udf_truncate_extents(struct inode *inode)
    uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc;
    int8_t etype;
    struct super_block *sb = inode->i_sb;
    + struct udf_sb_info *sbi = UDF_SB(sb);
    sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;
    loff_t byte_offset;
    int adsize;
    @@ -232,7 +233,7 @@ void udf_truncate_extents(struct inode *inode)
    aed->lengthAllocDescs =
    cpu_to_le32(lenalloc);
    if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(sb) >= 0x0201)
    + sbi->s_udfrev >= 0x0201)
    udf_update_tag(epos.bh->b_data,
    lenalloc +
    sizeof(struct allocExtDesc));
    @@ -271,7 +272,7 @@ void udf_truncate_extents(struct inode *inode)
    (struct allocExtDesc *)(epos.bh->b_data);
    aed->lengthAllocDescs = cpu_to_le32(lenalloc);
    if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(sb) >= 0x0201)
    + sbi->s_udfrev >= 0x0201)
    udf_update_tag(epos.bh->b_data,
    lenalloc + sizeof(struct allocExtDesc));
    else
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index 3c29820..92e6d75 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -41,40 +41,36 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
    return sb->s_fs_info;
    }

    -#define UDF_SB_FREE(X)\
    -{\
    - if (UDF_SB(X)) {\
    - kfree(UDF_SB_PARTMAPS(X));\
    - UDF_SB_PARTMAPS(X) = NULL;\
    - }\
    -}
    +struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi);

    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    - UDF_SB_PARTMAPS(X) = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    - if (UDF_SB_PARTMAPS(X) != NULL) {\
    - UDF_SB_NUMPARTS(X) = Y;\
    - memset(UDF_SB_PARTMAPS(X), 0x00, sizeof(struct udf_part_map) * Y);\
    + struct udf_sb_info *sbi = UDF_SB(X);\
    + sbi->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    + if (sbi->s_partmaps != NULL) {\
    + sbi->s_partitions = Y;\
    + memset(sbi->s_partmaps, 0x00, sizeof(struct udf_part_map) * Y);\
    } else {\
    - UDF_SB_NUMPARTS(X) = 0;\
    + sbi->s_partitions = 0;\
    udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\
    }\
    }

    #define UDF_SB_ALLOC_BITMAP(X,Y,Z)\
    {\
    - int nr_groups = ((UDF_SB_PARTLEN((X),(Y)) + (sizeof(struct spaceBitmapDesc) << 3) +\
    + struct udf_sb_info *sbi = UDF_SB(X);\
    + int nr_groups = ((sbi->s_partmaps[(Y)].s_partition_len + (sizeof(struct spaceBitmapDesc) << 3) +\
    ((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\
    int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
    if (size <= PAGE_SIZE)\
    - UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
    + sbi->s_partmaps[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
    else\
    - UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = vmalloc(size);\
    - if (UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap != NULL) {\
    - memset(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap, 0x00, size);\
    - UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap =\
    - (struct buffer_head **)(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap + 1);\
    - UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
    + sbi->s_partmaps[(Y)].Z.s_bitmap = vmalloc(size);\
    + if (sbi->s_partmaps[(Y)].Z.s_bitmap != NULL) {\
    + memset(sbi->s_partmaps[(Y)].Z.s_bitmap, 0x00, size);\
    + sbi->s_partmaps[(Y)].Z.s_bitmap->s_block_bitmap =\
    + (struct buffer_head **)(sbi->s_partmaps[(Y)].Z.s_bitmap + 1);\
    + sbi->s_partmaps[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
    } else {\
    udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\
    }\
    @@ -90,47 +86,16 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
    brelse(UDF_SB_BITMAP(X,Y,Z,i));\
    }\
    if (size <= PAGE_SIZE)\
    - kfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\
    + kfree(UDF_SB(X)->s_partmaps[Y].Z.s_bitmap);\
    else\
    - vfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\
    + vfree(UDF_SB(X)->s_partmaps[Y].Z.s_bitmap);\
    }

    #define UDF_QUERY_FLAG(X,Y) ( UDF_SB(X)->s_flags & ( 1 << (Y) ) )
    #define UDF_SET_FLAG(X,Y) ( UDF_SB(X)->s_flags |= ( 1 << (Y) ) )
    #define UDF_CLEAR_FLAG(X,Y) ( UDF_SB(X)->s_flags &= ~( 1 << (Y) ) )

    -#define UDF_UPDATE_UDFREV(X,Y) ( ((Y) > UDF_SB_UDFREV(X)) ? UDF_SB_UDFREV(X) = (Y) : UDF_SB_UDFREV(X) )
    -
    -#define UDF_SB_PARTMAPS(X) ( UDF_SB(X)->s_partmaps )
    -#define UDF_SB_PARTTYPE(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_type )
    -#define UDF_SB_PARTROOT(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_root )
    -#define UDF_SB_PARTLEN(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_len )
    -#define UDF_SB_PARTVSN(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_volumeseqnum )
    -#define UDF_SB_PARTNUM(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_num )
    -#define UDF_SB_TYPESPAR(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_type_specific.s_sparing )
    -#define UDF_SB_TYPEVIRT(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_type_specific.s_virtual )
    -#define UDF_SB_PARTFUNC(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_func )
    -#define UDF_SB_PARTFLAGS(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_flags )
    -#define UDF_SB_BITMAP(X,Y,Z,I) ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    -#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups )
    -
    -#define UDF_SB_VOLIDENT(X) ( UDF_SB(X)->s_volident )
    -#define UDF_SB_NUMPARTS(X) ( UDF_SB(X)->s_partitions )
    -#define UDF_SB_PARTITION(X) ( UDF_SB(X)->s_partition )
    -#define UDF_SB_SESSION(X) ( UDF_SB(X)->s_session )
    -#define UDF_SB_ANCHOR(X) ( UDF_SB(X)->s_anchor )
    -#define UDF_SB_LASTBLOCK(X) ( UDF_SB(X)->s_lastblock )
    -#define UDF_SB_LVIDBH(X) ( UDF_SB(X)->s_lvidbh )
    -#define UDF_SB_LVID(X) ( (struct logicalVolIntegrityDesc *)UDF_SB_LVIDBH(X)->b_data )
    -#define UDF_SB_LVIDIU(X) ( (struct logicalVolIntegrityDescImpUse *)&(UDF_SB_LVID(X)->impUse[le32_to_cpu(UDF_SB_LVID(X)->numOfPartitions) * 2 * sizeof(uint32_t)/sizeof(uint8_t)]) )
    -
    -#define UDF_SB_UMASK(X) ( UDF_SB(X)->s_umask )
    -#define UDF_SB_GID(X) ( UDF_SB(X)->s_gid )
    -#define UDF_SB_UID(X) ( UDF_SB(X)->s_uid )
    -#define UDF_SB_RECORDTIME(X) ( UDF_SB(X)->s_recordtime )
    -#define UDF_SB_SERIALNUM(X) ( UDF_SB(X)->s_serialnum )
    -#define UDF_SB_UDFREV(X) ( UDF_SB(X)->s_udfrev )
    -#define UDF_SB_FLAGS(X) ( UDF_SB(X)->s_flags )
    -#define UDF_SB_VAT(X) ( UDF_SB(X)->s_vat )
    +#define UDF_SB_BITMAP(X,Y,Z,I) ( UDF_SB(X)->s_partmaps[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    +#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( UDF_SB(X)->s_partmaps[(Y)].Z.s_bitmap->s_nr_groups )

    #endif /* __LINUX_UDF_SB_H */
    diff --git a/include/linux/udf_fs_sb.h b/include/linux/udf_fs_sb.h
    index 80ae9ef..9bc4735 100644
    --- a/include/linux/udf_fs_sb.h
    +++ b/include/linux/udf_fs_sb.h
    @@ -75,7 +75,7 @@ struct udf_part_map
    struct udf_sb_info
    {
    struct udf_part_map *s_partmaps;
    - __u8 s_volident[32];
    + __u8 s_volume_ident[32];

    /* Overall info */
    __u16 s_partitions;
    @@ -84,9 +84,9 @@ struct udf_sb_info
    /* Sector headers */
    __s32 s_session;
    __u32 s_anchor[4];
    - __u32 s_lastblock;
    + __u32 s_last_block;

    - struct buffer_head *s_lvidbh;
    + struct buffer_head *s_lvid_bh;

    /* Default permissions */
    mode_t s_umask;
    @@ -94,10 +94,10 @@ struct udf_sb_info
    uid_t s_uid;

    /* Root Info */
    - struct timespec s_recordtime;
    + struct timespec s_record_time;

    /* Fileset Info */
    - __u16 s_serialnum;
    + __u16 s_serial_number;

    /* highest UDF revision we have recorded to this media */
    __u16 s_udfrev;
    @@ -109,7 +109,7 @@ struct udf_sb_info
    struct nls_table *s_nls_map;

    /* VAT inode */
    - struct inode *s_vat;
    + struct inode *s_vat_inode;

    struct mutex s_alloc_mutex;
    };
    --
    1.5.3.7

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  2. [PATCH 09/16] udf: create common function for tag checksumming

    Signed-off-by: Marcin Slusarz
    CC: Jan Kara
    CC: Christoph Hellwig
    ---
    fs/udf/inode.c | 15 ++-------------
    fs/udf/misc.c | 35 ++++++++++++++---------------------
    fs/udf/namei.c | 9 +--------
    fs/udf/super.c | 16 ++--------------
    fs/udf/udfdecl.h | 3 +++
    5 files changed, 22 insertions(+), 56 deletions(-)

    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index 9adde18..6751945 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -1440,7 +1440,6 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    uint32_t udfperms;
    uint16_t icbflags;
    uint16_t crclen;
    - int i;
    kernel_timestamp cpu_time;
    int err = 0;
    struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
    @@ -1476,12 +1475,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use +
    sizeof(tag), crclen,
    0));
    -
    - use->descTag.tagChecksum = 0;
    - for (i = 0; i < 16; i++)
    - if (i != 4)
    - use->descTag.tagChecksum +=
    - ((uint8_t *)&(use->descTag))[i];
    + use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);

    mark_buffer_dirty(bh);
    brelse(bh);
    @@ -1650,12 +1644,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    fe->descTag.descCRCLength = cpu_to_le16(crclen);
    fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag),
    crclen, 0));
    -
    - fe->descTag.tagChecksum = 0;
    - for (i = 0; i < 16; i++)
    - if (i != 4)
    - fe->descTag.tagChecksum +=
    - ((uint8_t *)&(fe->descTag))[i];
    + fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);

    /* write the data blocks */
    mark_buffer_dirty(bh);
    diff --git a/fs/udf/misc.c b/fs/udf/misc.c
    index a0bf415..585e4ea 100644
    --- a/fs/udf/misc.c
    +++ b/fs/udf/misc.c
    @@ -51,7 +51,6 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    uint8_t *ea = NULL, *ad = NULL;
    int offset;
    uint16_t crclen;
    - int i;

    ea = UDF_I_DATA(inode);
    if (UDF_I_LENEATTR(inode)) {
    @@ -138,11 +137,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    eahd->descTag.descCRCLength = cpu_to_le16(crclen);
    eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
    sizeof(tag), crclen, 0));
    - eahd->descTag.tagChecksum = 0;
    - for (i = 0; i < 16; i++)
    - if (i != 4)
    - eahd->descTag.tagChecksum +=
    - ((uint8_t *)&(eahd->descTag))[i];
    + eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag);
    UDF_I_LENEATTR(inode) += size;
    return (struct genericFormat *)&ea[offset];
    }
    @@ -207,8 +202,6 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
    {
    tag *tag_p;
    struct buffer_head *bh = NULL;
    - register uint8_t checksum;
    - register int i;
    struct udf_sb_info *sbi = UDF_SB(sb);

    /* Read the block */
    @@ -234,12 +227,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
    }

    /* Verify the tag checksum */
    - checksum = 0U;
    - for (i = 0; i < 4; i++)
    - checksum += (uint8_t)(bh->b_data[i]);
    - for (i = 5; i < 16; i++)
    - checksum += (uint8_t)(bh->b_data[i]);
    - if (checksum != tag_p->tagChecksum) {
    + if (udf_tag_checksum(tag_p) != tag_p->tagChecksum) {
    printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
    goto error_out;
    }
    @@ -277,17 +265,11 @@ struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
    void udf_update_tag(char *data, int length)
    {
    tag *tptr = (tag *)data;
    - int i;
    -
    length -= sizeof(tag);

    - tptr->tagChecksum = 0;
    tptr->descCRCLength = cpu_to_le16(length);
    tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0));
    -
    - for (i = 0; i < 16; i++)
    - if (i != 4)
    - tptr->tagChecksum += (uint8_t)(data[i]);
    + tptr->tagChecksum = udf_tag_checksum(tptr);
    }

    void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
    @@ -300,3 +282,14 @@ void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
    tptr->tagLocation = cpu_to_le32(loc);
    udf_update_tag(data, length);
    }
    +
    +u8 udf_tag_checksum(const tag *t)
    +{
    + u8 *data = (u8 *)t;
    + u8 checksum = 0;
    + int i;
    + for (i = 0; i < sizeof(tag); ++i)
    + if (i != 4) /* position of checksum */
    + checksum += data[i];
    + return checksum;
    +}
    diff --git a/fs/udf/namei.c b/fs/udf/namei.c
    index 25d518b..f1cf18f 100644
    --- a/fs/udf/namei.c
    +++ b/fs/udf/namei.c
    @@ -47,8 +47,6 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
    {
    uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag);
    uint16_t crc;
    - uint8_t checksum = 0;
    - int i;
    int offset;
    uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse);
    uint8_t lfi = cfi->lengthFileIdent;
    @@ -122,13 +120,8 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,

    cfi->descTag.descCRC = cpu_to_le16(crc);
    cfi->descTag.descCRCLength = cpu_to_le16(crclen);
    + cfi->descTag.tagChecksum = udf_tag_checksum(&cfi->descTag);

    - for (i = 0; i < 16; i++) {
    - if (i != 4)
    - checksum += ((uint8_t *)&cfi->descTag)[i];
    - }
    -
    - cfi->descTag.tagChecksum = checksum;
    if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) {
    memcpy((uint8_t *)sfi, (uint8_t *)cfi,
    sizeof(struct fileIdentDesc));
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 7f75a94..12fb91d 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1564,7 +1564,6 @@ static void udf_open_lvid(struct super_block *sb)
    struct udf_sb_info *sbi = UDF_SB(sb);
    struct buffer_head *bh = sbi->s_lvid_bh;
    if (bh) {
    - int i;
    kernel_timestamp cpu_time;
    struct logicalVolIntegrityDesc *lvid =
    (struct logicalVolIntegrityDesc *)bh->b_data;
    @@ -1582,12 +1581,7 @@ static void udf_open_lvid(struct super_block *sb)
    le16_to_cpu(lvid->descTag.descCRCLength),
    0));

    - lvid->descTag.tagChecksum = 0;
    - for (i = 0; i < 16; i++)
    - if (i != 4)
    - lvid->descTag.tagChecksum +=
    - ((uint8_t *) &(lvid->descTag))[i];
    -
    + lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
    mark_buffer_dirty(bh);
    }
    }
    @@ -1595,7 +1589,6 @@ static void udf_open_lvid(struct super_block *sb)
    static void udf_close_lvid(struct super_block *sb)
    {
    kernel_timestamp cpu_time;
    - int i;
    struct udf_sb_info *sbi = UDF_SB(sb);
    struct buffer_head *bh = sbi->s_lvid_bh;
    struct logicalVolIntegrityDesc *lvid;
    @@ -1626,12 +1619,7 @@ static void udf_close_lvid(struct super_block *sb)
    le16_to_cpu(lvid->descTag.descCRCLength),
    0));

    - lvid->descTag.tagChecksum = 0;
    - for (i = 0; i < 16; i++)
    - if (i != 4)
    - lvid->descTag.tagChecksum +=
    - ((uint8_t *)&(lvid->descTag))[i];
    -
    + lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
    mark_buffer_dirty(bh);
    }
    }
    diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
    index b17ca67..005e3ad 100644
    --- a/fs/udf/udfdecl.h
    +++ b/fs/udf/udfdecl.h
    @@ -36,6 +36,9 @@

    #define udf_get_lb_pblock(sb,loc,offset) udf_get_pblock((sb), (loc).logicalBlockNum, (loc).partitionReferenceNum, (offset))

    +/* computes tag checksum */
    +u8 udf_tag_checksum(const tag *t);
    +
    struct dentry;
    struct inode;
    struct task_struct;
    --
    1.5.3.7

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  3. [PATCH 00/16] udf: cleanup

    Hi

    This patchset contains various UDF fs cleanups.
    It deprecates two patchsets I sent lately:

    http://lkml.org/lkml/2008/1/5/196 [PATCH 0/6] udf: improve code related to super_block v3
    http://lkml.org/lkml/2008/1/5/211 [PATCH 0/7] udf: more cleanups

    I hope I addressed all comments sent by Christoph Hellwig and Jan Kara.
    Thanks for review!

    [PATCH 01/16] udf: fix coding style of super.c
    [PATCH 02/16] udf: remove some ugly macros
    [PATCH 03/16] udf: convert UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps function
    [PATCH 04/16] udf: check if udf_load_logicalvol failed
    [PATCH 05/16] udf: convert macros related to bitmaps to functions
    [PATCH 06/16] udf: move calculating of nr_groups into helper function
    [PATCH 07/16] udf: fix sparse warnings (shadowing & mismatch between declaration and definition)
    [PATCH 08/16] udf: fix coding style
    [PATCH 09/16] udf: create common function for tag checksumming
    [PATCH 10/16] udf: create common function for changing free space counter
    [PATCH 11/16] udf: replace loops coded with goto to real loops
    [PATCH 12/16] udf: convert byte order of constant instead of variable
    [PATCH 13/16] udf: remove UDF_I_* macros and open code them
    [PATCH 14/16] udf: cache struct udf_inode_info

    These patches are new:
    [PATCH 15/16] udf: fix udf_debug macro
    [PATCH 16/16] udf: improve readability of udf_load_partition

    fs/udf/balloc.c | 491 ++++++++++++---------
    fs/udf/crc.c | 2 +-
    fs/udf/dir.c | 8 +-
    fs/udf/directory.c | 94 +++--
    fs/udf/file.c | 43 ++-
    fs/udf/ialloc.c | 94 +++--
    fs/udf/inode.c | 957 +++++++++++++++++++++++-----------------
    fs/udf/misc.c | 146 ++++---
    fs/udf/namei.c | 413 ++++++++++-------
    fs/udf/partition.c | 197 ++++++---
    fs/udf/super.c | 1081 ++++++++++++++++++++++++++++-----------------
    fs/udf/symlink.c | 9 +-
    fs/udf/truncate.c | 100 +++--
    fs/udf/udf_i.h | 16 -
    fs/udf/udf_sb.h | 88 +----
    fs/udf/udfdecl.h | 11 +-
    fs/udf/udftime.c | 59 ++--
    fs/udf/unicode.c | 85 ++--
    include/linux/udf_fs.h | 4 +-
    include/linux/udf_fs_sb.h | 12 +-
    20 files changed, 2261 insertions(+), 1649 deletions(-)

    This patchset depends on udf patches in -mm.
    Runtime tested: mount, open, read, seek, close, unmount.

    Marcin Slusarz
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  4. [PATCH 08/16] udf: fix coding style

    fix coding style errors found by checkpatch:
    - assignments in if conditions
    - braces {} around single statement blocks
    - no spaces after commas
    - printks without KERN_*
    - lines longer than 80 characters
    - spaces between "type *" and variable name

    before: 192 errors, 561 warnings, 8987 lines checked
    after: 1 errors, 38 warnings, 9468 lines checked

    Signed-off-by: Marcin Slusarz
    ---
    fs/udf/balloc.c | 231 +++++++++++-------
    fs/udf/crc.c | 2 +-
    fs/udf/directory.c | 83 ++++---
    fs/udf/file.c | 18 +-
    fs/udf/ialloc.c | 24 ++-
    fs/udf/inode.c | 665 +++++++++++++++++++++++++++++++---------------------
    fs/udf/misc.c | 76 ++++---
    fs/udf/namei.c | 298 ++++++++++++++----------
    fs/udf/partition.c | 160 ++++++++-----
    fs/udf/super.c | 383 +++++++++++++++++++-----------
    fs/udf/symlink.c | 3 +-
    fs/udf/truncate.c | 58 +++--
    fs/udf/udftime.c | 59 +++---
    fs/udf/unicode.c | 85 ++++---
    14 files changed, 1311 insertions(+), 834 deletions(-)

    patch (160kB) available at: http://www.kadu.net/~joi/kernel/2008...ng-style.patch
    md5: 00816fa02cf2541bee51e71a05d9dd94

    Tell me if I should post it to LKML...
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  5. [PATCH 11/16] udf: replace loops coded with goto to real loops

    Signed-off-by: Marcin Slusarz
    CC: Jan Kara
    CC: Christoph Hellwig
    ---
    fs/udf/balloc.c | 118 +++++++++++++++++++++++++++---------------------------
    1 files changed, 59 insertions(+), 59 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index 78dbf1d..df55d9f 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -183,46 +183,46 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
    block = bloc.logicalBlockNum + offset +
    (sizeof(struct spaceBitmapDesc) << 3);

    -do_more:
    - overflow = 0;
    - block_group = block >> (sb->s_blocksize_bits + 3);
    - bit = block % (sb->s_blocksize << 3);
    + do {
    + overflow = 0;
    + block_group = block >> (sb->s_blocksize_bits + 3);
    + bit = block % (sb->s_blocksize << 3);

    - /*
    - * Check to see if we are freeing blocks across a group boundary.
    - */
    - if (bit + count > (sb->s_blocksize << 3)) {
    - overflow = bit + count - (sb->s_blocksize << 3);
    - count -= overflow;
    - }
    - bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
    - if (bitmap_nr < 0)
    - goto error_return;
    + /*
    + * Check to see if we are freeing blocks across a group boundary.
    + */
    + if (bit + count > (sb->s_blocksize << 3)) {
    + overflow = bit + count - (sb->s_blocksize << 3);
    + count -= overflow;
    + }
    + bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
    + if (bitmap_nr < 0)
    + goto error_return;

    - bh = bitmap->s_block_bitmap[bitmap_nr];
    - for (i = 0; i < count; i++) {
    - if (udf_set_bit(bit + i, bh->b_data)) {
    - udf_debug("bit %ld already set\n", bit + i);
    - udf_debug("byte=%2x\n",
    - ((char *)bh->b_data)[(bit + i) >> 3]);
    - } else {
    - if (inode)
    - DQUOT_FREE_BLOCK(inode, 1);
    - udf_inc_free_space(sbi, sbi->s_partition, 1);
    + bh = bitmap->s_block_bitmap[bitmap_nr];
    + for (i = 0; i < count; i++) {
    + if (udf_set_bit(bit + i, bh->b_data)) {
    + udf_debug("bit %ld already set\n", bit + i);
    + udf_debug("byte=%2x\n",
    + ((char *)bh->b_data)[(bit + i) >> 3]);
    + } else {
    + if (inode)
    + DQUOT_FREE_BLOCK(inode, 1);
    + udf_inc_free_space(sbi, sbi->s_partition, 1);
    + }
    }
    - }
    - mark_buffer_dirty(bh);
    - if (overflow) {
    - block += count;
    - count = overflow;
    - goto do_more;
    - }
    + mark_buffer_dirty(bh);
    + if (overflow) {
    + block += count;
    + count = overflow;
    + }
    + } while (overflow);
    +
    error_return:
    sb->s_dirt = 1;
    if (sbi->s_lvid_bh)
    mark_buffer_dirty(sbi->s_lvid_bh);
    mutex_unlock(&sbi->s_alloc_mutex);
    - return;
    }

    static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    @@ -246,37 +246,37 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    if (first_block + block_count > part_len)
    block_count = part_len - first_block;

    -repeat:
    - nr_groups = udf_compute_nr_groups(sb, partition);
    - block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
    - block_group = block >> (sb->s_blocksize_bits + 3);
    - group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
    + do {
    + nr_groups = udf_compute_nr_groups(sb, partition);
    + block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
    + block_group = block >> (sb->s_blocksize_bits + 3);
    + group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);

    - bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
    - if (bitmap_nr < 0)
    - goto out;
    - bh = bitmap->s_block_bitmap[bitmap_nr];
    + bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
    + if (bitmap_nr < 0)
    + goto out;
    + bh = bitmap->s_block_bitmap[bitmap_nr];

    - bit = block % (sb->s_blocksize << 3);
    + bit = block % (sb->s_blocksize << 3);

    - while (bit < (sb->s_blocksize << 3) && block_count > 0) {
    - if (!udf_test_bit(bit, bh->b_data)) {
    - goto out;
    - } else if (DQUOT_PREALLOC_BLOCK(inode, 1)) {
    - goto out;
    - } else if (!udf_clear_bit(bit, bh->b_data)) {
    - udf_debug("bit already cleared for block %d\n", bit);
    - DQUOT_FREE_BLOCK(inode, 1);
    - goto out;
    + while (bit < (sb->s_blocksize << 3) && block_count > 0) {
    + if (!udf_test_bit(bit, bh->b_data))
    + goto out;
    + else if (DQUOT_PREALLOC_BLOCK(inode, 1))
    + goto out;
    + else if (!udf_clear_bit(bit, bh->b_data)) {
    + udf_debug("bit already cleared for block %d\n", bit);
    + DQUOT_FREE_BLOCK(inode, 1);
    + goto out;
    + }
    + block_count--;
    + alloc_count++;
    + bit++;
    + block++;
    }
    - block_count--;
    - alloc_count++;
    - bit++;
    - block++;
    - }
    - mark_buffer_dirty(bh);
    - if (block_count > 0)
    - goto repeat;
    + mark_buffer_dirty(bh);
    + } while (block_count > 0);
    +
    out:
    if (udf_inc_free_space(sbi, partition, -alloc_count))
    mark_buffer_dirty(sbi->s_lvid_bh);
    --
    1.5.3.7

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  6. [PATCH 16/16] udf: improve readability of udf_load_partition

    Signed-off-by: Marcin Slusarz
    CC: Jan Kara
    CC: Christoph Hellwig
    ---
    fs/udf/super.c | 59 ++++++++++++++++++++++++++++---------------------------
    1 files changed, 30 insertions(+), 29 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 52d2c32..2048351 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1447,44 +1447,45 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    sbi = UDF_SB(sb);

    for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
    - if (sbi->s_anchor[i] &&
    - (bh = udf_read_tagged(sb, sbi->s_anchor[i],
    - sbi->s_anchor[i], &ident))) {
    - anchor = (struct anchorVolDescPtr *)bh->b_data;
    -
    - /* Locate the main sequence */
    - main_s = le32_to_cpu(
    - anchor->mainVolDescSeqExt.extLocation);
    - main_e = le32_to_cpu(
    - anchor->mainVolDescSeqExt.extLength);
    - main_e = main_e >> sb->s_blocksize_bits;
    - main_e += main_s;
    -
    - /* Locate the reserve sequence */
    - reserve_s = le32_to_cpu(
    + if (!sbi->s_anchor[i])
    + continue;
    + bh = udf_read_tagged(sb, sbi->s_anchor[i], sbi->s_anchor[i],
    + &ident);
    + if (!bh)
    + continue;
    +
    + anchor = (struct anchorVolDescPtr *)bh->b_data;
    +
    + /* Locate the main sequence */
    + main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
    + main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
    + main_e = main_e >> sb->s_blocksize_bits;
    + main_e += main_s;
    +
    + /* Locate the reserve sequence */
    + reserve_s = le32_to_cpu(
    anchor->reserveVolDescSeqExt.extLocation);
    - reserve_e = le32_to_cpu(
    + reserve_e = le32_to_cpu(
    anchor->reserveVolDescSeqExt.extLength);
    - reserve_e = reserve_e >> sb->s_blocksize_bits;
    - reserve_e += reserve_s;
    + reserve_e = reserve_e >> sb->s_blocksize_bits;
    + reserve_e += reserve_s;

    - brelse(bh);
    + brelse(bh);

    - /* Process the main & reserve sequences */
    - /* responsible for finding the PartitionDesc(s) */
    - if (!(udf_process_sequence(sb, main_s, main_e,
    - fileset) &&
    - udf_process_sequence(sb, reserve_s, reserve_e,
    - fileset)))
    - break;
    - }
    + /* Process the main & reserve sequences */
    + /* responsible for finding the PartitionDesc(s) */
    + if (!(udf_process_sequence(sb, main_s, main_e,
    + fileset) &&
    + udf_process_sequence(sb, reserve_s, reserve_e,
    + fileset)))
    + break;
    }

    if (i == ARRAY_SIZE(sbi->s_anchor)) {
    udf_debug("No Anchor block found\n");
    return 1;
    - } else
    - udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);
    + }
    + udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);

    for (i = 0; i < sbi->s_partitions; i++) {
    kernel_lb_addr uninitialized_var(ino);
    --
    1.5.3.7

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  7. [PATCH 15/16] udf: fix udf_debug macro

    udf_debug should be enclosed with do { } while (0)
    to be safely used in code like below:
    if (something)
    udf_debug();
    else
    anything;
    (Otherwise compiler will not compile it with:
    "error: expected expression before 'else'")

    Signed-off-by: Marcin Slusarz
    CC: Jan Kara
    ---
    include/linux/udf_fs.h | 4 ++--
    1 files changed, 2 insertions(+), 2 deletions(-)

    diff --git a/include/linux/udf_fs.h b/include/linux/udf_fs.h
    index 36c684e..c954527 100644
    --- a/include/linux/udf_fs.h
    +++ b/include/linux/udf_fs.h
    @@ -39,11 +39,11 @@

    #ifdef UDFFS_DEBUG
    #define udf_debug(f, a...) \
    - { \
    + do { \
    printk (KERN_DEBUG "UDF-fs DEBUG %s:%d:%s: ", \
    __FILE__, __LINE__, __FUNCTION__); \
    printk (f, ##a); \
    - }
    + } while (0)
    #else
    #define udf_debug(f, a...) /**/
    #endif
    --
    1.5.3.7

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  8. [PATCH 12/16] udf: convert byte order of constant instead of variable

    convert byte order of constant instead of variable,
    which can be done at compile time (vs run time)

    Signed-off-by: Marcin Slusarz
    Acked-by: Jan Kara
    ---
    fs/udf/directory.c | 4 ++--
    fs/udf/inode.c | 16 ++++++++--------
    fs/udf/misc.c | 12 ++++++------
    fs/udf/super.c | 16 ++++++++--------
    4 files changed, 24 insertions(+), 24 deletions(-)

    diff --git a/fs/udf/directory.c b/fs/udf/directory.c
    index d4ae723..598bcf7 100644
    --- a/fs/udf/directory.c
    +++ b/fs/udf/directory.c
    @@ -225,7 +225,7 @@ struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, int *offset)
    if ((*offset > 0) && (*offset < bufsize))
    ptr += *offset;
    fi = (struct fileIdentDesc *)ptr;
    - if (le16_to_cpu(fi->descTag.tagIdent) != TAG_IDENT_FID) {
    + if (fi->descTag.tagIdent != cpu_to_le16(TAG_IDENT_FID)) {
    udf_debug("0x%x != TAG_IDENT_FID\n",
    le16_to_cpu(fi->descTag.tagIdent));
    udf_debug("offset: %u sizeof: %lu bufsize: %u\n",
    @@ -262,7 +262,7 @@ static extent_ad *udf_get_fileextent(void *buffer, int bufsize, int *offset)

    fe = (struct fileEntry *)buffer;

    - if (le16_to_cpu(fe->descTag.tagIdent) != TAG_IDENT_FE) {
    + if (fe->descTag.tagIdent != cpu_to_le16(TAG_IDENT_FE)) {
    udf_debug("0x%x != TAG_IDENT_FE\n",
    le16_to_cpu(fe->descTag.tagIdent));
    return NULL;
    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index 6751945..bb73635 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -1103,7 +1103,7 @@ static void __udf_read_inode(struct inode *inode)

    fe = (struct fileEntry *)bh->b_data;

    - if (le16_to_cpu(fe->icbTag.strategyType) == 4096) {
    + if (fe->icbTag.strategyType == cpu_to_le16(4096)) {
    struct buffer_head *ibh = NULL, *nbh = NULL;
    struct indirectEntry *ie;

    @@ -1140,7 +1140,7 @@ static void __udf_read_inode(struct inode *inode)
    } else {
    brelse(ibh);
    }
    - } else if (le16_to_cpu(fe->icbTag.strategyType) != 4) {
    + } else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
    printk(KERN_ERR "udf: unsupported strategy type: %d\n",
    le16_to_cpu(fe->icbTag.strategyType));
    brelse(bh);
    @@ -1164,9 +1164,9 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    fe = (struct fileEntry *)bh->b_data;
    efe = (struct extendedFileEntry *)bh->b_data;

    - if (le16_to_cpu(fe->icbTag.strategyType) == 4)
    + if (fe->icbTag.strategyType == cpu_to_le16(4))
    UDF_I_STRAT4096(inode) = 0;
    - else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
    + else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
    UDF_I_STRAT4096(inode) = 1;

    UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) &
    @@ -1177,7 +1177,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    UDF_I_LENALLOC(inode) = 0;
    UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
    UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
    - if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE) {
    + if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
    UDF_I_EFE(inode) = 1;
    UDF_I_USE(inode) = 0;
    if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
    @@ -1189,7 +1189,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    bh->b_data + sizeof(struct extendedFileEntry),
    inode->i_sb->s_blocksize -
    sizeof(struct extendedFileEntry));
    - } else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE) {
    + } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
    UDF_I_EFE(inode) = 0;
    UDF_I_USE(inode) = 0;
    if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
    @@ -1199,7 +1199,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    }
    memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry),
    inode->i_sb->s_blocksize - sizeof(struct fileEntry));
    - } else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) {
    + } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
    UDF_I_EFE(inode) = 0;
    UDF_I_USE(inode) = 1;
    UDF_I_LENALLOC(inode) = le32_to_cpu(
    @@ -1458,7 +1458,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    fe = (struct fileEntry *)bh->b_data;
    efe = (struct extendedFileEntry *)bh->b_data;

    - if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) {
    + if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
    struct unallocSpaceEntry *use =
    (struct unallocSpaceEntry *)bh->b_data;

    diff --git a/fs/udf/misc.c b/fs/udf/misc.c
    index 585e4ea..a3a513f 100644
    --- a/fs/udf/misc.c
    +++ b/fs/udf/misc.c
    @@ -74,8 +74,8 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,

    if (UDF_I_LENEATTR(inode)) {
    /* check checksum/crc */
    - if (le16_to_cpu(eahd->descTag.tagIdent) !=
    - TAG_IDENT_EAHD ||
    + if (eahd->descTag.tagIdent !=
    + cpu_to_le16(TAG_IDENT_EAHD) ||
    le32_to_cpu(eahd->descTag.tagLocation) !=
    UDF_I_LOCATION(inode).logicalBlockNum)
    return NULL;
    @@ -161,8 +161,8 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
    eahd = (struct extendedAttrHeaderDesc *)ea;

    /* check checksum/crc */
    - if (le16_to_cpu(eahd->descTag.tagIdent) !=
    - TAG_IDENT_EAHD ||
    + if (eahd->descTag.tagIdent !=
    + cpu_to_le16(TAG_IDENT_EAHD) ||
    le32_to_cpu(eahd->descTag.tagLocation) !=
    UDF_I_LOCATION(inode).logicalBlockNum)
    return NULL;
    @@ -233,8 +233,8 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
    }

    /* Verify the tag version */
    - if (le16_to_cpu(tag_p->descVersion) != 0x0002U &&
    - le16_to_cpu(tag_p->descVersion) != 0x0003U) {
    + if (tag_p->descVersion != cpu_to_le16(0x0002U) &&
    + tag_p->descVersion != cpu_to_le16(0x0003U)) {
    udf_debug("tag version 0x%04x != 0x0002 || 0x0003 block %d\n",
    le16_to_cpu(tag_p->descVersion), block);
    goto error_out;
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 12fb91d..b102958 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1014,20 +1014,20 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    le32_to_cpu(p->partitionLength); /* blocks */
    map->s_partition_root =
    le32_to_cpu(p->partitionStartingLocation);
    - if (le32_to_cpu(p->accessType) ==
    - PD_ACCESS_TYPE_READ_ONLY)
    + if (p->accessType ==
    + cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY))
    map->s_partition_flags |=
    UDF_PART_FLAG_READ_ONLY;
    - if (le32_to_cpu(p->accessType) ==
    - PD_ACCESS_TYPE_WRITE_ONCE)
    + if (p->accessType ==
    + cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE))
    map->s_partition_flags |=
    UDF_PART_FLAG_WRITE_ONCE;
    - if (le32_to_cpu(p->accessType) ==
    - PD_ACCESS_TYPE_REWRITABLE)
    + if (p->accessType ==
    + cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE))
    map->s_partition_flags |=
    UDF_PART_FLAG_REWRITABLE;
    - if (le32_to_cpu(p->accessType) ==
    - PD_ACCESS_TYPE_OVERWRITABLE)
    + if (p->accessType ==
    + cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE))
    map->s_partition_flags |=
    UDF_PART_FLAG_OVERWRITABLE;

    --
    1.5.3.7

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  9. [PATCH 13/16] udf: remove UDF_I_* macros and open code them

    Signed-off-by: Marcin Slusarz
    Acked-by: Jan Kara
    ---
    fs/udf/balloc.c | 30 +++---
    fs/udf/dir.c | 7 +-
    fs/udf/directory.c | 6 +-
    fs/udf/file.c | 24 +++--
    fs/udf/ialloc.c | 50 +++++-----
    fs/udf/inode.c | 296 ++++++++++++++++++++++++++-------------------------
    fs/udf/misc.c | 38 ++++----
    fs/udf/namei.c | 110 ++++++++++---------
    fs/udf/partition.c | 4 +-
    fs/udf/super.c | 2 +-
    fs/udf/symlink.c | 4 +-
    fs/udf/truncate.c | 34 +++---
    fs/udf/udf_i.h | 16 ---
    fs/udf/udfdecl.h | 8 +-
    14 files changed, 315 insertions(+), 314 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index df55d9f..ec6d44c 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -460,7 +460,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_LOCATION(table);
    + epos.block = oepos.block = UDF_I(table)->i_location;
    epos.bh = oepos.bh = NULL;

    while (count &&
    @@ -539,9 +539,9 @@ static void udf_table_free_blocks(struct super_block *sb,
    elen = EXT_RECORDED_ALLOCATED |
    (count << sb->s_blocksize_bits);

    - if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT) {
    + if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) {
    adsize = sizeof(short_ad);
    - } else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG) {
    + } else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG) {
    adsize = sizeof(long_ad);
    } else {
    brelse(oepos.bh);
    @@ -573,7 +573,8 @@ 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_DATA(table) + epos.offset - adsize;
    + sptr = UDF_I(table)->i_ext.i_data + epos.offset
    + - adsize;
    dptr = epos.bh->b_data +
    sizeof(struct allocExtDesc);
    memcpy(dptr, sptr, adsize);
    @@ -591,8 +592,9 @@ static void udf_table_free_blocks(struct super_block *sb,
    aed->lengthAllocDescs) +
    adsize);
    } else {
    - sptr = UDF_I_DATA(table) + epos.offset;
    - UDF_I_LENALLOC(table) += adsize;
    + sptr = UDF_I(table)->i_ext.i_data +
    + epos.offset;
    + UDF_I(table)->i_lenAlloc += adsize;
    mark_inode_dirty(table);
    }
    epos.offset = sizeof(struct allocExtDesc);
    @@ -606,7 +608,7 @@ static void udf_table_free_blocks(struct super_block *sb,
    2, 1, epos.block.logicalBlockNum,
    sizeof(tag));

    - switch (UDF_I_ALLOCTYPE(table)) {
    + switch (UDF_I(table)->i_alloc_type) {
    case ICBTAG_FLAG_AD_SHORT:
    sad = (short_ad *)sptr;
    sad->extLength = cpu_to_le32(
    @@ -637,7 +639,7 @@ static void udf_table_free_blocks(struct super_block *sb,
    udf_write_aext(table, &epos, eloc, elen, 1);

    if (!epos.bh) {
    - UDF_I_LENALLOC(table) += adsize;
    + UDF_I(table)->i_lenAlloc += adsize;
    mark_inode_dirty(table);
    } else {
    aed = (struct allocExtDesc *)epos.bh->b_data;
    @@ -675,16 +677,16 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
    first_block >= sbi->s_partmaps[partition].s_partition_len)
    return 0;

    - if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    adsize = sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(table)->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_LOCATION(table);
    + epos.block = UDF_I(table)->i_location;
    epos.bh = NULL;
    eloc.logicalBlockNum = 0xFFFFFFFF;

    @@ -740,9 +742,9 @@ static int udf_table_new_block(struct super_block *sb,

    *err = -ENOSPC;

    - if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    adsize = sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    adsize = sizeof(long_ad);
    else
    return newblock;
    @@ -757,7 +759,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_LOCATION(table);
    + epos.block = UDF_I(table)->i_location;
    epos.bh = goal_epos.bh = NULL;

    while (spread &&
    diff --git a/fs/udf/dir.c b/fs/udf/dir.c
    index c5e38d6..61b49c5 100644
    --- a/fs/udf/dir.c
    +++ b/fs/udf/dir.c
    @@ -69,16 +69,17 @@ static int do_udf_readdir(struct inode *dir, struct file *filp,
    (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
    bits = dir->i_sb->s_blocksize_bits;

    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    fibh.sbh = fibh.ebh = NULL;
    else if (inode_bmap(dir, nf_pos >> (bits - 2),
    &epos, &eloc, &elen, &offset) ==
    (EXT_RECORDED_ALLOCATED >> 30)) {
    block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
    if ((++offset << bits) < elen) {
    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    epos.offset -= sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(dir)->i_alloc_type ==
    + ICBTAG_FLAG_AD_LONG)
    epos.offset -= sizeof(long_ad);
    } else
    offset = 0;
    diff --git a/fs/udf/directory.c b/fs/udf/directory.c
    index 598bcf7..cd3da31 100644
    --- a/fs/udf/directory.c
    +++ b/fs/udf/directory.c
    @@ -84,9 +84,9 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,

    fibh->soffset = fibh->eoffset;

    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
    - fi = udf_get_fileident(UDF_I_DATA(dir) -
    - (UDF_I_EFE(dir) ?
    + 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 ?
    sizeof(struct extendedFileEntry) :
    sizeof(struct fileEntry)),
    dir->i_sb->s_blocksize,
    diff --git a/fs/udf/file.c b/fs/udf/file.c
    index a984a89..a1e07a1 100644
    --- a/fs/udf/file.c
    +++ b/fs/udf/file.c
    @@ -50,7 +50,8 @@ static int udf_adinicb_readpage(struct file *file, struct page *page)

    kaddr = kmap(page);
    memset(kaddr, 0, PAGE_CACHE_SIZE);
    - memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), inode->i_size);
    + memcpy(kaddr, UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr,
    + inode->i_size);
    flush_dcache_page(page);
    SetPageUptodate(page);
    kunmap(page);
    @@ -68,7 +69,8 @@ static int udf_adinicb_writepage(struct page *page,
    BUG_ON(!PageLocked(page));

    kaddr = kmap(page);
    - memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), kaddr, inode->i_size);
    + memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, kaddr,
    + inode->i_size);
    mark_inode_dirty(inode);
    SetPageUptodate(page);
    kunmap(page);
    @@ -87,7 +89,7 @@ static int udf_adinicb_write_end(struct file *file,
    char *kaddr;

    kaddr = kmap_atomic(page, KM_USER0);
    - memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset,
    + memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr + offset,
    kaddr + offset, copied);
    kunmap_atomic(kaddr, KM_USER0);

    @@ -111,7 +113,7 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
    int err, pos;
    size_t count = iocb->ki_left;

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
    if (file->f_flags & O_APPEND)
    pos = inode->i_size;
    else
    @@ -121,15 +123,16 @@ 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_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
    + if (UDF_I(inode)->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_LENALLOC(inode) = pos + count;
    + UDF_I(inode)->i_lenAlloc = pos + count;
    else
    - UDF_I_LENALLOC(inode) = inode->i_size;
    + UDF_I(inode)->i_lenAlloc = inode->i_size;
    }
    }

    @@ -209,11 +212,12 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
    result = put_user(new_block, (long __user *)arg);
    return result;
    case UDF_GETEASIZE:
    - result = put_user(UDF_I_LENEATTR(inode), (int __user *)arg);
    + result = put_user(UDF_I(inode)->i_lenEAttr, (int __user *)arg);
    break;
    case UDF_GETEABLOCK:
    - result = copy_to_user((char __user *)arg, UDF_I_DATA(inode),
    - UDF_I_LENEATTR(inode)) ? -EFAULT : 0;
    + result = copy_to_user((char __user *)arg,
    + UDF_I(inode)->i_ext.i_data,
    + UDF_I(inode)->i_lenEAttr) ? -EFAULT : 0;
    break;
    }

    diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
    index 7697b48..5ed8cda 100644
    --- a/fs/udf/ialloc.c
    +++ b/fs/udf/ialloc.c
    @@ -57,7 +57,7 @@ void udf_free_inode(struct inode *inode)
    }
    mutex_unlock(&sbi->s_alloc_mutex);

    - udf_free_blocks(sb, NULL, UDF_I_LOCATION(inode), 0, 1);
    + udf_free_blocks(sb, NULL, UDF_I(inode)->i_location, 0, 1);
    }

    struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    @@ -66,7 +66,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    struct udf_sb_info *sbi = UDF_SB(sb);
    struct inode *inode;
    int block;
    - uint32_t start = UDF_I_LOCATION(dir).logicalBlockNum;
    + uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;

    inode = new_inode(sb);

    @@ -76,14 +76,14 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    }
    *err = -ENOSPC;

    - UDF_I_UNIQUE(inode) = 0;
    - UDF_I_LENEXTENTS(inode) = 0;
    - UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
    - UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
    - UDF_I_STRAT4096(inode) = 0;
    + 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;

    block = udf_new_block(dir->i_sb, NULL,
    - UDF_I_LOCATION(dir).partitionReferenceNum,
    + UDF_I(dir)->i_location.partitionReferenceNum,
    start, err);
    if (*err) {
    iput(inode);
    @@ -107,7 +107,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_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);
    + UDF_I(inode)->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID);
    if (!(++uniqueID & 0x00000000FFFFFFFFUL))
    uniqueID += 16;
    lvhd->uniqueID = cpu_to_le64(uniqueID);
    @@ -123,41 +123,41 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    inode->i_gid = current->fsgid;
    }

    - UDF_I_LOCATION(inode).logicalBlockNum = block;
    - UDF_I_LOCATION(inode).partitionReferenceNum =
    - UDF_I_LOCATION(dir).partitionReferenceNum;
    - inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);
    + 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);
    inode->i_blocks = 0;
    - UDF_I_LENEATTR(inode) = 0;
    - UDF_I_LENALLOC(inode) = 0;
    - UDF_I_USE(inode) = 0;
    + UDF_I(inode)->i_lenEAttr = 0;
    + UDF_I(inode)->i_lenAlloc = 0;
    + UDF_I(inode)->i_use = 0;
    if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
    - UDF_I_EFE(inode) = 1;
    + UDF_I(inode)->i_efe = 1;
    if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)
    sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE;
    - UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize -
    + UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
    sizeof(struct extendedFileEntry),
    GFP_KERNEL);
    } else {
    - UDF_I_EFE(inode) = 0;
    - UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize -
    + UDF_I(inode)->i_efe = 0;
    + UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
    sizeof(struct fileEntry),
    GFP_KERNEL);
    }
    - if (!UDF_I_DATA(inode)) {
    + if (!UDF_I(inode)->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_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
    + UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
    else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
    - UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
    + UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
    else
    - UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
    + UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG;
    inode->i_mtime = inode->i_atime = inode->i_ctime =
    - UDF_I_CRTIME(inode) = current_fs_time(inode->i_sb);
    + UDF_I(inode)->i_crtime = current_fs_time(inode->i_sb);
    insert_inode_hash(inode);
    mark_inode_dirty(inode);
    mutex_unlock(&sbi->s_alloc_mutex);
    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index bb73635..b0eb878 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -120,8 +120,8 @@ void udf_clear_inode(struct inode *inode)
    unlock_kernel();
    write_inode_now(inode, 1);
    }
    - kfree(UDF_I_DATA(inode));
    - UDF_I_DATA(inode) = NULL;
    + kfree(UDF_I(inode)->i_ext.i_data);
    + UDF_I(inode)->i_ext.i_data = NULL;
    }

    static int udf_writepage(struct page *page, struct writeback_control *wbc)
    @@ -169,11 +169,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_LENALLOC(inode)) {
    + if (!UDF_I(inode)->i_lenAlloc) {
    if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
    - UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
    + UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
    else
    - UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
    + UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG;
    mark_inode_dirty(inode);
    return;
    }
    @@ -183,21 +183,21 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)

    if (!PageUptodate(page)) {
    kaddr = kmap(page);
    - memset(kaddr + UDF_I_LENALLOC(inode), 0x00,
    - PAGE_CACHE_SIZE - UDF_I_LENALLOC(inode));
    - memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode),
    - UDF_I_LENALLOC(inode));
    + 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);
    flush_dcache_page(page);
    SetPageUptodate(page);
    kunmap(page);
    }
    - memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0x00,
    - UDF_I_LENALLOC(inode));
    - UDF_I_LENALLOC(inode) = 0;
    + 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;
    if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
    - UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
    + UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
    else
    - UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
    + UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG;

    inode->i_data.a_ops->writepage(page, &udf_wbc);
    page_cache_release(page);
    @@ -226,20 +226,20 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
    alloctype = ICBTAG_FLAG_AD_LONG;

    if (!inode->i_size) {
    - UDF_I_ALLOCTYPE(inode) = alloctype;
    + UDF_I(inode)->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_LOCATION(inode).partitionReferenceNum,
    - UDF_I_LOCATION(inode).logicalBlockNum, err);
    + UDF_I(inode)->i_location.partitionReferenceNum,
    + UDF_I(inode)->i_location.logicalBlockNum, err);
    if (!(*block))
    return NULL;
    newblock = udf_get_pblock(inode->i_sb, *block,
    - UDF_I_LOCATION(inode).partitionReferenceNum,
    - 0);
    + UDF_I(inode)->i_location.partitionReferenceNum,
    + 0);
    if (!newblock)
    return NULL;
    dbh = udf_tgetblk(inode->i_sb, newblock);
    @@ -257,14 +257,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_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
    + UDF_I(inode)->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_ALLOCTYPE(inode) = alloctype;
    + UDF_I(inode)->i_alloc_type = alloctype;
    sfi->descTag.tagLocation = cpu_to_le32(*block);
    dfibh.soffset = dfibh.eoffset;
    dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
    @@ -272,23 +272,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_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
    + UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
    brelse(dbh);
    return NULL;
    }
    }
    mark_buffer_dirty_inode(dbh, inode);

    - memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0,
    - UDF_I_LENALLOC(inode));
    - UDF_I_LENALLOC(inode) = 0;
    + 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;
    eloc.logicalBlockNum = *block;
    eloc.partitionReferenceNum =
    - UDF_I_LOCATION(inode).partitionReferenceNum;
    + UDF_I(inode)->i_location.partitionReferenceNum;
    elen = inode->i_size;
    - UDF_I_LENEXTENTS(inode) = elen;
    + UDF_I(inode)->i_lenExtents = elen;
    epos.bh = NULL;
    - epos.block = UDF_I_LOCATION(inode);
    + epos.block = UDF_I(inode)->i_location;
    epos.offset = udf_file_entry_alloc_offset(inode);
    udf_add_aext(inode, &epos, eloc, elen, 0);
    /* UniqueID stuff */
    @@ -321,9 +321,9 @@ static int udf_get_block(struct inode *inode, sector_t block,
    if (block < 0)
    goto abort_negative;

    - if (block == UDF_I_NEXT_ALLOC_BLOCK(inode) + 1) {
    - UDF_I_NEXT_ALLOC_BLOCK(inode)++;
    - UDF_I_NEXT_ALLOC_GOAL(inode)++;
    + if (block == UDF_I(inode)->i_next_alloc_block + 1) {
    + UDF_I(inode)->i_next_alloc_block++;
    + UDF_I(inode)->i_next_alloc_goal++;
    }

    err = 0;
    @@ -392,8 +392,8 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
    (last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
    (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
    sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
    - UDF_I_LENEXTENTS(inode) =
    - (UDF_I_LENEXTENTS(inode) + sb->s_blocksize - 1) &
    + UDF_I(inode)->i_lenExtents =
    + (UDF_I(inode)->i_lenExtents + sb->s_blocksize - 1) &
    ~(sb->s_blocksize - 1);
    }

    @@ -470,9 +470,9 @@ out:
    }

    /* last_pos should point to the last written extent... */
    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    last_pos->offset -= sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    last_pos->offset -= sizeof(long_ad);
    else
    return -1;
    @@ -495,11 +495,11 @@ 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_LOCATION(inode).logicalBlockNum;
    + int goal = 0, pgoal = UDF_I(inode)->i_location.logicalBlockNum;
    int lastblock = 0;

    prev_epos.offset = udf_file_entry_alloc_offset(inode);
    - prev_epos.block = UDF_I_LOCATION(inode);
    + prev_epos.block = UDF_I(inode)->i_location;
    prev_epos.bh = NULL;
    cur_epos = next_epos = prev_epos;
    b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
    @@ -649,23 +649,24 @@ 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_NEXT_ALLOC_BLOCK(inode) == block)
    - goal = UDF_I_NEXT_ALLOC_GOAL(inode);
    + if (UDF_I(inode)->i_next_alloc_block == block)
    + goal = UDF_I(inode)->i_next_alloc_goal;

    if (!goal) {
    if (!(goal = pgoal)) /* XXX: what was intended here? */
    - goal = UDF_I_LOCATION(inode).logicalBlockNum+1;
    + goal = UDF_I(inode)->
    + i_location.logicalBlockNum + 1;
    }

    newblocknum = udf_new_block(inode->i_sb, inode,
    - UDF_I_LOCATION(inode).partitionReferenceNum,
    + UDF_I(inode)->i_location.partitionReferenceNum,
    goal, err);
    if (!newblocknum) {
    brelse(prev_epos.bh);
    *err = -ENOSPC;
    return NULL;
    }
    - UDF_I_LENEXTENTS(inode) += inode->i_sb->s_blocksize;
    + UDF_I(inode)->i_lenExtents += inode->i_sb->s_blocksize;
    }

    /* if the extent the requsted block is located in contains multiple
    @@ -690,14 +691,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_LOCATION(inode).partitionReferenceNum, 0);
    + UDF_I(inode)->i_location.partitionReferenceNum, 0);
    if (!newblock)
    return NULL;
    *phys = newblock;
    *err = 0;
    *new = 1;
    - UDF_I_NEXT_ALLOC_BLOCK(inode) = block;
    - UDF_I_NEXT_ALLOC_GOAL(inode) = newblocknum;
    + UDF_I(inode)->i_next_alloc_block = block;
    + UDF_I(inode)->i_next_alloc_goal = newblocknum;
    inode->i_ctime = current_fs_time(inode->i_sb);

    if (IS_SYNC(inode))
    @@ -756,7 +757,7 @@ static void udf_split_extents(struct inode *inode, int *c, int offset,
    laarr[curr].extLocation.logicalBlockNum = newblocknum;
    if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
    laarr[curr].extLocation.partitionReferenceNum =
    - UDF_I_LOCATION(inode).partitionReferenceNum;
    + UDF_I(inode)->i_location.partitionReferenceNum;
    laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
    blocksize;
    curr++;
    @@ -863,7 +864,7 @@ static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
    (*endnum)--;
    }
    }
    - UDF_I_LENEXTENTS(inode) +=
    + UDF_I(inode)->i_lenExtents +=
    numalloc << inode->i_sb->s_blocksize_bits;
    }
    }
    @@ -1034,23 +1035,25 @@ void udf_truncate(struct inode *inode)
    return;

    lock_kernel();
    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
    + if (UDF_I(inode)->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_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
    - inode->i_size = UDF_I_LENALLOC(inode);
    + if (UDF_I(inode)->i_alloc_type ==
    + ICBTAG_FLAG_AD_IN_ICB) {
    + inode->i_size = UDF_I(inode)->i_lenAlloc;
    unlock_kernel();
    return;
    } else
    udf_truncate_extents(inode);
    } else {
    offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
    - memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) +
    - offset, 0x00, inode->i_sb->s_blocksize -
    + memset(UDF_I(inode)->i_ext.i_data +
    + UDF_I(inode)->i_lenEAttr + offset,
    + 0x00, inode->i_sb->s_blocksize -
    offset - udf_file_entry_alloc_offset(inode));
    - UDF_I_LENALLOC(inode) = inode->i_size;
    + UDF_I(inode)->i_lenAlloc = inode->i_size;
    }
    } else {
    block_truncate_page(inode->i_mapping, inode->i_size,
    @@ -1084,7 +1087,7 @@ static void __udf_read_inode(struct inode *inode)
    * i_nlink = 1
    * i_op = NULL;
    */
    - bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);
    + bh = udf_read_ptagged(inode->i_sb, UDF_I(inode)->i_location, 0, &ident);
    if (!bh) {
    printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
    inode->i_ino);
    @@ -1107,7 +1110,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_LOCATION(inode), 1,
    + ibh = udf_read_ptagged(inode->i_sb, UDF_I(inode)->i_location, 1,
    &ident);
    if (ident == TAG_IDENT_IE) {
    if (ibh) {
    @@ -1121,7 +1124,7 @@ static void __udf_read_inode(struct inode *inode)
    &ident))) {
    if (ident == TAG_IDENT_FE ||
    ident == TAG_IDENT_EFE) {
    - memcpy(&UDF_I_LOCATION(inode),
    + memcpy(&UDF_I(inode)->i_location,
    &loc,
    sizeof(kernel_lb_addr));
    brelse(bh);
    @@ -1165,44 +1168,45 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    efe = (struct extendedFileEntry *)bh->b_data;

    if (fe->icbTag.strategyType == cpu_to_le16(4))
    - UDF_I_STRAT4096(inode) = 0;
    + UDF_I(inode)->i_strat4096 = 0;
    else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
    - UDF_I_STRAT4096(inode) = 1;
    + UDF_I(inode)->i_strat4096 = 1;

    - UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) &
    + UDF_I(inode)->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
    ICBTAG_FLAG_AD_MASK;
    - UDF_I_UNIQUE(inode) = 0;
    - UDF_I_LENEATTR(inode) = 0;
    - UDF_I_LENEXTENTS(inode) = 0;
    - UDF_I_LENALLOC(inode) = 0;
    - UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
    - UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
    + 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;
    if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
    - UDF_I_EFE(inode) = 1;
    - UDF_I_USE(inode) = 0;
    + UDF_I(inode)->i_efe = 1;
    + UDF_I(inode)->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_DATA(inode),
    + memcpy(UDF_I(inode)->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_EFE(inode) = 0;
    - UDF_I_USE(inode) = 0;
    + UDF_I(inode)->i_efe = 0;
    + UDF_I(inode)->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_DATA(inode), bh->b_data + sizeof(struct fileEntry),
    + memcpy(UDF_I(inode)->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_EFE(inode) = 0;
    - UDF_I_USE(inode) = 1;
    - UDF_I_LENALLOC(inode) = le32_to_cpu(
    + UDF_I(inode)->i_efe = 0;
    + UDF_I(inode)->i_use = 1;
    + UDF_I(inode)->i_lenAlloc = le32_to_cpu(
    ((struct unallocSpaceEntry *)bh->b_data)->
    lengthAllocDescs);
    if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
    @@ -1210,7 +1214,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    make_bad_inode(inode);
    return;
    }
    - memcpy(UDF_I_DATA(inode),
    + memcpy(UDF_I(inode)->i_ext.i_data,
    bh->b_data + sizeof(struct unallocSpaceEntry),
    inode->i_sb->s_blocksize -
    sizeof(struct unallocSpaceEntry));
    @@ -1234,12 +1238,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_LENEXTENTS(inode) = inode->i_size;
    + UDF_I(inode)->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_EFE(inode) == 0) {
    + if (UDF_I(inode)->i_efe == 0) {
    inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
    (inode->i_sb->s_blocksize_bits - 9);

    @@ -1267,10 +1271,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    inode->i_ctime = sbi->s_record_time;
    }

    - UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID);
    - UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr);
    - UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs);
    - offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode);
    + 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;
    } else {
    inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
    (inode->i_sb->s_blocksize_bits - 9);
    @@ -1293,10 +1297,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_CRTIME(inode).tv_sec = convtime;
    - UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000;
    + UDF_I(inode)->i_crtime.tv_sec = convtime;
    + UDF_I(inode)->i_crtime.tv_nsec = convtime_usec * 1000;
    } else {
    - UDF_I_CRTIME(inode) = sbi->s_record_time;
    + UDF_I(inode)->i_crtime = sbi->s_record_time;
    }

    if (udf_stamp_to_time(&convtime, &convtime_usec,
    @@ -1307,11 +1311,11 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    inode->i_ctime = sbi->s_record_time;
    }

    - UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
    - UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr);
    - UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs);
    + 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);
    offset = sizeof(struct extendedFileEntry) +
    - UDF_I_LENEATTR(inode);
    + UDF_I(inode)->i_lenEAttr;
    }

    switch (fe->icbTag.fileType) {
    @@ -1324,7 +1328,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_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    inode->i_data.a_ops = &udf_adinicb_aops;
    else
    inode->i_data.a_ops = &udf_aops;
    @@ -1371,9 +1375,9 @@ 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_DATA(inode) = kmalloc(size, GFP_KERNEL);
    + UDF_I(inode)->i_ext.i_data = kmalloc(size, GFP_KERNEL);

    - if (!UDF_I_DATA(inode)) {
    + if (!UDF_I(inode)->i_ext.i_data) {
    printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) "
    "no free memory\n", inode->i_ino);
    return -ENOMEM;
    @@ -1447,7 +1451,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)

    bh = udf_tread(inode->i_sb,
    udf_get_lb_pblock(inode->i_sb,
    - UDF_I_LOCATION(inode), 0));
    + UDF_I(inode)->i_location, 0));
    if (!bh) {
    udf_debug("bread failure\n");
    return -EIO;
    @@ -1462,14 +1466,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_LENALLOC(inode));
    + use->lengthAllocDescs = cpu_to_le32(UDF_I(inode)->i_lenAlloc);
    memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
    - UDF_I_DATA(inode), inode->i_sb->s_blocksize -
    + UDF_I(inode)->i_ext.i_data, inode->i_sb->s_blocksize -
    sizeof(struct unallocSpaceEntry));
    crclen = sizeof(struct unallocSpaceEntry) +
    - UDF_I_LENALLOC(inode) - sizeof(tag);
    + UDF_I(inode)->i_lenAlloc - sizeof(tag);
    use->descTag.tagLocation = cpu_to_le32(
    - UDF_I_LOCATION(inode).
    + UDF_I(inode)->i_location.
    logicalBlockNum);
    use->descTag.descCRCLength = cpu_to_le16(crclen);
    use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use +
    @@ -1534,8 +1538,9 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
    }

    - if (UDF_I_EFE(inode) == 0) {
    - memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode),
    + if (UDF_I(inode)->i_efe == 0) {
    + memcpy(bh->b_data + sizeof(struct fileEntry),
    + UDF_I(inode)->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) >>
    @@ -1551,14 +1556,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_UNIQUE(inode));
    - fe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
    - fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
    + 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->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
    crclen = sizeof(struct fileEntry);
    } else {
    memcpy(bh->b_data + sizeof(struct extendedFileEntry),
    - UDF_I_DATA(inode),
    + UDF_I(inode)->i_ext.i_data,
    inode->i_sb->s_blocksize -
    sizeof(struct extendedFileEntry));
    efe->objectSize = cpu_to_le64(inode->i_size);
    @@ -1566,26 +1571,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_CRTIME(inode).tv_sec > inode->i_atime.tv_sec ||
    - (UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec &&
    - UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec))
    - UDF_I_CRTIME(inode) = inode->i_atime;
    + 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 (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec ||
    - (UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec &&
    - UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec))
    - UDF_I_CRTIME(inode) = inode->i_mtime;
    + 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 (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec ||
    - (UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec &&
    - UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec))
    - UDF_I_CRTIME(inode) = inode->i_ctime;
    + 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 (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_CRTIME(inode)))
    + if (udf_time_to_stamp(&cpu_time, UDF_I(inode)->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);
    @@ -1594,13 +1599,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_UNIQUE(inode));
    - efe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
    - efe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
    + 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->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
    crclen = sizeof(struct extendedFileEntry);
    }
    - if (UDF_I_STRAT4096(inode)) {
    + if (UDF_I(inode)->i_strat4096) {
    fe->icbTag.strategyType = cpu_to_le16(4096);
    fe->icbTag.strategyParameter = cpu_to_le16(1);
    fe->icbTag.numEntries = cpu_to_le16(2);
    @@ -1624,7 +1629,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_ALLOCTYPE(inode) |
    + icbflags = UDF_I(inode)->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) |
    @@ -1639,8 +1644,9 @@ 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_LOCATION(inode).logicalBlockNum);
    - crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
    + UDF_I(inode)->i_location.logicalBlockNum);
    + crclen += UDF_I(inode)->i_lenEAttr + UDF_I(inode)->i_lenAlloc -
    + sizeof(tag);
    fe->descTag.descCRCLength = cpu_to_le16(crclen);
    fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag),
    crclen, 0));
    @@ -1671,7 +1677,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
    return NULL;

    if (inode->i_state & I_NEW) {
    - memcpy(&UDF_I_LOCATION(inode), &ino, sizeof(kernel_lb_addr));
    + memcpy(&UDF_I(inode)->i_location, &ino, sizeof(kernel_lb_addr));
    __udf_read_inode(inode);
    unlock_new_inode(inode);
    }
    @@ -1705,15 +1711,15 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
    uint8_t *ptr;

    if (!epos->bh)
    - ptr = UDF_I_DATA(inode) + epos->offset -
    + ptr = UDF_I(inode)->i_ext.i_data + epos->offset -
    udf_file_entry_alloc_offset(inode) +
    - UDF_I_LENEATTR(inode);
    + UDF_I(inode)->i_lenEAttr;
    else
    ptr = epos->bh->b_data + epos->offset;

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    adsize = sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    adsize = sizeof(long_ad);
    else
    return -1;
    @@ -1763,7 +1769,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_LENALLOC(inode) += adsize;
    + UDF_I(inode)->i_lenAlloc += adsize;
    mark_inode_dirty(inode);
    }
    }
    @@ -1773,7 +1779,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_ALLOCTYPE(inode)) {
    + switch (UDF_I(inode)->i_alloc_type) {
    case ICBTAG_FLAG_AD_SHORT:
    sad = (short_ad *)sptr;
    sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
    @@ -1807,7 +1813,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_LENALLOC(inode) += adsize;
    + UDF_I(inode)->i_lenAlloc += adsize;
    mark_inode_dirty(inode);
    } else {
    aed = (struct allocExtDesc *)epos->bh->b_data;
    @@ -1836,13 +1842,13 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
    long_ad *lad;

    if (!epos->bh)
    - ptr = UDF_I_DATA(inode) + epos->offset -
    + ptr = UDF_I(inode)->i_ext.i_data + epos->offset -
    udf_file_entry_alloc_offset(inode) +
    - UDF_I_LENEATTR(inode);
    + UDF_I(inode)->i_lenEAttr;
    else
    ptr = epos->bh->b_data + epos->offset;

    - switch (UDF_I_ALLOCTYPE(inode)) {
    + switch (UDF_I(inode)->i_alloc_type) {
    case ICBTAG_FLAG_AD_SHORT:
    sad = (short_ad *)ptr;
    sad->extLength = cpu_to_le32(elen);
    @@ -1914,11 +1920,11 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
    if (!epos->bh) {
    if (!epos->offset)
    epos->offset = udf_file_entry_alloc_offset(inode);
    - ptr = UDF_I_DATA(inode) + epos->offset -
    + ptr = UDF_I(inode)->i_ext.i_data + epos->offset -
    udf_file_entry_alloc_offset(inode) +
    - UDF_I_LENEATTR(inode);
    + UDF_I(inode)->i_lenEAttr;
    alen = udf_file_entry_alloc_offset(inode) +
    - UDF_I_LENALLOC(inode);
    + UDF_I(inode)->i_lenAlloc;
    } else {
    if (!epos->offset)
    epos->offset = sizeof(struct allocExtDesc);
    @@ -1928,7 +1934,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
    lengthAllocDescs);
    }

    - switch (UDF_I_ALLOCTYPE(inode)) {
    + switch (UDF_I(inode)->i_alloc_type) {
    case ICBTAG_FLAG_AD_SHORT:
    sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
    if (!sad)
    @@ -1936,7 +1942,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_LOCATION(inode).partitionReferenceNum;
    + UDF_I(inode)->i_location.partitionReferenceNum;
    *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
    break;
    case ICBTAG_FLAG_AD_LONG:
    @@ -1949,7 +1955,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
    break;
    default:
    udf_debug("alloc_type = %d unsupported\n",
    - UDF_I_ALLOCTYPE(inode));
    + UDF_I(inode)->i_alloc_type);
    return -1;
    }

    @@ -1990,9 +1996,9 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
    get_bh(epos.bh);
    }

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    adsize = sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    adsize = sizeof(long_ad);
    else
    adsize = 0;
    @@ -2019,7 +2025,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_LENALLOC(inode) -= (adsize * 2);
    + UDF_I(inode)->i_lenAlloc -= (adsize * 2);
    mark_inode_dirty(inode);
    } else {
    aed = (struct allocExtDesc *)oepos.bh->b_data;
    @@ -2038,7 +2044,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_LENALLOC(inode) -= adsize;
    + UDF_I(inode)->i_lenAlloc -= adsize;
    mark_inode_dirty(inode);
    } else {
    aed = (struct allocExtDesc *)oepos.bh->b_data;
    @@ -2077,7 +2083,7 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
    }

    pos->offset = 0;
    - pos->block = UDF_I_LOCATION(inode);
    + pos->block = UDF_I(inode)->i_location;
    pos->bh = NULL;
    *elen = 0;

    @@ -2085,7 +2091,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_LENEXTENTS(inode) = lbcount;
    + UDF_I(inode)->i_lenExtents = lbcount;
    return -1;
    }
    lbcount += *elen;
    diff --git a/fs/udf/misc.c b/fs/udf/misc.c
    index a3a513f..2af4470 100644
    --- a/fs/udf/misc.c
    +++ b/fs/udf/misc.c
    @@ -52,16 +52,16 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    int offset;
    uint16_t crclen;

    - ea = UDF_I_DATA(inode);
    - if (UDF_I_LENEATTR(inode)) {
    - ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(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;
    } else {
    ad = ea;
    size += sizeof(struct extendedAttrHeaderDesc);
    }

    offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
    - UDF_I_LENALLOC(inode);
    + UDF_I(inode)->i_lenAlloc;

    /* TODO - Check for FreeEASpace */

    @@ -69,21 +69,21 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    struct extendedAttrHeaderDesc *eahd;
    eahd = (struct extendedAttrHeaderDesc *)ea;

    - if (UDF_I_LENALLOC(inode))
    - memmove(&ad[size], ad, UDF_I_LENALLOC(inode));
    + if (UDF_I(inode)->i_lenAlloc)
    + memmove(&ad[size], ad, UDF_I(inode)->i_lenAlloc);

    - if (UDF_I_LENEATTR(inode)) {
    + if (UDF_I(inode)->i_lenEAttr) {
    /* check checksum/crc */
    if (eahd->descTag.tagIdent !=
    cpu_to_le16(TAG_IDENT_EAHD) ||
    le32_to_cpu(eahd->descTag.tagLocation) !=
    - UDF_I_LOCATION(inode).logicalBlockNum)
    + UDF_I(inode)->i_location.logicalBlockNum)
    return NULL;
    } else {
    struct udf_sb_info *sbi = UDF_SB(inode->i_sb);

    size -= sizeof(struct extendedAttrHeaderDesc);
    - UDF_I_LENEATTR(inode) +=
    + UDF_I(inode)->i_lenEAttr +=
    sizeof(struct extendedAttrHeaderDesc);
    eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
    if (sbi->s_udfrev >= 0x0200)
    @@ -93,15 +93,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_LOCATION(inode).logicalBlockNum);
    + UDF_I(inode)->i_location.logicalBlockNum);
    eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
    eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
    }

    - offset = UDF_I_LENEATTR(inode);
    + offset = UDF_I(inode)->i_lenEAttr;
    if (type < 2048) {
    if (le32_to_cpu(eahd->appAttrLocation) <
    - UDF_I_LENEATTR(inode)) {
    + UDF_I(inode)->i_lenEAttr) {
    uint32_t aal =
    le32_to_cpu(eahd->appAttrLocation);
    memmove(&ea[offset - aal + size],
    @@ -111,7 +111,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_LENEATTR(inode)) {
    + UDF_I(inode)->i_lenEAttr) {
    uint32_t ial =
    le32_to_cpu(eahd->impAttrLocation);
    memmove(&ea[offset - ial + size],
    @@ -122,7 +122,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    }
    } else if (type < 65536) {
    if (le32_to_cpu(eahd->appAttrLocation) <
    - UDF_I_LENEATTR(inode)) {
    + UDF_I(inode)->i_lenEAttr) {
    uint32_t aal =
    le32_to_cpu(eahd->appAttrLocation);
    memmove(&ea[offset - aal + size],
    @@ -138,7 +138,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_LENEATTR(inode) += size;
    + UDF_I(inode)->i_lenEAttr += size;
    return (struct genericFormat *)&ea[offset];
    }
    if (loc & 0x02)
    @@ -154,9 +154,9 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
    uint8_t *ea = NULL;
    uint32_t offset;

    - ea = UDF_I_DATA(inode);
    + ea = UDF_I(inode)->i_ext.i_data;

    - if (UDF_I_LENEATTR(inode)) {
    + if (UDF_I(inode)->i_lenEAttr) {
    struct extendedAttrHeaderDesc *eahd;
    eahd = (struct extendedAttrHeaderDesc *)ea;

    @@ -164,7 +164,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_LOCATION(inode).logicalBlockNum)
    + UDF_I(inode)->i_location.logicalBlockNum)
    return NULL;

    if (type < 2048)
    @@ -174,7 +174,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
    else
    offset = le32_to_cpu(eahd->appAttrLocation);

    - while (offset < UDF_I_LENEATTR(inode)) {
    + while (offset < UDF_I(inode)->i_lenEAttr) {
    gaf = (struct genericFormat *)&ea[offset];
    if (le32_to_cpu(gaf->attrType) == type &&
    gaf->attrSubtype == subtype)
    diff --git a/fs/udf/namei.c b/fs/udf/namei.c
    index f1cf18f..6bb2cc0 100644
    --- a/fs/udf/namei.c
    +++ b/fs/udf/namei.c
    @@ -54,7 +54,7 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
    sizeof(struct fileIdentDesc);
    int adinicb = 0;

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    adinicb = 1;

    offset = fibh->soffset + sizeof(struct fileIdentDesc);
    @@ -164,16 +164,17 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,

    fibh->soffset = fibh->eoffset =
    (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(dir)->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_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    epos.offset -= sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(dir)->i_alloc_type ==
    + ICBTAG_FLAG_AD_LONG)
    epos.offset -= sizeof(long_ad);
    } else
    offset = 0;
    @@ -372,16 +373,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_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(dir)->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_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    epos.offset -= sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(dir)->i_alloc_type ==
    + ICBTAG_FLAG_AD_LONG)
    epos.offset -= sizeof(long_ad);
    } else
    offset = 0;
    @@ -393,10 +395,10 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
    return NULL;
    }

    - block = UDF_I_LOCATION(dir).logicalBlockNum;
    + block = UDF_I(dir)->i_location.logicalBlockNum;

    } else {
    - block = udf_get_lb_pblock(dir->i_sb, UDF_I_LOCATION(dir), 0);
    + block = udf_get_lb_pblock(dir->i_sb, UDF_I(dir)->i_location, 0);
    fibh->sbh = fibh->ebh = NULL;
    fibh->soffset = fibh->eoffset = sb->s_blocksize;
    goto add;
    @@ -475,7 +477,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
    add:
    f_pos += nfidlen;

    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
    sb->s_blocksize - fibh->eoffset < nfidlen) {
    brelse(epos.bh);
    epos.bh = NULL;
    @@ -489,15 +491,15 @@ add:
    udf_expand_dir_adinicb(dir, &block, err);
    if (!fibh->sbh)
    return NULL;
    - epos.block = UDF_I_LOCATION(dir);
    + epos.block = UDF_I(dir)->i_location;
    eloc.logicalBlockNum = block;
    eloc.partitionReferenceNum =
    - UDF_I_LOCATION(dir).partitionReferenceNum;
    + UDF_I(dir)->i_location.partitionReferenceNum;
    elen = dir->i_sb->s_blocksize;
    epos.offset = udf_file_entry_alloc_offset(dir);
    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    epos.offset += sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    epos.offset += sizeof(long_ad);
    }

    @@ -509,12 +511,13 @@ add:
    fibh->sbh = fibh->ebh;
    }

    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
    - block = UDF_I_LOCATION(dir).logicalBlockNum;
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
    + block = UDF_I(dir)->i_location.logicalBlockNum;
    fi = (struct fileIdentDesc *)
    - (UDF_I_DATA(dir) + fibh->soffset -
    + (UDF_I(dir)->i_ext.i_data +
    + fibh->soffset -
    udf_ext0_offset(dir) +
    - UDF_I_LENEATTR(dir));
    + UDF_I(dir)->i_lenEAttr);
    } else {
    block = eloc.logicalBlockNum +
    ((elen - 1) >>
    @@ -572,8 +575,8 @@ add:
    if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
    brelse(epos.bh);
    dir->i_size += nfidlen;
    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    - UDF_I_LENALLOC(dir) += nfidlen;
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    + UDF_I(dir)->i_lenAlloc += nfidlen;
    mark_inode_dirty(dir);
    return fi;
    } else {
    @@ -613,7 +616,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
    return err;
    }

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    inode->i_data.a_ops = &udf_adinicb_aops;
    else
    inode->i_data.a_ops = &udf_aops;
    @@ -631,11 +634,11 @@ 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_LOCATION(inode));
    + cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
    *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
    - cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
    + cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL);
    udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    mark_inode_dirty(dir);
    if (fibh.sbh != fibh.ebh)
    brelse(fibh.ebh);
    @@ -674,11 +677,11 @@ 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_LOCATION(inode));
    + cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
    *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
    - cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
    + cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL);
    udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    mark_inode_dirty(dir);
    mark_inode_dirty(inode);

    @@ -721,9 +724,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_LOCATION(dir));
    + cfi.icb.extLocation = cpu_to_lelb(UDF_I(dir)->i_location);
    *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
    - cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
    + cpu_to_le32(UDF_I(dir)->i_unique & 0x00000000FFFFFFFFUL);
    cfi.fileCharacteristics =
    FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
    udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
    @@ -741,9 +744,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_LOCATION(inode));
    + cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
    *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
    - cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
    + cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL);
    cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
    udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
    inc_nlink(dir);
    @@ -776,16 +779,17 @@ static int empty_dir(struct inode *dir)
    fibh.soffset = fibh.eoffset =
    (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;

    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(dir)->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_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    epos.offset -= sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(dir)->i_alloc_type ==
    + ICBTAG_FLAG_AD_LONG)
    epos.offset -= sizeof(long_ad);
    } else
    offset = 0;
    @@ -945,28 +949,28 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
    inode->i_data.a_ops = &udf_symlink_aops;
    inode->i_op = &page_symlink_inode_operations;

    - if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB) {
    + if (UDF_I(inode)->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_LOCATION(inode).partitionReferenceNum,
    - UDF_I_LOCATION(inode).logicalBlockNum, &err);
    + UDF_I(inode)->i_location.partitionReferenceNum,
    + UDF_I(inode)->i_location.logicalBlockNum, &err);
    if (!block)
    goto out_no_entry;
    - epos.block = UDF_I_LOCATION(inode);
    + epos.block = UDF_I(inode)->i_location;
    epos.offset = udf_file_entry_alloc_offset(inode);
    epos.bh = NULL;
    eloc.logicalBlockNum = block;
    eloc.partitionReferenceNum =
    - UDF_I_LOCATION(inode).partitionReferenceNum;
    + UDF_I(inode)->i_location.partitionReferenceNum;
    elen = inode->i_sb->s_blocksize;
    - UDF_I_LENEXTENTS(inode) = elen;
    + UDF_I(inode)->i_lenExtents = elen;
    udf_add_aext(inode, &epos, eloc, elen, 0);
    brelse(epos.bh);

    block = udf_get_pblock(inode->i_sb, block,
    - UDF_I_LOCATION(inode).partitionReferenceNum,
    + UDF_I(inode)->i_location.partitionReferenceNum,
    0);
    epos.bh = udf_tread(inode->i_sb, block);
    lock_buffer(epos.bh);
    @@ -976,7 +980,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
    mark_buffer_dirty_inode(epos.bh, inode);
    ea = epos.bh->b_data + udf_ext0_offset(inode);
    } else {
    - ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
    + ea = UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr;
    }

    eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
    @@ -1045,15 +1049,15 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,

    brelse(epos.bh);
    inode->i_size = elen;
    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
    - UDF_I_LENALLOC(inode) = inode->i_size;
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    + UDF_I(inode)->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_LOCATION(inode));
    + cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
    bh = UDF_SB(inode->i_sb)->s_lvid_bh;
    if (bh) {
    struct logicalVolIntegrityDesc *lvid =
    @@ -1071,7 +1075,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
    mark_buffer_dirty(bh);
    }
    udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    mark_inode_dirty(dir);
    if (fibh.sbh != fibh.ebh)
    brelse(fibh.ebh);
    @@ -1110,7 +1114,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
    return err;
    }
    cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
    - cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
    + cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
    bh = UDF_SB(inode->i_sb)->s_lvid_bh;
    if (bh) {
    struct logicalVolIntegrityDesc *lvid =
    @@ -1128,7 +1132,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
    mark_buffer_dirty(bh);
    }
    udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
    - if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    mark_inode_dirty(dir);

    if (fibh.sbh != fibh.ebh)
    @@ -1189,10 +1193,10 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
    goto end_rename;
    }
    retval = -EIO;
    - if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) {
    + if (UDF_I(old_inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
    dir_fi = udf_get_fileident(
    - UDF_I_DATA(old_inode) -
    - (UDF_I_EFE(old_inode) ?
    + UDF_I(old_inode)->i_ext.i_data -
    + (UDF_I(old_inode)->i_efe ?
    sizeof(struct extendedFileEntry) :
    sizeof(struct fileEntry)),
    old_inode->i_sb->s_blocksize, &offset);
    @@ -1250,11 +1254,11 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
    mark_inode_dirty(old_dir);

    if (dir_fi) {
    - dir_fi->icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(new_dir));
    + dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location);
    udf_update_tag((char *)dir_fi,
    (sizeof(struct fileIdentDesc) +
    le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
    - if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB)
    + if (UDF_I(old_inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
    mark_inode_dirty(old_inode);
    else
    mark_buffer_dirty_inode(dir_bh, old_inode);
    diff --git a/fs/udf/partition.c b/fs/udf/partition.c
    index 027c879..cfe213f 100644
    --- a/fs/udf/partition.c
    +++ b/fs/udf/partition.c
    @@ -88,14 +88,14 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,

    brelse(bh);

    - if (UDF_I_LOCATION(sbi->s_vat_inode).partitionReferenceNum ==
    + if (UDF_I(sbi->s_vat_inode)->i_location.partitionReferenceNum ==
    partition) {
    udf_debug("recursive call to udf_get_pblock!\n");
    return 0xFFFFFFFF;
    }

    return udf_get_pblock(sb, loc,
    - UDF_I_LOCATION(sbi->s_vat_inode).
    + UDF_I(sbi->s_vat_inode)->i_location.
    partitionReferenceNum,
    offset);
    }
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index b102958..52d2c32 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -2046,7 +2046,7 @@ static unsigned int udf_count_free_table(struct super_block *sb,

    lock_kernel();

    - epos.block = UDF_I_LOCATION(table);
    + epos.block = UDF_I(table)->i_location;
    epos.offset = sizeof(struct unallocSpaceEntry);
    epos.bh = NULL;

    diff --git a/fs/udf/symlink.c b/fs/udf/symlink.c
    index dcf06ef..d55989c 100644
    --- a/fs/udf/symlink.c
    +++ b/fs/udf/symlink.c
    @@ -81,8 +81,8 @@ static int udf_symlink_filler(struct file *file, struct page *page)
    char *p = kmap(page);

    lock_kernel();
    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
    - symlink = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
    + 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;
    } else {
    bh = sb_bread(inode->i_sb, udf_block_map(inode, 0));

    diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
    index 5c1bf92..8eb1d24 100644
    --- a/fs/udf/truncate.c
    +++ b/fs/udf/truncate.c
    @@ -75,16 +75,16 @@ void udf_truncate_tail_extent(struct inode *inode)
    int8_t etype = -1, netype;
    int adsize;

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB ||
    - inode->i_size == UDF_I_LENEXTENTS(inode))
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
    + inode->i_size == UDF_I(inode)->i_lenExtents)
    return;
    /* Are we going to delete the file anyway? */
    if (inode->i_nlink == 0)
    return;

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    adsize = sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    adsize = sizeof(long_ad);
    else
    BUG();
    @@ -117,7 +117,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_LENEXTENTS(inode) = inode->i_size;
    + UDF_I(inode)->i_lenExtents = inode->i_size;
    brelse(epos.bh);
    }

    @@ -130,18 +130,18 @@ void udf_discard_prealloc(struct inode *inode)
    int8_t etype = -1, netype;
    int adsize;

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB ||
    - inode->i_size == UDF_I_LENEXTENTS(inode))
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
    + inode->i_size == UDF_I(inode)->i_lenExtents)
    return;

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    adsize = sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    adsize = sizeof(long_ad);
    else
    adsize = 0;

    - epos.block = UDF_I_LOCATION(inode);
    + epos.block = UDF_I(inode)->i_location;

    /* Find the last extent in the file */
    while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
    @@ -153,7 +153,7 @@ void udf_discard_prealloc(struct inode *inode)
    lbcount -= elen;
    extent_trunc(inode, &epos, eloc, etype, elen, 0);
    if (!epos.bh) {
    - UDF_I_LENALLOC(inode) =
    + UDF_I(inode)->i_lenAlloc =
    epos.offset -
    udf_file_entry_alloc_offset(inode);
    mark_inode_dirty(inode);
    @@ -174,7 +174,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_LENEXTENTS(inode) = lbcount;
    + UDF_I(inode)->i_lenExtents = lbcount;
    brelse(epos.bh);
    }

    @@ -190,9 +190,9 @@ void udf_truncate_extents(struct inode *inode)
    loff_t byte_offset;
    int adsize;

    - if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
    + if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
    adsize = sizeof(short_ad);
    - else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
    + else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    adsize = sizeof(long_ad);
    else
    BUG();
    @@ -227,7 +227,7 @@ void udf_truncate_extents(struct inode *inode)
    0, indirect_ext_len);
    } else {
    if (!epos.bh) {
    - UDF_I_LENALLOC(inode) =
    + UDF_I(inode)->i_lenAlloc =
    lenalloc;
    mark_inode_dirty(inode);
    } else {
    @@ -275,7 +275,7 @@ void udf_truncate_extents(struct inode *inode)
    indirect_ext_len);
    } else {
    if (!epos.bh) {
    - UDF_I_LENALLOC(inode) = lenalloc;
    + UDF_I(inode)->i_lenAlloc = lenalloc;
    mark_inode_dirty(inode);
    } else {
    struct allocExtDesc *aed =
    @@ -325,7 +325,7 @@ void udf_truncate_extents(struct inode *inode)
    (sb->s_blocksize - 1)) != 0));
    }
    }
    - UDF_I_LENEXTENTS(inode) = inode->i_size;
    + UDF_I(inode)->i_lenExtents = inode->i_size;

    brelse(epos.bh);
    }
    diff --git a/fs/udf/udf_i.h b/fs/udf/udf_i.h
    index d7dbe6f..ccc52f1 100644
    --- a/fs/udf/udf_i.h
    +++ b/fs/udf/udf_i.h
    @@ -7,20 +7,4 @@ static inline struct udf_inode_info *UDF_I(struct inode *inode)
    return list_entry(inode, struct udf_inode_info, vfs_inode);
    }

    -#define UDF_I_LOCATION(X) ( UDF_I(X)->i_location )
    -#define UDF_I_LENEATTR(X) ( UDF_I(X)->i_lenEAttr )
    -#define UDF_I_LENALLOC(X) ( UDF_I(X)->i_lenAlloc )
    -#define UDF_I_LENEXTENTS(X) ( UDF_I(X)->i_lenExtents )
    -#define UDF_I_UNIQUE(X) ( UDF_I(X)->i_unique )
    -#define UDF_I_ALLOCTYPE(X) ( UDF_I(X)->i_alloc_type )
    -#define UDF_I_EFE(X) ( UDF_I(X)->i_efe )
    -#define UDF_I_USE(X) ( UDF_I(X)->i_use )
    -#define UDF_I_STRAT4096(X) ( UDF_I(X)->i_strat4096 )
    -#define UDF_I_NEXT_ALLOC_BLOCK(X) ( UDF_I(X)->i_next_alloc_block )
    -#define UDF_I_NEXT_ALLOC_GOAL(X) ( UDF_I(X)->i_next_alloc_goal )
    -#define UDF_I_CRTIME(X) ( UDF_I(X)->i_crtime )
    -#define UDF_I_SAD(X) ( UDF_I(X)->i_ext.i_sad )
    -#define UDF_I_LAD(X) ( UDF_I(X)->i_ext.i_lad )
    -#define UDF_I_DATA(X) ( UDF_I(X)->i_ext.i_data )
    -
    #endif /* !defined(_LINUX_UDF_I_H) */
    diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
    index 005e3ad..681dc2b 100644
    --- a/fs/udf/udfdecl.h
    +++ b/fs/udf/udfdecl.h
    @@ -24,14 +24,14 @@
    #define UDF_PATH_LEN 1023

    #define udf_file_entry_alloc_offset(inode)\
    - (UDF_I_USE(inode) ?\
    + (UDF_I(inode)->i_use ?\
    sizeof(struct unallocSpaceEntry) :\
    - ((UDF_I_EFE(inode) ?\
    + ((UDF_I(inode)->i_efe ?\
    sizeof(struct extendedFileEntry) :\
    - sizeof(struct fileEntry)) + UDF_I_LENEATTR(inode)))
    + sizeof(struct fileEntry)) + UDF_I(inode)->i_lenEAttr))

    #define udf_ext0_offset(inode)\
    - (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB ?\
    + (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ?\
    udf_file_entry_alloc_offset(inode) : 0)

    #define udf_get_lb_pblock(sb,loc,offset) udf_get_pblock((sb), (loc).logicalBlockNum, (loc).partitionReferenceNum, (offset))
    --
    1.5.3.7

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  10. [PATCH 14/16] 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
    Acked-by: Jan Kara
    ---
    fs/udf/balloc.c | 35 ++++---
    fs/udf/dir.c | 9 +-
    fs/udf/directory.c | 7 +-
    fs/udf/file.c | 21 ++--
    fs/udf/ialloc.c | 49 +++++----
    fs/udf/inode.c | 305 ++++++++++++++++++++++++++++------------------------
    fs/udf/misc.c | 40 ++++----
    fs/udf/namei.c | 112 +++++++++++---------
    fs/udf/partition.c | 8 +-
    fs/udf/symlink.c | 6 +-
    fs/udf/truncate.c | 37 ++++---
    11 files changed, 338 insertions(+), 291 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index ec6d44c..1a11dd2 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -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 &&
    diff --git a/fs/udf/dir.c b/fs/udf/dir.c
    index 61b49c5..cedc141 100644
    --- a/fs/udf/dir.c
    +++ b/fs/udf/dir.c
    @@ -58,6 +58,7 @@ static int do_udf_readdir(struct inode *dir, struct file *filp,
    unsigned int dt_type;
    struct extent_position epos = { NULL, 0, {0, 0} };
    unsigned char bits;
    + struct udf_inode_info *iinfo;

    if (nf_pos >= size)
    return 0;
    @@ -69,17 +70,17 @@ static int do_udf_readdir(struct inode *dir, struct file *filp,
    (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
    bits = dir->i_sb->s_blocksize_bits;

    - 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 >> (bits - 2),
    &epos, &eloc, &elen, &offset) ==
    (EXT_RECORDED_ALLOCATED >> 30)) {
    block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
    if ((++offset << 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 ==
    - ICBTAG_FLAG_AD_LONG)
    + else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
    epos.offset -= sizeof(long_ad);
    } else
    offset = 0;
    diff --git a/fs/udf/directory.c b/fs/udf/directory.c
    index cd3da31..496c43f 100644
    --- a/fs/udf/directory.c
    +++ b/fs/udf/directory.c
    @@ -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,
    diff --git a/fs/udf/file.c b/fs/udf/file.c
    index a1e07a1..97c71ae 100644
    --- a/fs/udf/file.c
    +++ b/fs/udf/file.c
    @@ -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;
    }
    }

    diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
    index 5ed8cda..8436031 100644
    --- a/fs/udf/ialloc.c
    +++ b/fs/udf/ialloc.c
    @@ -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);
    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index b0eb878..466d2ee 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;
    sector_t phys = 0;
    + 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;
    diff --git a/fs/udf/misc.c b/fs/udf/misc.c
    index 2af4470..a1d6da0 100644
    --- a/fs/udf/misc.c
    +++ b/fs/udf/misc.c
    @@ -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)
    diff --git a/fs/udf/namei.c b/fs/udf/namei.c
    index 6bb2cc0..4bf83d5 100644
    --- a/fs/udf/namei.c
    +++ b/fs/udf/namei.c
    @@ -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);
    diff --git a/fs/udf/partition.c b/fs/udf/partition.c
    index cfe213f..fc53334 100644
    --- a/fs/udf/partition.c
    +++ b/fs/udf/partition.c
    @@ -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);
    }

    diff --git a/fs/udf/symlink.c b/fs/udf/symlink.c
    index d55989c..6ec9922 100644
    --- a/fs/udf/symlink.c
    +++ b/fs/udf/symlink.c
    @@ -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));

    diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
    index 8eb1d24..fe61be1 100644
    --- a/fs/udf/truncate.c
    +++ b/fs/udf/truncate.c
    @@ -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);
    }
    --
    1.5.3.7

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  11. Re: [PATCH 04/16] udf: check if udf_load_logicalvol failed

    On Thu 10-01-08 23:06:20, marcin.slusarz@gmail.com wrote:
    > udf_load_logicalvol may fail eg in out of memory conditions - check it
    > and propagate error further
    >
    > Signed-off-by: Marcin Slusarz
    > CC: Ben Fennema
    > CC: Jan Kara
    > CC: Christoph Hellwig

    Acked-by: Jan Kara

    > ---
    > fs/udf/super.c | 5 ++++-
    > 1 files changed, 4 insertions(+), 1 deletions(-)
    >
    > diff --git a/fs/udf/super.c b/fs/udf/super.c
    > index 3f5b632..9257796 100644
    > --- a/fs/udf/super.c
    > +++ b/fs/udf/super.c
    > @@ -1263,7 +1263,10 @@ static int udf_process_sequence(struct super_block *sb, long block,
    > if (i == VDS_POS_PRIMARY_VOL_DESC) {
    > udf_load_pvoldesc(sb, bh);
    > } else if (i == VDS_POS_LOGICAL_VOL_DESC) {
    > - udf_load_logicalvol(sb, bh, fileset); /* TODO: check return value */
    > + if (udf_load_logicalvol(sb, bh, fileset)) {
    > + brelse(bh);
    > + return 1;
    > + }
    > } else if (i == VDS_POS_PARTITION_DESC) {
    > struct buffer_head *bh2 = NULL;
    > if (udf_load_partdesc(sb, bh)) {
    > --
    > 1.5.3.7
    >


    Honza
    --
    Jan Kara
    SUSE Labs, CR
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  12. Re: [PATCH 05/16] udf: convert macros related to bitmaps to functions

    On Thu 10-01-08 23:06:21, marcin.slusarz@gmail.com wrote:
    > convert UDF_SB_ALLOC_BITMAP macro to udf_sb_alloc_bitmap function
    > convert UDF_SB_FREE_BITMAP macro to udf_sb_free_bitmap function
    >
    > Signed-off-by: Marcin Slusarz
    > CC: Ben Fennema
    > CC: Jan Kara
    > CC: Christoph Hellwig

    Acked-by: Jan Kara

    > ---
    > fs/udf/super.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++++-----
    > fs/udf/udf_sb.h | 38 ----------------------------------
    > 2 files changed, 55 insertions(+), 44 deletions(-)
    >
    > diff --git a/fs/udf/super.c b/fs/udf/super.c
    > index 9257796..2344157 100644
    > --- a/fs/udf/super.c
    > +++ b/fs/udf/super.c
    > @@ -937,6 +937,39 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
    > root->logicalBlockNum, root->partitionReferenceNum);
    > }
    >
    > +static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
    > +{
    > + struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[index];
    > + struct udf_bitmap *bitmap;
    > + int nr_groups;
    > + int size;
    > +
    > + /* TODO: move calculating of nr_groups into helper function */
    > + nr_groups = (map->s_partition_len +
    > + (sizeof(struct spaceBitmapDesc) << 3) +
    > + (sb->s_blocksize * 8) - 1) /
    > + (sb->s_blocksize * 8);
    > + size = sizeof(struct udf_bitmap) +
    > + (sizeof(struct buffer_head *) * nr_groups);
    > +
    > + if (size <= PAGE_SIZE)
    > + bitmap = kmalloc(size, GFP_KERNEL);
    > + else
    > + bitmap = vmalloc(size); /* TODO: get rid of vmalloc */
    > +
    > + if (bitmap == NULL) {
    > + udf_error(sb, __FUNCTION__,
    > + "Unable to allocate space for bitmap "
    > + "and %d buffer_head pointers", nr_groups);
    > + return NULL;
    > + }
    > +
    > + memset(bitmap, 0x00, size);
    > + bitmap->s_block_bitmap = (struct buffer_head **)(bitmap + 1);
    > + bitmap->s_nr_groups = nr_groups;
    > + return bitmap;
    > +}
    > +
    > static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    > {
    > struct partitionDesc *p;
    > @@ -987,7 +1020,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    > i, map->s_uspace.s_table->i_ino);
    > }
    > if (phd->unallocSpaceBitmap.extLength) {
    > - UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
    > + map->s_uspace.s_bitmap = udf_sb_alloc_bitmap(sb, i);
    > if (map->s_uspace.s_bitmap != NULL) {
    > map->s_uspace.s_bitmap->s_extLength =
    > le32_to_cpu(phd->unallocSpaceBitmap.extLength);
    > @@ -1017,7 +1050,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    > i, map->s_fspace.s_table->i_ino);
    > }
    > if (phd->freedSpaceBitmap.extLength) {
    > - UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
    > + map->s_fspace.s_bitmap = udf_sb_alloc_bitmap(sb, i);
    > if (map->s_fspace.s_bitmap != NULL) {
    > map->s_fspace.s_bitmap->s_extLength =
    > le32_to_cpu(phd->freedSpaceBitmap.extLength);
    > @@ -1504,6 +1537,22 @@ static void udf_close_lvid(struct super_block *sb)
    > }
    > }
    >
    > +static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
    > +{
    > + int i;
    > + int nr_groups = bitmap->s_nr_groups;
    > + int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);
    > +
    > + for (i = 0; i < nr_groups; i++)
    > + if (bitmap->s_block_bitmap[i])
    > + brelse(bitmap->s_block_bitmap[i]);
    > +
    > + if (size <= PAGE_SIZE)
    > + kfree(bitmap);
    > + else
    > + vfree(bitmap);
    > +}
    > +
    > /*
    > * udf_read_super
    > *
    > @@ -1689,9 +1738,9 @@ error_out:
    > if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
    > iput(map->s_fspace.s_table);
    > if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
    > - UDF_SB_FREE_BITMAP(sb, sbi->s_partition, s_uspace);
    > + udf_sb_free_bitmap(map->s_uspace.s_bitmap);
    > if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
    > - UDF_SB_FREE_BITMAP(sb, sbi->s_partition, s_fspace);
    > + udf_sb_free_bitmap(map->s_fspace.s_bitmap);
    > if (map->s_partition_type == UDF_SPARABLE_MAP15)
    > for (i = 0; i < 4; i++)
    > brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
    > @@ -1767,9 +1816,9 @@ static void udf_put_super(struct super_block *sb)
    > if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
    > iput(map->s_fspace.s_table);
    > if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
    > - UDF_SB_FREE_BITMAP(sb, sbi->s_partition, s_uspace);
    > + udf_sb_free_bitmap(map->s_uspace.s_bitmap);
    > if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
    > - UDF_SB_FREE_BITMAP(sb, sbi->s_partition, s_fspace);
    > + udf_sb_free_bitmap(map->s_fspace.s_bitmap);
    > if (map->s_partition_type == UDF_SPARABLE_MAP15)
    > for (i = 0; i < 4; i++)
    > brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
    > diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    > index 4d3bd77..2c05f82 100644
    > --- a/fs/udf/udf_sb.h
    > +++ b/fs/udf/udf_sb.h
    > @@ -43,46 +43,8 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
    >
    > struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi);
    >
    > -#define UDF_SB_ALLOC_BITMAP(X,Y,Z)\
    > -{\
    > - struct udf_sb_info *sbi = UDF_SB(X);\
    > - int nr_groups = ((sbi->s_partmaps[(Y)].s_partition_len + (sizeof(struct spaceBitmapDesc) << 3) +\
    > - ((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\
    > - int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
    > - if (size <= PAGE_SIZE)\
    > - sbi->s_partmaps[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
    > - else\
    > - sbi->s_partmaps[(Y)].Z.s_bitmap = vmalloc(size);\
    > - if (sbi->s_partmaps[(Y)].Z.s_bitmap != NULL) {\
    > - memset(sbi->s_partmaps[(Y)].Z.s_bitmap, 0x00, size);\
    > - sbi->s_partmaps[(Y)].Z.s_bitmap->s_block_bitmap =\
    > - (struct buffer_head **)(sbi->s_partmaps[(Y)].Z.s_bitmap + 1);\
    > - sbi->s_partmaps[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
    > - } else {\
    > - udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\
    > - }\
    > -}
    > -
    > -#define UDF_SB_FREE_BITMAP(X,Y,Z)\
    > -{\
    > - int i;\
    > - int nr_groups = UDF_SB_BITMAP_NR_GROUPS(X,Y,Z);\
    > - int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
    > - for (i = 0; i < nr_groups; i++) {\
    > - if (UDF_SB_BITMAP(X,Y,Z,i))\
    > - brelse(UDF_SB_BITMAP(X,Y,Z,i));\
    > - }\
    > - if (size <= PAGE_SIZE)\
    > - kfree(UDF_SB(X)->s_partmaps[Y].Z.s_bitmap);\
    > - else\
    > - vfree(UDF_SB(X)->s_partmaps[Y].Z.s_bitmap);\
    > -}
    > -
    > #define UDF_QUERY_FLAG(X,Y) ( UDF_SB(X)->s_flags & ( 1 << (Y) ) )
    > #define UDF_SET_FLAG(X,Y) ( UDF_SB(X)->s_flags |= ( 1 << (Y) ) )
    > #define UDF_CLEAR_FLAG(X,Y) ( UDF_SB(X)->s_flags &= ~( 1 << (Y) ) )
    >
    > -#define UDF_SB_BITMAP(X,Y,Z,I) ( UDF_SB(X)->s_partmaps[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    > -#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( UDF_SB(X)->s_partmaps[(Y)].Z.s_bitmap->s_nr_groups )
    > -
    > #endif /* __LINUX_UDF_SB_H */
    > --
    > 1.5.3.7


    Honza
    --
    Jan Kara
    SUSE Labs, CR
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  13. Re: [PATCH 09/16] udf: create common function for tag checksumming

    On Thu 10-01-08 23:06:25, marcin.slusarz@gmail.com wrote:
    > Signed-off-by: Marcin Slusarz
    > CC: Jan Kara
    > CC: Christoph Hellwig

    Acked-by: Jan Kara

    > ---
    > fs/udf/inode.c | 15 ++-------------
    > fs/udf/misc.c | 35 ++++++++++++++---------------------
    > fs/udf/namei.c | 9 +--------
    > fs/udf/super.c | 16 ++--------------
    > fs/udf/udfdecl.h | 3 +++
    > 5 files changed, 22 insertions(+), 56 deletions(-)
    >
    > diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    > index 9adde18..6751945 100644
    > --- a/fs/udf/inode.c
    > +++ b/fs/udf/inode.c
    > @@ -1440,7 +1440,6 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    > uint32_t udfperms;
    > uint16_t icbflags;
    > uint16_t crclen;
    > - int i;
    > kernel_timestamp cpu_time;
    > int err = 0;
    > struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
    > @@ -1476,12 +1475,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    > use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use +
    > sizeof(tag), crclen,
    > 0));
    > -
    > - use->descTag.tagChecksum = 0;
    > - for (i = 0; i < 16; i++)
    > - if (i != 4)
    > - use->descTag.tagChecksum +=
    > - ((uint8_t *)&(use->descTag))[i];
    > + use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);
    >
    > mark_buffer_dirty(bh);
    > brelse(bh);
    > @@ -1650,12 +1644,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    > fe->descTag.descCRCLength = cpu_to_le16(crclen);
    > fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag),
    > crclen, 0));
    > -
    > - fe->descTag.tagChecksum = 0;
    > - for (i = 0; i < 16; i++)
    > - if (i != 4)
    > - fe->descTag.tagChecksum +=
    > - ((uint8_t *)&(fe->descTag))[i];
    > + fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
    >
    > /* write the data blocks */
    > mark_buffer_dirty(bh);
    > diff --git a/fs/udf/misc.c b/fs/udf/misc.c
    > index a0bf415..585e4ea 100644
    > --- a/fs/udf/misc.c
    > +++ b/fs/udf/misc.c
    > @@ -51,7 +51,6 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    > uint8_t *ea = NULL, *ad = NULL;
    > int offset;
    > uint16_t crclen;
    > - int i;
    >
    > ea = UDF_I_DATA(inode);
    > if (UDF_I_LENEATTR(inode)) {
    > @@ -138,11 +137,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    > eahd->descTag.descCRCLength = cpu_to_le16(crclen);
    > eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
    > sizeof(tag), crclen, 0));
    > - eahd->descTag.tagChecksum = 0;
    > - for (i = 0; i < 16; i++)
    > - if (i != 4)
    > - eahd->descTag.tagChecksum +=
    > - ((uint8_t *)&(eahd->descTag))[i];
    > + eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag);
    > UDF_I_LENEATTR(inode) += size;
    > return (struct genericFormat *)&ea[offset];
    > }
    > @@ -207,8 +202,6 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
    > {
    > tag *tag_p;
    > struct buffer_head *bh = NULL;
    > - register uint8_t checksum;
    > - register int i;
    > struct udf_sb_info *sbi = UDF_SB(sb);
    >
    > /* Read the block */
    > @@ -234,12 +227,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
    > }
    >
    > /* Verify the tag checksum */
    > - checksum = 0U;
    > - for (i = 0; i < 4; i++)
    > - checksum += (uint8_t)(bh->b_data[i]);
    > - for (i = 5; i < 16; i++)
    > - checksum += (uint8_t)(bh->b_data[i]);
    > - if (checksum != tag_p->tagChecksum) {
    > + if (udf_tag_checksum(tag_p) != tag_p->tagChecksum) {
    > printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
    > goto error_out;
    > }
    > @@ -277,17 +265,11 @@ struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
    > void udf_update_tag(char *data, int length)
    > {
    > tag *tptr = (tag *)data;
    > - int i;
    > -
    > length -= sizeof(tag);
    >
    > - tptr->tagChecksum = 0;
    > tptr->descCRCLength = cpu_to_le16(length);
    > tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0));
    > -
    > - for (i = 0; i < 16; i++)
    > - if (i != 4)
    > - tptr->tagChecksum += (uint8_t)(data[i]);
    > + tptr->tagChecksum = udf_tag_checksum(tptr);
    > }
    >
    > void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
    > @@ -300,3 +282,14 @@ void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
    > tptr->tagLocation = cpu_to_le32(loc);
    > udf_update_tag(data, length);
    > }
    > +
    > +u8 udf_tag_checksum(const tag *t)
    > +{
    > + u8 *data = (u8 *)t;
    > + u8 checksum = 0;
    > + int i;
    > + for (i = 0; i < sizeof(tag); ++i)
    > + if (i != 4) /* position of checksum */
    > + checksum += data[i];
    > + return checksum;
    > +}
    > diff --git a/fs/udf/namei.c b/fs/udf/namei.c
    > index 25d518b..f1cf18f 100644
    > --- a/fs/udf/namei.c
    > +++ b/fs/udf/namei.c
    > @@ -47,8 +47,6 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
    > {
    > uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag);
    > uint16_t crc;
    > - uint8_t checksum = 0;
    > - int i;
    > int offset;
    > uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse);
    > uint8_t lfi = cfi->lengthFileIdent;
    > @@ -122,13 +120,8 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
    >
    > cfi->descTag.descCRC = cpu_to_le16(crc);
    > cfi->descTag.descCRCLength = cpu_to_le16(crclen);
    > + cfi->descTag.tagChecksum = udf_tag_checksum(&cfi->descTag);
    >
    > - for (i = 0; i < 16; i++) {
    > - if (i != 4)
    > - checksum += ((uint8_t *)&cfi->descTag)[i];
    > - }
    > -
    > - cfi->descTag.tagChecksum = checksum;
    > if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) {
    > memcpy((uint8_t *)sfi, (uint8_t *)cfi,
    > sizeof(struct fileIdentDesc));
    > diff --git a/fs/udf/super.c b/fs/udf/super.c
    > index 7f75a94..12fb91d 100644
    > --- a/fs/udf/super.c
    > +++ b/fs/udf/super.c
    > @@ -1564,7 +1564,6 @@ static void udf_open_lvid(struct super_block *sb)
    > struct udf_sb_info *sbi = UDF_SB(sb);
    > struct buffer_head *bh = sbi->s_lvid_bh;
    > if (bh) {
    > - int i;
    > kernel_timestamp cpu_time;
    > struct logicalVolIntegrityDesc *lvid =
    > (struct logicalVolIntegrityDesc *)bh->b_data;
    > @@ -1582,12 +1581,7 @@ static void udf_open_lvid(struct super_block *sb)
    > le16_to_cpu(lvid->descTag.descCRCLength),
    > 0));
    >
    > - lvid->descTag.tagChecksum = 0;
    > - for (i = 0; i < 16; i++)
    > - if (i != 4)
    > - lvid->descTag.tagChecksum +=
    > - ((uint8_t *) &(lvid->descTag))[i];
    > -
    > + lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
    > mark_buffer_dirty(bh);
    > }
    > }
    > @@ -1595,7 +1589,6 @@ static void udf_open_lvid(struct super_block *sb)
    > static void udf_close_lvid(struct super_block *sb)
    > {
    > kernel_timestamp cpu_time;
    > - int i;
    > struct udf_sb_info *sbi = UDF_SB(sb);
    > struct buffer_head *bh = sbi->s_lvid_bh;
    > struct logicalVolIntegrityDesc *lvid;
    > @@ -1626,12 +1619,7 @@ static void udf_close_lvid(struct super_block *sb)
    > le16_to_cpu(lvid->descTag.descCRCLength),
    > 0));
    >
    > - lvid->descTag.tagChecksum = 0;
    > - for (i = 0; i < 16; i++)
    > - if (i != 4)
    > - lvid->descTag.tagChecksum +=
    > - ((uint8_t *)&(lvid->descTag))[i];
    > -
    > + lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
    > mark_buffer_dirty(bh);
    > }
    > }
    > diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
    > index b17ca67..005e3ad 100644
    > --- a/fs/udf/udfdecl.h
    > +++ b/fs/udf/udfdecl.h
    > @@ -36,6 +36,9 @@
    >
    > #define udf_get_lb_pblock(sb,loc,offset) udf_get_pblock((sb), (loc).logicalBlockNum, (loc).partitionReferenceNum, (offset))
    >
    > +/* computes tag checksum */
    > +u8 udf_tag_checksum(const tag *t);
    > +
    > struct dentry;
    > struct inode;
    > struct task_struct;


    Honza
    --
    Jan Kara
    SUSE Labs, CR
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  14. Re: [PATCH 06/16] udf: move calculating of nr_groups into helper function

    On Thu 10-01-08 23:06:22, marcin.slusarz@gmail.com wrote:
    > Signed-off-by: Marcin Slusarz
    > CC: Ben Fennema
    > CC: Jan Kara
    > CC: Christoph Hellwig

    Acked-by: Jan Kara

    > ---
    > fs/udf/balloc.c | 4 +---
    > fs/udf/super.c | 16 ++++++++++------
    > fs/udf/udf_sb.h | 2 ++
    > 3 files changed, 13 insertions(+), 9 deletions(-)
    >
    > diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    > index 8c0c279..3f67d9d 100644
    > --- a/fs/udf/balloc.c
    > +++ b/fs/udf/balloc.c
    > @@ -231,9 +231,7 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    > block_count = part_len - first_block;
    >
    > repeat:
    > - nr_groups = (sbi->s_partmaps[partition].s_partition_len +
    > - (sizeof(struct spaceBitmapDesc) << 3) +
    > - (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
    > + nr_groups = udf_compute_nr_groups(sb, partition);
    > block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
    > block_group = block >> (sb->s_blocksize_bits + 3);
    > group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
    > diff --git a/fs/udf/super.c b/fs/udf/super.c
    > index 2344157..187aff9 100644
    > --- a/fs/udf/super.c
    > +++ b/fs/udf/super.c
    > @@ -937,18 +937,22 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
    > root->logicalBlockNum, root->partitionReferenceNum);
    > }
    >
    > +int udf_compute_nr_groups(struct super_block *sb, u32 partition)
    > +{
    > + struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
    > + return (map->s_partition_len +
    > + (sizeof(struct spaceBitmapDesc) << 3) +
    > + (sb->s_blocksize * 8) - 1) /
    > + (sb->s_blocksize * 8);
    > +}
    > +
    > static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
    > {
    > - struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[index];
    > struct udf_bitmap *bitmap;
    > int nr_groups;
    > int size;
    >
    > - /* TODO: move calculating of nr_groups into helper function */
    > - nr_groups = (map->s_partition_len +
    > - (sizeof(struct spaceBitmapDesc) << 3) +
    > - (sb->s_blocksize * 8) - 1) /
    > - (sb->s_blocksize * 8);
    > + nr_groups = udf_compute_nr_groups(sb, index);
    > size = sizeof(struct udf_bitmap) +
    > (sizeof(struct buffer_head *) * nr_groups);
    >
    > diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    > index 2c05f82..d9adb0f 100644
    > --- a/fs/udf/udf_sb.h
    > +++ b/fs/udf/udf_sb.h
    > @@ -43,6 +43,8 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
    >
    > struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi);
    >
    > +int udf_compute_nr_groups(struct super_block *sb, u32 partition);
    > +
    > #define UDF_QUERY_FLAG(X,Y) ( UDF_SB(X)->s_flags & ( 1 << (Y) ) )
    > #define UDF_SET_FLAG(X,Y) ( UDF_SB(X)->s_flags |= ( 1 << (Y) ) )
    > #define UDF_CLEAR_FLAG(X,Y) ( UDF_SB(X)->s_flags &= ~( 1 << (Y) ) )
    > --
    > 1.5.3.7
    >


    Honza
    --
    Jan Kara
    SUSE Labs, CR
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  15. Re: [PATCH 11/16] udf: replace loops coded with goto to real loops

    On Thu 10-01-08 23:06:27, marcin.slusarz@gmail.com wrote:
    > Signed-off-by: Marcin Slusarz
    > CC: Jan Kara
    > CC: Christoph Hellwig

    Acked-by: Jan Kara

    > ---
    > fs/udf/balloc.c | 118 +++++++++++++++++++++++++++---------------------------
    > 1 files changed, 59 insertions(+), 59 deletions(-)
    >
    > diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    > index 78dbf1d..df55d9f 100644
    > --- a/fs/udf/balloc.c
    > +++ b/fs/udf/balloc.c
    > @@ -183,46 +183,46 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
    > block = bloc.logicalBlockNum + offset +
    > (sizeof(struct spaceBitmapDesc) << 3);
    >
    > -do_more:
    > - overflow = 0;
    > - block_group = block >> (sb->s_blocksize_bits + 3);
    > - bit = block % (sb->s_blocksize << 3);
    > + do {
    > + overflow = 0;
    > + block_group = block >> (sb->s_blocksize_bits + 3);
    > + bit = block % (sb->s_blocksize << 3);
    >
    > - /*
    > - * Check to see if we are freeing blocks across a group boundary.
    > - */
    > - if (bit + count > (sb->s_blocksize << 3)) {
    > - overflow = bit + count - (sb->s_blocksize << 3);
    > - count -= overflow;
    > - }
    > - bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
    > - if (bitmap_nr < 0)
    > - goto error_return;
    > + /*
    > + * Check to see if we are freeing blocks across a group boundary.
    > + */
    > + if (bit + count > (sb->s_blocksize << 3)) {
    > + overflow = bit + count - (sb->s_blocksize << 3);
    > + count -= overflow;
    > + }
    > + bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
    > + if (bitmap_nr < 0)
    > + goto error_return;
    >
    > - bh = bitmap->s_block_bitmap[bitmap_nr];
    > - for (i = 0; i < count; i++) {
    > - if (udf_set_bit(bit + i, bh->b_data)) {
    > - udf_debug("bit %ld already set\n", bit + i);
    > - udf_debug("byte=%2x\n",
    > - ((char *)bh->b_data)[(bit + i) >> 3]);
    > - } else {
    > - if (inode)
    > - DQUOT_FREE_BLOCK(inode, 1);
    > - udf_inc_free_space(sbi, sbi->s_partition, 1);
    > + bh = bitmap->s_block_bitmap[bitmap_nr];
    > + for (i = 0; i < count; i++) {
    > + if (udf_set_bit(bit + i, bh->b_data)) {
    > + udf_debug("bit %ld already set\n", bit + i);
    > + udf_debug("byte=%2x\n",
    > + ((char *)bh->b_data)[(bit + i) >> 3]);
    > + } else {
    > + if (inode)
    > + DQUOT_FREE_BLOCK(inode, 1);
    > + udf_inc_free_space(sbi, sbi->s_partition, 1);
    > + }
    > }
    > - }
    > - mark_buffer_dirty(bh);
    > - if (overflow) {
    > - block += count;
    > - count = overflow;
    > - goto do_more;
    > - }
    > + mark_buffer_dirty(bh);
    > + if (overflow) {
    > + block += count;
    > + count = overflow;
    > + }
    > + } while (overflow);
    > +
    > error_return:
    > sb->s_dirt = 1;
    > if (sbi->s_lvid_bh)
    > mark_buffer_dirty(sbi->s_lvid_bh);
    > mutex_unlock(&sbi->s_alloc_mutex);
    > - return;
    > }
    >
    > static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    > @@ -246,37 +246,37 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    > if (first_block + block_count > part_len)
    > block_count = part_len - first_block;
    >
    > -repeat:
    > - nr_groups = udf_compute_nr_groups(sb, partition);
    > - block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
    > - block_group = block >> (sb->s_blocksize_bits + 3);
    > - group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
    > + do {
    > + nr_groups = udf_compute_nr_groups(sb, partition);
    > + block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
    > + block_group = block >> (sb->s_blocksize_bits + 3);
    > + group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
    >
    > - bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
    > - if (bitmap_nr < 0)
    > - goto out;
    > - bh = bitmap->s_block_bitmap[bitmap_nr];
    > + bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
    > + if (bitmap_nr < 0)
    > + goto out;
    > + bh = bitmap->s_block_bitmap[bitmap_nr];
    >
    > - bit = block % (sb->s_blocksize << 3);
    > + bit = block % (sb->s_blocksize << 3);
    >
    > - while (bit < (sb->s_blocksize << 3) && block_count > 0) {
    > - if (!udf_test_bit(bit, bh->b_data)) {
    > - goto out;
    > - } else if (DQUOT_PREALLOC_BLOCK(inode, 1)) {
    > - goto out;
    > - } else if (!udf_clear_bit(bit, bh->b_data)) {
    > - udf_debug("bit already cleared for block %d\n", bit);
    > - DQUOT_FREE_BLOCK(inode, 1);
    > - goto out;
    > + while (bit < (sb->s_blocksize << 3) && block_count > 0) {
    > + if (!udf_test_bit(bit, bh->b_data))
    > + goto out;
    > + else if (DQUOT_PREALLOC_BLOCK(inode, 1))
    > + goto out;
    > + else if (!udf_clear_bit(bit, bh->b_data)) {
    > + udf_debug("bit already cleared for block %d\n", bit);
    > + DQUOT_FREE_BLOCK(inode, 1);
    > + goto out;
    > + }
    > + block_count--;
    > + alloc_count++;
    > + bit++;
    > + block++;
    > }
    > - block_count--;
    > - alloc_count++;
    > - bit++;
    > - block++;
    > - }
    > - mark_buffer_dirty(bh);
    > - if (block_count > 0)
    > - goto repeat;
    > + mark_buffer_dirty(bh);
    > + } while (block_count > 0);
    > +
    > out:
    > if (udf_inc_free_space(sbi, partition, -alloc_count))
    > mark_buffer_dirty(sbi->s_lvid_bh);
    > --
    > 1.5.3.7
    >


    Honza
    --
    Jan Kara
    SUSE Labs, CR
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  16. Re: [PATCH 10/16] udf: create common function for changing free space counter

    On Thu 10-01-08 23:06:26, marcin.slusarz@gmail.com wrote:
    > Signed-off-by: Marcin Slusarz
    > CC: Jan Kara
    > CC: Christoph Hellwig

    Just two minor comment...

    > ---
    > fs/udf/balloc.c | 49 ++++++++++++++++++++-----------------------------
    > 1 files changed, 20 insertions(+), 29 deletions(-)
    >
    > diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    > index dc9f8a9..78dbf1d 100644
    > --- a/fs/udf/balloc.c
    > +++ b/fs/udf/balloc.c
    > @@ -140,6 +140,20 @@ static inline int load_block_bitmap(struct super_block *sb,
    > return slot;
    > }
    >
    > +static bool udf_inc_free_space(struct udf_sb_info *sbi,

    Maybe because you use the function for both increasing and decreasing
    free space, you could call is udf_add_free_space?

    > + u16 partition, u32 cnt)
    > +{
    > + struct logicalVolIntegrityDesc *lvid;
    > +
    > + if (sbi->s_lvid_bh)
    > + return false;
    > +
    > + lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    > + lvid->freeSpaceTable[partition] = cpu_to_le32(le32_to_cpu(
    > + lvid->freeSpaceTable[partition]) + cnt);

    I think macro like le32_add_cpu() just went into the kernel so you could
    use that...

    > + return true;
    > +}
    > +
    > static void udf_bitmap_free_blocks(struct super_block *sb,
    > struct inode *inode,
    > struct udf_bitmap *bitmap,
    > @@ -194,11 +208,7 @@ do_more:
    > } else {
    > if (inode)
    > DQUOT_FREE_BLOCK(inode, 1);
    > - if (sbi->s_lvid_bh) {
    > - struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    > - lvid->freeSpaceTable[sbi->s_partition] =
    > - cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[sbi->s_partition]) + 1);
    > - }
    > + udf_inc_free_space(sbi, sbi->s_partition, 1);
    > }
    > }
    > mark_buffer_dirty(bh);
    > @@ -268,12 +278,8 @@ repeat:
    > if (block_count > 0)
    > goto repeat;
    > out:
    > - if (sbi->s_lvid_bh) {
    > - struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    > - lvid->freeSpaceTable[partition] =
    > - cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - alloc_count);
    > + if (udf_inc_free_space(sbi, partition, -alloc_count))
    > mark_buffer_dirty(sbi->s_lvid_bh);
    > - }
    > sb->s_dirt = 1;
    > mutex_unlock(&sbi->s_alloc_mutex);
    > return alloc_count;
    > @@ -404,12 +410,8 @@ got_block:
    >
    > mark_buffer_dirty(bh);
    >
    > - if (sbi->s_lvid_bh) {
    > - struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    > - lvid->freeSpaceTable[partition] =
    > - cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - 1);
    > + if (udf_inc_free_space(sbi, partition, -1))
    > mark_buffer_dirty(sbi->s_lvid_bh);
    > - }
    > sb->s_dirt = 1;
    > mutex_unlock(&sbi->s_alloc_mutex);
    > *err = 0;
    > @@ -450,12 +452,8 @@ static void udf_table_free_blocks(struct super_block *sb,
    > could occure, but.. oh well */
    > if (inode)
    > DQUOT_FREE_BLOCK(inode, count);
    > - if (sbi->s_lvid_bh) {
    > - struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    > - lvid->freeSpaceTable[sbi->s_partition] =
    > - cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[sbi->s_partition]) + count);
    > + if (udf_inc_free_space(sbi, sbi->s_partition, count))
    > mark_buffer_dirty(sbi->s_lvid_bh);
    > - }
    >
    > start = bloc.logicalBlockNum + offset;
    > end = bloc.logicalBlockNum + offset + count - 1;
    > @@ -719,10 +717,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
    >
    > brelse(epos.bh);
    >
    > - if (alloc_count && sbi->s_lvid_bh) {
    > - struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    > - lvid->freeSpaceTable[partition] =
    > - cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - alloc_count);
    > + if (alloc_count && udf_inc_free_space(sbi, partition, -alloc_count)) {
    > mark_buffer_dirty(sbi->s_lvid_bh);
    > sb->s_dirt = 1;
    > }
    > @@ -822,12 +817,8 @@ static int udf_table_new_block(struct super_block *sb,
    > udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
    > brelse(goal_epos.bh);
    >
    > - if (sbi->s_lvid_bh) {
    > - struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    > - lvid->freeSpaceTable[partition] =
    > - cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - 1);
    > + if (udf_inc_free_space(sbi, partition, -1))
    > mark_buffer_dirty(sbi->s_lvid_bh);
    > - }
    >
    > sb->s_dirt = 1;
    > mutex_unlock(&sbi->s_alloc_mutex);


    Honza
    --
    Jan Kara
    SUSE Labs, CR
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  17. Re: [PATCH 15/16] udf: fix udf_debug macro

    On Thu 10-01-08 23:06:31, marcin.slusarz@gmail.com wrote:
    > udf_debug should be enclosed with do { } while (0)
    > to be safely used in code like below:
    > if (something)
    > udf_debug();
    > else
    > anything;
    > (Otherwise compiler will not compile it with:
    > "error: expected expression before 'else'")
    >
    > Signed-off-by: Marcin Slusarz
    > CC: Jan Kara
    > ---
    > include/linux/udf_fs.h | 4 ++--
    > 1 files changed, 2 insertions(+), 2 deletions(-)
    >
    > diff --git a/include/linux/udf_fs.h b/include/linux/udf_fs.h
    > index 36c684e..c954527 100644
    > --- a/include/linux/udf_fs.h
    > +++ b/include/linux/udf_fs.h
    > @@ -39,11 +39,11 @@
    >
    > #ifdef UDFFS_DEBUG
    > #define udf_debug(f, a...) \
    > - { \
    > + do { \
    > printk (KERN_DEBUG "UDF-fs DEBUG %s:%d:%s: ", \
    > __FILE__, __LINE__, __FUNCTION__); \
    > printk (f, ##a); \
    > - }
    > + } while (0)
    > #else
    > #define udf_debug(f, a...) /**/
    > #endif

    Actually, in that case you should also change /**/ to
    do {} while (0)

    Honza
    --
    Jan Kara
    SUSE Labs, CR
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  18. Re: [PATCH 16/16] udf: improve readability of udf_load_partition

    On Thu 10-01-08 23:06:32, marcin.slusarz@gmail.com wrote:
    > Signed-off-by: Marcin Slusarz
    > CC: Jan Kara
    > CC: Christoph Hellwig

    Acked-by: Jan Kara

    > ---
    > fs/udf/super.c | 59 ++++++++++++++++++++++++++++---------------------------
    > 1 files changed, 30 insertions(+), 29 deletions(-)
    >
    > diff --git a/fs/udf/super.c b/fs/udf/super.c
    > index 52d2c32..2048351 100644
    > --- a/fs/udf/super.c
    > +++ b/fs/udf/super.c
    > @@ -1447,44 +1447,45 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    > sbi = UDF_SB(sb);
    >
    > for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
    > - if (sbi->s_anchor[i] &&
    > - (bh = udf_read_tagged(sb, sbi->s_anchor[i],
    > - sbi->s_anchor[i], &ident))) {
    > - anchor = (struct anchorVolDescPtr *)bh->b_data;
    > -
    > - /* Locate the main sequence */
    > - main_s = le32_to_cpu(
    > - anchor->mainVolDescSeqExt.extLocation);
    > - main_e = le32_to_cpu(
    > - anchor->mainVolDescSeqExt.extLength);
    > - main_e = main_e >> sb->s_blocksize_bits;
    > - main_e += main_s;
    > -
    > - /* Locate the reserve sequence */
    > - reserve_s = le32_to_cpu(
    > + if (!sbi->s_anchor[i])
    > + continue;
    > + bh = udf_read_tagged(sb, sbi->s_anchor[i], sbi->s_anchor[i],
    > + &ident);
    > + if (!bh)
    > + continue;
    > +
    > + anchor = (struct anchorVolDescPtr *)bh->b_data;
    > +
    > + /* Locate the main sequence */
    > + main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
    > + main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
    > + main_e = main_e >> sb->s_blocksize_bits;
    > + main_e += main_s;
    > +
    > + /* Locate the reserve sequence */
    > + reserve_s = le32_to_cpu(
    > anchor->reserveVolDescSeqExt.extLocation);
    > - reserve_e = le32_to_cpu(
    > + reserve_e = le32_to_cpu(
    > anchor->reserveVolDescSeqExt.extLength);
    > - reserve_e = reserve_e >> sb->s_blocksize_bits;
    > - reserve_e += reserve_s;
    > + reserve_e = reserve_e >> sb->s_blocksize_bits;
    > + reserve_e += reserve_s;
    >
    > - brelse(bh);
    > + brelse(bh);
    >
    > - /* Process the main & reserve sequences */
    > - /* responsible for finding the PartitionDesc(s) */
    > - if (!(udf_process_sequence(sb, main_s, main_e,
    > - fileset) &&
    > - udf_process_sequence(sb, reserve_s, reserve_e,
    > - fileset)))
    > - break;
    > - }
    > + /* Process the main & reserve sequences */
    > + /* responsible for finding the PartitionDesc(s) */
    > + if (!(udf_process_sequence(sb, main_s, main_e,
    > + fileset) &&
    > + udf_process_sequence(sb, reserve_s, reserve_e,
    > + fileset)))
    > + break;
    > }
    >
    > if (i == ARRAY_SIZE(sbi->s_anchor)) {
    > udf_debug("No Anchor block found\n");
    > return 1;
    > - } else
    > - udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);
    > + }
    > + udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);
    >
    > for (i = 0; i < sbi->s_partitions; i++) {
    > kernel_lb_addr uninitialized_var(ino);
    > --
    > 1.5.3.7
    >


    Honza
    --
    Jan Kara
    SUSE Labs, CR
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  19. Re: [PATCH 00/16] udf: cleanup

    On Thu, Jan 10, 2008 at 11:06:16PM +0100, marcin.slusarz@gmail.com wrote:
    > Hi
    >
    > This patchset contains various UDF fs cleanups.
    > It deprecates two patchsets I sent lately:
    >
    > http://lkml.org/lkml/2008/1/5/196 [PATCH 0/6] udf: improve code related to super_block v3
    > http://lkml.org/lkml/2008/1/5/211 [PATCH 0/7] udf: more cleanups
    >
    > I hope I addressed all comments sent by Christoph Hellwig and Jan Kara.
    > Thanks for review!


    The whole patch series looks fine to me.

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  20. Re: [PATCH 10/16] udf: create common function for changing free space counter

    On Fri, Jan 11, 2008 at 12:24:49AM +0100, Jan Kara wrote:
    > On Thu 10-01-08 23:06:26, marcin.slusarz@gmail.com wrote:
    > > Signed-off-by: Marcin Slusarz
    > > CC: Jan Kara
    > > CC: Christoph Hellwig

    > Just two minor comment...
    >
    > > ---
    > > fs/udf/balloc.c | 49 ++++++++++++++++++++-----------------------------
    > > 1 files changed, 20 insertions(+), 29 deletions(-)
    > >
    > > diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    > > index dc9f8a9..78dbf1d 100644
    > > --- a/fs/udf/balloc.c
    > > +++ b/fs/udf/balloc.c
    > > @@ -140,6 +140,20 @@ static inline int load_block_bitmap(struct super_block *sb,
    > > return slot;
    > > }
    > >
    > > +static bool udf_inc_free_space(struct udf_sb_info *sbi,

    > Maybe because you use the function for both increasing and decreasing
    > free space, you could call is udf_add_free_space?

    Ok. Done.

    >
    > > + u16 partition, u32 cnt)
    > > +{
    > > + struct logicalVolIntegrityDesc *lvid;
    > > +
    > > + if (sbi->s_lvid_bh)
    > > + return false;
    > > +
    > > + lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
    > > + lvid->freeSpaceTable[partition] = cpu_to_le32(le32_to_cpu(
    > > + lvid->freeSpaceTable[partition]) + cnt);

    > I think macro like le32_add_cpu() just went into the kernel so you could
    > use that...

    I didn't want to rely on too many patches, so I intentionally left it.
    I'll convert it together with other le*_add_cpu changes.

    Can you ack this patch with udf_inc_free_space rename?

    Marcin
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

+ Reply to Thread
Page 1 of 2 1 2 LastLast