Commit c0b34438 authored by Marcin Slusarz's avatar Marcin Slusarz Committed by Linus Torvalds

udf: remove UDF_I_* macros and open code them

Signed-off-by: default avatarMarcin Slusarz <marcin.slusarz@gmail.com>
Acked-by: default avatarJan Kara <jack@suse.cz>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 5e0f0017
...@@ -460,7 +460,7 @@ static void udf_table_free_blocks(struct super_block *sb, ...@@ -460,7 +460,7 @@ static void udf_table_free_blocks(struct super_block *sb,
epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry); epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
elen = 0; elen = 0;
epos.block = oepos.block = UDF_I_LOCATION(table); epos.block = oepos.block = UDF_I(table)->i_location;
epos.bh = oepos.bh = NULL; epos.bh = oepos.bh = NULL;
while (count && while (count &&
...@@ -539,9 +539,9 @@ static void udf_table_free_blocks(struct super_block *sb, ...@@ -539,9 +539,9 @@ static void udf_table_free_blocks(struct super_block *sb,
elen = EXT_RECORDED_ALLOCATED | elen = EXT_RECORDED_ALLOCATED |
(count << sb->s_blocksize_bits); (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); 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); adsize = sizeof(long_ad);
} else { } else {
brelse(oepos.bh); brelse(oepos.bh);
...@@ -573,7 +573,8 @@ static void udf_table_free_blocks(struct super_block *sb, ...@@ -573,7 +573,8 @@ static void udf_table_free_blocks(struct super_block *sb,
if (epos.offset + adsize > sb->s_blocksize) { if (epos.offset + adsize > sb->s_blocksize) {
loffset = epos.offset; loffset = epos.offset;
aed->lengthAllocDescs = cpu_to_le32(adsize); 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 + dptr = epos.bh->b_data +
sizeof(struct allocExtDesc); sizeof(struct allocExtDesc);
memcpy(dptr, sptr, adsize); memcpy(dptr, sptr, adsize);
...@@ -591,8 +592,9 @@ static void udf_table_free_blocks(struct super_block *sb, ...@@ -591,8 +592,9 @@ static void udf_table_free_blocks(struct super_block *sb,
aed->lengthAllocDescs) + aed->lengthAllocDescs) +
adsize); adsize);
} else { } else {
sptr = UDF_I_DATA(table) + epos.offset; sptr = UDF_I(table)->i_ext.i_data +
UDF_I_LENALLOC(table) += adsize; epos.offset;
UDF_I(table)->i_lenAlloc += adsize;
mark_inode_dirty(table); mark_inode_dirty(table);
} }
epos.offset = sizeof(struct allocExtDesc); epos.offset = sizeof(struct allocExtDesc);
...@@ -606,7 +608,7 @@ static void udf_table_free_blocks(struct super_block *sb, ...@@ -606,7 +608,7 @@ static void udf_table_free_blocks(struct super_block *sb,
2, 1, epos.block.logicalBlockNum, 2, 1, epos.block.logicalBlockNum,
sizeof(tag)); sizeof(tag));
switch (UDF_I_ALLOCTYPE(table)) { switch (UDF_I(table)->i_alloc_type) {
case ICBTAG_FLAG_AD_SHORT: case ICBTAG_FLAG_AD_SHORT:
sad = (short_ad *)sptr; sad = (short_ad *)sptr;
sad->extLength = cpu_to_le32( sad->extLength = cpu_to_le32(
...@@ -637,7 +639,7 @@ static void udf_table_free_blocks(struct super_block *sb, ...@@ -637,7 +639,7 @@ static void udf_table_free_blocks(struct super_block *sb,
udf_write_aext(table, &epos, eloc, elen, 1); udf_write_aext(table, &epos, eloc, elen, 1);
if (!epos.bh) { if (!epos.bh) {
UDF_I_LENALLOC(table) += adsize; UDF_I(table)->i_lenAlloc += adsize;
mark_inode_dirty(table); mark_inode_dirty(table);
} else { } else {
aed = (struct allocExtDesc *)epos.bh->b_data; aed = (struct allocExtDesc *)epos.bh->b_data;
...@@ -675,16 +677,16 @@ static int udf_table_prealloc_blocks(struct super_block *sb, ...@@ -675,16 +677,16 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
first_block >= sbi->s_partmaps[partition].s_partition_len) first_block >= sbi->s_partmaps[partition].s_partition_len)
return 0; 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); 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); adsize = sizeof(long_ad);
else else
return 0; return 0;
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
epos.offset = sizeof(struct unallocSpaceEntry); epos.offset = sizeof(struct unallocSpaceEntry);
epos.block = UDF_I_LOCATION(table); epos.block = UDF_I(table)->i_location;
epos.bh = NULL; epos.bh = NULL;
eloc.logicalBlockNum = 0xFFFFFFFF; eloc.logicalBlockNum = 0xFFFFFFFF;
...@@ -740,9 +742,9 @@ static int udf_table_new_block(struct super_block *sb, ...@@ -740,9 +742,9 @@ static int udf_table_new_block(struct super_block *sb,
*err = -ENOSPC; *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); 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); adsize = sizeof(long_ad);
else else
return newblock; return newblock;
...@@ -757,7 +759,7 @@ static int udf_table_new_block(struct super_block *sb, ...@@ -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. of the current closest match and use that when we are done.
*/ */
epos.offset = sizeof(struct unallocSpaceEntry); epos.offset = sizeof(struct unallocSpaceEntry);
epos.block = UDF_I_LOCATION(table); epos.block = UDF_I(table)->i_location;
epos.bh = goal_epos.bh = NULL; epos.bh = goal_epos.bh = NULL;
while (spread && while (spread &&
......
...@@ -125,15 +125,16 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir, ...@@ -125,15 +125,16 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
nf_pos = (udf_ext0_offset(dir) >> 2); nf_pos = (udf_ext0_offset(dir) >> 2);
fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; fibh.soffset = fibh.eoffset = (nf_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; fibh.sbh = fibh.ebh = NULL;
} else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2), } else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) { &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset); block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { 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); 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); epos.offset -= sizeof(long_ad);
} else { } else {
offset = 0; offset = 0;
......
...@@ -84,9 +84,9 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos, ...@@ -84,9 +84,9 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,
fibh->soffset = fibh->eoffset; fibh->soffset = fibh->eoffset;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) { if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
fi = udf_get_fileident(UDF_I_DATA(dir) - fi = udf_get_fileident(UDF_I(dir)->i_ext.i_data -
(UDF_I_EFE(dir) ? (UDF_I(dir)->i_efe ?
sizeof(struct extendedFileEntry) : sizeof(struct extendedFileEntry) :
sizeof(struct fileEntry)), sizeof(struct fileEntry)),
dir->i_sb->s_blocksize, dir->i_sb->s_blocksize,
......
...@@ -50,7 +50,8 @@ static int udf_adinicb_readpage(struct file *file, struct page *page) ...@@ -50,7 +50,8 @@ static int udf_adinicb_readpage(struct file *file, struct page *page)
kaddr = kmap(page); kaddr = kmap(page);
memset(kaddr, 0, PAGE_CACHE_SIZE); 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); flush_dcache_page(page);
SetPageUptodate(page); SetPageUptodate(page);
kunmap(page); kunmap(page);
...@@ -68,7 +69,8 @@ static int udf_adinicb_writepage(struct page *page, ...@@ -68,7 +69,8 @@ static int udf_adinicb_writepage(struct page *page,
BUG_ON(!PageLocked(page)); BUG_ON(!PageLocked(page));
kaddr = kmap(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); mark_inode_dirty(inode);
SetPageUptodate(page); SetPageUptodate(page);
kunmap(page); kunmap(page);
...@@ -87,7 +89,7 @@ static int udf_adinicb_write_end(struct file *file, ...@@ -87,7 +89,7 @@ static int udf_adinicb_write_end(struct file *file,
char *kaddr; char *kaddr;
kaddr = kmap_atomic(page, KM_USER0); 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); kaddr + offset, copied);
kunmap_atomic(kaddr, KM_USER0); kunmap_atomic(kaddr, KM_USER0);
...@@ -111,7 +113,7 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov, ...@@ -111,7 +113,7 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
int err, pos; int err, pos;
size_t count = iocb->ki_left; 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) if (file->f_flags & O_APPEND)
pos = inode->i_size; pos = inode->i_size;
else else
...@@ -121,15 +123,16 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov, ...@@ -121,15 +123,16 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
(udf_file_entry_alloc_offset(inode) + (udf_file_entry_alloc_offset(inode) +
pos + count)) { pos + count)) {
udf_expand_file_adinicb(inode, pos + count, &err); 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); udf_debug("udf_expand_adinicb: err=%d\n", err);
return err; return err;
} }
} else { } else {
if (pos + count > inode->i_size) if (pos + count > inode->i_size)
UDF_I_LENALLOC(inode) = pos + count; UDF_I(inode)->i_lenAlloc = pos + count;
else 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, ...@@ -209,11 +212,12 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
result = put_user(new_block, (long __user *)arg); result = put_user(new_block, (long __user *)arg);
return result; return result;
case UDF_GETEASIZE: 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; break;
case UDF_GETEABLOCK: case UDF_GETEABLOCK:
result = copy_to_user((char __user *)arg, UDF_I_DATA(inode), result = copy_to_user((char __user *)arg,
UDF_I_LENEATTR(inode)) ? -EFAULT : 0; UDF_I(inode)->i_ext.i_data,
UDF_I(inode)->i_lenEAttr) ? -EFAULT : 0;
break; break;
} }
......
...@@ -57,7 +57,7 @@ void udf_free_inode(struct inode *inode) ...@@ -57,7 +57,7 @@ void udf_free_inode(struct inode *inode)
} }
mutex_unlock(&sbi->s_alloc_mutex); 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) 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) ...@@ -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 udf_sb_info *sbi = UDF_SB(sb);
struct inode *inode; struct inode *inode;
int block; int block;
uint32_t start = UDF_I_LOCATION(dir).logicalBlockNum; uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;
inode = new_inode(sb); inode = new_inode(sb);
...@@ -76,14 +76,14 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) ...@@ -76,14 +76,14 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
} }
*err = -ENOSPC; *err = -ENOSPC;
UDF_I_UNIQUE(inode) = 0; UDF_I(inode)->i_unique = 0;
UDF_I_LENEXTENTS(inode) = 0; UDF_I(inode)->i_lenExtents = 0;
UDF_I_NEXT_ALLOC_BLOCK(inode) = 0; UDF_I(inode)->i_next_alloc_block = 0;
UDF_I_NEXT_ALLOC_GOAL(inode) = 0; UDF_I(inode)->i_next_alloc_goal = 0;
UDF_I_STRAT4096(inode) = 0; UDF_I(inode)->i_strat4096 = 0;
block = udf_new_block(dir->i_sb, NULL, block = udf_new_block(dir->i_sb, NULL,
UDF_I_LOCATION(dir).partitionReferenceNum, UDF_I(dir)->i_location.partitionReferenceNum,
start, err); start, err);
if (*err) { if (*err) {
iput(inode); iput(inode);
...@@ -107,7 +107,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) ...@@ -107,7 +107,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
else else
lvidiu->numFiles = lvidiu->numFiles =
cpu_to_le32(le32_to_cpu(lvidiu->numFiles) + 1); 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)) if (!(++uniqueID & 0x00000000FFFFFFFFUL))
uniqueID += 16; uniqueID += 16;
lvhd->uniqueID = cpu_to_le64(uniqueID); lvhd->uniqueID = cpu_to_le64(uniqueID);
...@@ -123,41 +123,41 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) ...@@ -123,41 +123,41 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
inode->i_gid = current->fsgid; inode->i_gid = current->fsgid;
} }
UDF_I_LOCATION(inode).logicalBlockNum = block; UDF_I(inode)->i_location.logicalBlockNum = block;
UDF_I_LOCATION(inode).partitionReferenceNum = UDF_I(inode)->i_location.partitionReferenceNum =
UDF_I_LOCATION(dir).partitionReferenceNum; UDF_I(dir)->i_location.partitionReferenceNum;
inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0); inode->i_ino = udf_get_lb_pblock(sb, UDF_I(inode)->i_location, 0);
inode->i_blocks = 0; inode->i_blocks = 0;
UDF_I_LENEATTR(inode) = 0; UDF_I(inode)->i_lenEAttr = 0;
UDF_I_LENALLOC(inode) = 0; UDF_I(inode)->i_lenAlloc = 0;
UDF_I_USE(inode) = 0; UDF_I(inode)->i_use = 0;
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) { 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) if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)
sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE; 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), sizeof(struct extendedFileEntry),
GFP_KERNEL); GFP_KERNEL);
} else { } else {
UDF_I_EFE(inode) = 0; UDF_I(inode)->i_efe = 0;
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 fileEntry), sizeof(struct fileEntry),
GFP_KERNEL); GFP_KERNEL);
} }
if (!UDF_I_DATA(inode)) { if (!UDF_I(inode)->i_ext.i_data) {
iput(inode); iput(inode);
*err = -ENOMEM; *err = -ENOMEM;
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
return NULL; return NULL;
} }
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB)) 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)) 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 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 = 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); insert_inode_hash(inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
......
...@@ -120,8 +120,8 @@ void udf_clear_inode(struct inode *inode) ...@@ -120,8 +120,8 @@ void udf_clear_inode(struct inode *inode)
unlock_kernel(); unlock_kernel();
write_inode_now(inode, 1); write_inode_now(inode, 1);
} }
kfree(UDF_I_DATA(inode)); kfree(UDF_I(inode)->i_ext.i_data);
UDF_I_DATA(inode) = NULL; UDF_I(inode)->i_ext.i_data = NULL;
} }
static int udf_writepage(struct page *page, struct writeback_control *wbc) 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) ...@@ -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 */ /* from now on we have normal address_space methods */
inode->i_data.a_ops = &udf_aops; 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)) 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 else
UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG; UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG;
mark_inode_dirty(inode); mark_inode_dirty(inode);
return; return;
} }
...@@ -183,21 +183,21 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err) ...@@ -183,21 +183,21 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
if (!PageUptodate(page)) { if (!PageUptodate(page)) {
kaddr = kmap(page); kaddr = kmap(page);
memset(kaddr + UDF_I_LENALLOC(inode), 0x00, memset(kaddr + UDF_I(inode)->i_lenAlloc, 0x00,
PAGE_CACHE_SIZE - UDF_I_LENALLOC(inode)); PAGE_CACHE_SIZE - UDF_I(inode)->i_lenAlloc);
memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), memcpy(kaddr, UDF_I(inode)->i_ext.i_data +
UDF_I_LENALLOC(inode)); UDF_I(inode)->i_lenEAttr, UDF_I(inode)->i_lenAlloc);
flush_dcache_page(page); flush_dcache_page(page);
SetPageUptodate(page); SetPageUptodate(page);
kunmap(page); kunmap(page);
} }
memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0x00, memset(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, 0x00,
UDF_I_LENALLOC(inode)); UDF_I(inode)->i_lenAlloc);
UDF_I_LENALLOC(inode) = 0; UDF_I(inode)->i_lenAlloc = 0;
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) 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 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); inode->i_data.a_ops->writepage(page, &udf_wbc);
page_cache_release(page); page_cache_release(page);
...@@ -226,20 +226,20 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block, ...@@ -226,20 +226,20 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
alloctype = ICBTAG_FLAG_AD_LONG; alloctype = ICBTAG_FLAG_AD_LONG;
if (!inode->i_size) { if (!inode->i_size) {
UDF_I_ALLOCTYPE(inode) = alloctype; UDF_I(inode)->i_alloc_type = alloctype;
mark_inode_dirty(inode); mark_inode_dirty(inode);
return NULL; return NULL;
} }
/* alloc block, and copy data to it */ /* alloc block, and copy data to it */
*block = udf_new_block(inode->i_sb, inode, *block = udf_new_block(inode->i_sb, inode,
UDF_I_LOCATION(inode).partitionReferenceNum, UDF_I(inode)->i_location.partitionReferenceNum,
UDF_I_LOCATION(inode).logicalBlockNum, err); UDF_I(inode)->i_location.logicalBlockNum, err);
if (!(*block)) if (!(*block))
return NULL; return NULL;
newblock = udf_get_pblock(inode->i_sb, *block, newblock = udf_get_pblock(inode->i_sb, *block,
UDF_I_LOCATION(inode).partitionReferenceNum, UDF_I(inode)->i_location.partitionReferenceNum,
0); 0);
if (!newblock) if (!newblock)
return NULL; return NULL;
dbh = udf_tgetblk(inode->i_sb, newblock); dbh = udf_tgetblk(inode->i_sb, newblock);
...@@ -257,14 +257,14 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block, ...@@ -257,14 +257,14 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
dfibh.soffset = dfibh.eoffset = 0; dfibh.soffset = dfibh.eoffset = 0;
dfibh.sbh = dfibh.ebh = dbh; dfibh.sbh = dfibh.ebh = dbh;
while ((f_pos < size)) { 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, sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
if (!sfi) { if (!sfi) {
brelse(dbh); brelse(dbh);
return NULL; return NULL;
} }
UDF_I_ALLOCTYPE(inode) = alloctype; UDF_I(inode)->i_alloc_type = alloctype;
sfi->descTag.tagLocation = cpu_to_le32(*block); sfi->descTag.tagLocation = cpu_to_le32(*block);
dfibh.soffset = dfibh.eoffset; dfibh.soffset = dfibh.eoffset;
dfibh.eoffset += (sfibh.eoffset - sfibh.soffset); dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
...@@ -272,23 +272,23 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block, ...@@ -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, if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
sfi->fileIdent + sfi->fileIdent +
le16_to_cpu(sfi->lengthOfImpUse))) { 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); brelse(dbh);
return NULL; return NULL;
} }
} }
mark_buffer_dirty_inode(dbh, inode); mark_buffer_dirty_inode(dbh, inode);
memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0, memset(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, 0,
UDF_I_LENALLOC(inode)); UDF_I(inode)->i_lenAlloc);
UDF_I_LENALLOC(inode) = 0; UDF_I(inode)->i_lenAlloc = 0;
eloc.logicalBlockNum = *block; eloc.logicalBlockNum = *block;
eloc.partitionReferenceNum = eloc.partitionReferenceNum =
UDF_I_LOCATION(inode).partitionReferenceNum; UDF_I(inode)->i_location.partitionReferenceNum;
elen = inode->i_size; elen = inode->i_size;
UDF_I_LENEXTENTS(inode) = elen; UDF_I(inode)->i_lenExtents = elen;
epos.bh = NULL; epos.bh = NULL;
epos.block = UDF_I_LOCATION(inode); epos.block = UDF_I(inode)->i_location;
epos.offset = udf_file_entry_alloc_offset(inode); epos.offset = udf_file_entry_alloc_offset(inode);
udf_add_aext(inode, &epos, eloc, elen, 0); udf_add_aext(inode, &epos, eloc, elen, 0);
/* UniqueID stuff */ /* UniqueID stuff */
...@@ -321,9 +321,9 @@ static int udf_get_block(struct inode *inode, sector_t block, ...@@ -321,9 +321,9 @@ static int udf_get_block(struct inode *inode, sector_t block,
if (block < 0) if (block < 0)
goto abort_negative; goto abort_negative;
if (block == UDF_I_NEXT_ALLOC_BLOCK(inode) + 1) { if (block == UDF_I(inode)->i_next_alloc_block + 1) {
UDF_I_NEXT_ALLOC_BLOCK(inode)++; UDF_I(inode)->i_next_alloc_block++;
UDF_I_NEXT_ALLOC_GOAL(inode)++; UDF_I(inode)->i_next_alloc_goal++;
} }
err = 0; err = 0;
...@@ -392,8 +392,8 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, ...@@ -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_FLAG_MASK) |
(((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) + (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
sb->s_blocksize - 1) & ~(sb->s_blocksize - 1)); sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
UDF_I_LENEXTENTS(inode) = UDF_I(inode)->i_lenExtents =
(UDF_I_LENEXTENTS(inode) + sb->s_blocksize - 1) & (UDF_I(inode)->i_lenExtents + sb->s_blocksize - 1) &
~(sb->s_blocksize - 1); ~(sb->s_blocksize - 1);
} }
...@@ -470,9 +470,9 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, ...@@ -470,9 +470,9 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
} }
/* last_pos should point to the last written extent... */ /* 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); 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); last_pos->offset -= sizeof(long_ad);
else else
return -1; return -1;
...@@ -495,11 +495,11 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block, ...@@ -495,11 +495,11 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
uint32_t newblocknum, newblock; uint32_t newblocknum, newblock;
sector_t offset = 0; sector_t offset = 0;
int8_t etype; 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; int lastblock = 0;
prev_epos.offset = udf_file_entry_alloc_offset(inode); 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; prev_epos.bh = NULL;
cur_epos = next_epos = prev_epos; cur_epos = next_epos = prev_epos;
b_off = (loff_t)block << inode->i_sb->s_blocksize_bits; 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, ...@@ -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)) if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
newblocknum = laarr[c].extLocation.logicalBlockNum + offset; newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
else { /* otherwise, allocate a new block */ else { /* otherwise, allocate a new block */
if (UDF_I_NEXT_ALLOC_BLOCK(inode) == block) if (UDF_I(inode)->i_next_alloc_block == block)
goal = UDF_I_NEXT_ALLOC_GOAL(inode); goal = UDF_I(inode)->i_next_alloc_goal;
if (!goal) { if (!goal) {
if (!(goal = pgoal)) /* XXX: what was intended here? */ 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, newblocknum = udf_new_block(inode->i_sb, inode,
UDF_I_LOCATION(inode).partitionReferenceNum, UDF_I(inode)->i_location.partitionReferenceNum,
goal, err); goal, err);
if (!newblocknum) { if (!newblocknum) {
brelse(prev_epos.bh); brelse(prev_epos.bh);
*err = -ENOSPC; *err = -ENOSPC;
return NULL; 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 /* 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, ...@@ -690,14 +691,14 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
brelse(prev_epos.bh); brelse(prev_epos.bh);
newblock = udf_get_pblock(inode->i_sb, newblocknum, newblock = udf_get_pblock(inode->i_sb, newblocknum,
UDF_I_LOCATION(inode).partitionReferenceNum, 0); UDF_I(inode)->i_location.partitionReferenceNum, 0);
if (!newblock) if (!newblock)
return NULL; return NULL;
*phys = newblock; *phys = newblock;
*err = 0; *err = 0;
*new = 1; *new = 1;
UDF_I_NEXT_ALLOC_BLOCK(inode) = block; UDF_I(inode)->i_next_alloc_block = block;
UDF_I_NEXT_ALLOC_GOAL(inode) = newblocknum; UDF_I(inode)->i_next_alloc_goal = newblocknum;
inode->i_ctime = current_fs_time(inode->i_sb); inode->i_ctime = current_fs_time(inode->i_sb);
if (IS_SYNC(inode)) if (IS_SYNC(inode))
...@@ -756,7 +757,7 @@ static void udf_split_extents(struct inode *inode, int *c, int offset, ...@@ -756,7 +757,7 @@ static void udf_split_extents(struct inode *inode, int *c, int offset,
laarr[curr].extLocation.logicalBlockNum = newblocknum; laarr[curr].extLocation.logicalBlockNum = newblocknum;
if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
laarr[curr].extLocation.partitionReferenceNum = laarr[curr].extLocation.partitionReferenceNum =
UDF_I_LOCATION(inode).partitionReferenceNum; UDF_I(inode)->i_location.partitionReferenceNum;
laarr[curr].extLength = EXT_RECORDED_ALLOCATED | laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
blocksize; blocksize;
curr++; curr++;
...@@ -863,7 +864,7 @@ static void udf_prealloc_extents(struct inode *inode, int c, int lastblock, ...@@ -863,7 +864,7 @@ static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
(*endnum)--; (*endnum)--;
} }
} }
UDF_I_LENEXTENTS(inode) += UDF_I(inode)->i_lenExtents +=
numalloc << inode->i_sb->s_blocksize_bits; numalloc << inode->i_sb->s_blocksize_bits;
} }
} }
...@@ -1034,23 +1035,25 @@ void udf_truncate(struct inode *inode) ...@@ -1034,23 +1035,25 @@ void udf_truncate(struct inode *inode)
return; return;
lock_kernel(); 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 < if (inode->i_sb->s_blocksize <
(udf_file_entry_alloc_offset(inode) + (udf_file_entry_alloc_offset(inode) +
inode->i_size)) { inode->i_size)) {
udf_expand_file_adinicb(inode, inode->i_size, &err); udf_expand_file_adinicb(inode, inode->i_size, &err);
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) { if (UDF_I(inode)->i_alloc_type ==
inode->i_size = UDF_I_LENALLOC(inode); ICBTAG_FLAG_AD_IN_ICB) {
inode->i_size = UDF_I(inode)->i_lenAlloc;
unlock_kernel(); unlock_kernel();
return; return;
} else } else
udf_truncate_extents(inode); udf_truncate_extents(inode);
} else { } else {
offset = inode->i_size & (inode->i_sb->s_blocksize - 1); offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + memset(UDF_I(inode)->i_ext.i_data +
offset, 0x00, inode->i_sb->s_blocksize - UDF_I(inode)->i_lenEAttr + offset,
0x00, inode->i_sb->s_blocksize -
offset - udf_file_entry_alloc_offset(inode)); offset - udf_file_entry_alloc_offset(inode));
UDF_I_LENALLOC(inode) = inode->i_size; UDF_I(inode)->i_lenAlloc = inode->i_size;
} }
} else { } else {
block_truncate_page(inode->i_mapping, inode->i_size, block_truncate_page(inode->i_mapping, inode->i_size,
...@@ -1084,7 +1087,7 @@ static void __udf_read_inode(struct inode *inode) ...@@ -1084,7 +1087,7 @@ static void __udf_read_inode(struct inode *inode)
* i_nlink = 1 * i_nlink = 1
* i_op = NULL; * 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) { if (!bh) {
printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n", printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
inode->i_ino); inode->i_ino);
...@@ -1107,7 +1110,7 @@ static void __udf_read_inode(struct inode *inode) ...@@ -1107,7 +1110,7 @@ static void __udf_read_inode(struct inode *inode)
struct buffer_head *ibh = NULL, *nbh = NULL; struct buffer_head *ibh = NULL, *nbh = NULL;
struct indirectEntry *ie; 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); &ident);
if (ident == TAG_IDENT_IE) { if (ident == TAG_IDENT_IE) {
if (ibh) { if (ibh) {
...@@ -1121,7 +1124,7 @@ static void __udf_read_inode(struct inode *inode) ...@@ -1121,7 +1124,7 @@ static void __udf_read_inode(struct inode *inode)
&ident))) { &ident))) {
if (ident == TAG_IDENT_FE || if (ident == TAG_IDENT_FE ||
ident == TAG_IDENT_EFE) { ident == TAG_IDENT_EFE) {
memcpy(&UDF_I_LOCATION(inode), memcpy(&UDF_I(inode)->i_location,
&loc, &loc,
sizeof(kernel_lb_addr)); sizeof(kernel_lb_addr));
brelse(bh); brelse(bh);
...@@ -1165,44 +1168,45 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1165,44 +1168,45 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
efe = (struct extendedFileEntry *)bh->b_data; efe = (struct extendedFileEntry *)bh->b_data;
if (fe->icbTag.strategyType == cpu_to_le16(4)) 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)) */ 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; ICBTAG_FLAG_AD_MASK;
UDF_I_UNIQUE(inode) = 0; UDF_I(inode)->i_unique = 0;
UDF_I_LENEATTR(inode) = 0; UDF_I(inode)->i_lenEAttr = 0;
UDF_I_LENEXTENTS(inode) = 0; UDF_I(inode)->i_lenExtents = 0;
UDF_I_LENALLOC(inode) = 0; UDF_I(inode)->i_lenAlloc = 0;
UDF_I_NEXT_ALLOC_BLOCK(inode) = 0; UDF_I(inode)->i_next_alloc_block = 0;
UDF_I_NEXT_ALLOC_GOAL(inode) = 0; UDF_I(inode)->i_next_alloc_goal = 0;
if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) { if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
UDF_I_EFE(inode) = 1; UDF_I(inode)->i_efe = 1;
UDF_I_USE(inode) = 0; UDF_I(inode)->i_use = 0;
if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
sizeof(struct extendedFileEntry))) { sizeof(struct extendedFileEntry))) {
make_bad_inode(inode); make_bad_inode(inode);
return; return;
} }
memcpy(UDF_I_DATA(inode), memcpy(UDF_I(inode)->i_ext.i_data,
bh->b_data + sizeof(struct extendedFileEntry), bh->b_data + sizeof(struct extendedFileEntry),
inode->i_sb->s_blocksize - inode->i_sb->s_blocksize -
sizeof(struct extendedFileEntry)); sizeof(struct extendedFileEntry));
} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) { } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
UDF_I_EFE(inode) = 0; UDF_I(inode)->i_efe = 0;
UDF_I_USE(inode) = 0; UDF_I(inode)->i_use = 0;
if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
sizeof(struct fileEntry))) { sizeof(struct fileEntry))) {
make_bad_inode(inode); make_bad_inode(inode);
return; 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)); inode->i_sb->s_blocksize - sizeof(struct fileEntry));
} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) { } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
UDF_I_EFE(inode) = 0; UDF_I(inode)->i_efe = 0;
UDF_I_USE(inode) = 1; UDF_I(inode)->i_use = 1;
UDF_I_LENALLOC(inode) = le32_to_cpu( UDF_I(inode)->i_lenAlloc = le32_to_cpu(
((struct unallocSpaceEntry *)bh->b_data)-> ((struct unallocSpaceEntry *)bh->b_data)->
lengthAllocDescs); lengthAllocDescs);
if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - 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) ...@@ -1210,7 +1214,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
make_bad_inode(inode); make_bad_inode(inode);
return; return;
} }
memcpy(UDF_I_DATA(inode), memcpy(UDF_I(inode)->i_ext.i_data,
bh->b_data + sizeof(struct unallocSpaceEntry), bh->b_data + sizeof(struct unallocSpaceEntry),
inode->i_sb->s_blocksize - inode->i_sb->s_blocksize -
sizeof(struct unallocSpaceEntry)); sizeof(struct unallocSpaceEntry));
...@@ -1234,12 +1238,12 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1234,12 +1238,12 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
inode->i_nlink = 1; inode->i_nlink = 1;
inode->i_size = le64_to_cpu(fe->informationLength); 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_convert_permissions(fe);
inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask; 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_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
(inode->i_sb->s_blocksize_bits - 9); (inode->i_sb->s_blocksize_bits - 9);
...@@ -1267,10 +1271,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1267,10 +1271,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
inode->i_ctime = sbi->s_record_time; inode->i_ctime = sbi->s_record_time;
} }
UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID); UDF_I(inode)->i_unique = le64_to_cpu(fe->uniqueID);
UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr); UDF_I(inode)->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs); UDF_I(inode)->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode); offset = sizeof(struct fileEntry) + UDF_I(inode)->i_lenEAttr;
} else { } else {
inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) << inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
(inode->i_sb->s_blocksize_bits - 9); (inode->i_sb->s_blocksize_bits - 9);
...@@ -1293,10 +1297,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1293,10 +1297,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
if (udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
lets_to_cpu(efe->createTime))) { lets_to_cpu(efe->createTime))) {
UDF_I_CRTIME(inode).tv_sec = convtime; UDF_I(inode)->i_crtime.tv_sec = convtime;
UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000; UDF_I(inode)->i_crtime.tv_nsec = convtime_usec * 1000;
} else { } 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, if (udf_stamp_to_time(&convtime, &convtime_usec,
...@@ -1307,11 +1311,11 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1307,11 +1311,11 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
inode->i_ctime = sbi->s_record_time; inode->i_ctime = sbi->s_record_time;
} }
UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID); UDF_I(inode)->i_unique = le64_to_cpu(efe->uniqueID);
UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr); UDF_I(inode)->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs); UDF_I(inode)->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
offset = sizeof(struct extendedFileEntry) + offset = sizeof(struct extendedFileEntry) +
UDF_I_LENEATTR(inode); UDF_I(inode)->i_lenEAttr;
} }
switch (fe->icbTag.fileType) { switch (fe->icbTag.fileType) {
...@@ -1324,7 +1328,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -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_REALTIME:
case ICBTAG_FILE_TYPE_REGULAR: case ICBTAG_FILE_TYPE_REGULAR:
case ICBTAG_FILE_TYPE_UNDEF: 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; inode->i_data.a_ops = &udf_adinicb_aops;
else else
inode->i_data.a_ops = &udf_aops; inode->i_data.a_ops = &udf_aops;
...@@ -1371,9 +1375,9 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -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) 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) " printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) "
"no free memory\n", inode->i_ino); "no free memory\n", inode->i_ino);
return -ENOMEM; return -ENOMEM;
...@@ -1447,7 +1451,7 @@ static int udf_update_inode(struct inode *inode, int do_sync) ...@@ -1447,7 +1451,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
bh = udf_tread(inode->i_sb, bh = udf_tread(inode->i_sb,
udf_get_lb_pblock(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
UDF_I_LOCATION(inode), 0)); UDF_I(inode)->i_location, 0));
if (!bh) { if (!bh) {
udf_debug("bread failure\n"); udf_debug("bread failure\n");
return -EIO; return -EIO;
...@@ -1462,14 +1466,14 @@ static int udf_update_inode(struct inode *inode, int do_sync) ...@@ -1462,14 +1466,14 @@ static int udf_update_inode(struct inode *inode, int do_sync)
struct unallocSpaceEntry *use = struct unallocSpaceEntry *use =
(struct unallocSpaceEntry *)bh->b_data; (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), 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)); sizeof(struct unallocSpaceEntry));
crclen = 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( use->descTag.tagLocation = cpu_to_le32(
UDF_I_LOCATION(inode). UDF_I(inode)->i_location.
logicalBlockNum); logicalBlockNum);
use->descTag.descCRCLength = cpu_to_le16(crclen); use->descTag.descCRCLength = cpu_to_le16(crclen);
use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + 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) ...@@ -1534,8 +1538,9 @@ static int udf_update_inode(struct inode *inode, int do_sync)
dsea->minorDeviceIdent = cpu_to_le32(iminor(inode)); dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
} }
if (UDF_I_EFE(inode) == 0) { if (UDF_I(inode)->i_efe == 0) {
memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode), memcpy(bh->b_data + sizeof(struct fileEntry),
UDF_I(inode)->i_ext.i_data,
inode->i_sb->s_blocksize - sizeof(struct fileEntry)); inode->i_sb->s_blocksize - sizeof(struct fileEntry));
fe->logicalBlocksRecorded = cpu_to_le64( fe->logicalBlocksRecorded = cpu_to_le64(
(inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >> (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
...@@ -1551,14 +1556,14 @@ static int udf_update_inode(struct inode *inode, int do_sync) ...@@ -1551,14 +1556,14 @@ static int udf_update_inode(struct inode *inode, int do_sync)
strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER); strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
fe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode)); fe->uniqueID = cpu_to_le64(UDF_I(inode)->i_unique);
fe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode)); fe->lengthExtendedAttr = cpu_to_le32(UDF_I(inode)->i_lenEAttr);
fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode)); fe->lengthAllocDescs = cpu_to_le32(UDF_I(inode)->i_lenAlloc);
fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE); fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
crclen = sizeof(struct fileEntry); crclen = sizeof(struct fileEntry);
} else { } else {
memcpy(bh->b_data + sizeof(struct extendedFileEntry), memcpy(bh->b_data + sizeof(struct extendedFileEntry),
UDF_I_DATA(inode), UDF_I(inode)->i_ext.i_data,
inode->i_sb->s_blocksize - inode->i_sb->s_blocksize -
sizeof(struct extendedFileEntry)); sizeof(struct extendedFileEntry));
efe->objectSize = cpu_to_le64(inode->i_size); efe->objectSize = cpu_to_le64(inode->i_size);
...@@ -1566,26 +1571,26 @@ static int udf_update_inode(struct inode *inode, int do_sync) ...@@ -1566,26 +1571,26 @@ static int udf_update_inode(struct inode *inode, int do_sync)
(inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >> (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
(blocksize_bits - 9)); (blocksize_bits - 9));
if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec || if (UDF_I(inode)->i_crtime.tv_sec > inode->i_atime.tv_sec ||
(UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec && (UDF_I(inode)->i_crtime.tv_sec == inode->i_atime.tv_sec &&
UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec)) UDF_I(inode)->i_crtime.tv_nsec > inode->i_atime.tv_nsec))
UDF_I_CRTIME(inode) = inode->i_atime; UDF_I(inode)->i_crtime = inode->i_atime;
if (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec || if (UDF_I(inode)->i_crtime.tv_sec > inode->i_mtime.tv_sec ||
(UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec && (UDF_I(inode)->i_crtime.tv_sec == inode->i_mtime.tv_sec &&
UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec)) UDF_I(inode)->i_crtime.tv_nsec > inode->i_mtime.tv_nsec))
UDF_I_CRTIME(inode) = inode->i_mtime; UDF_I(inode)->i_crtime = inode->i_mtime;
if (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec || if (UDF_I(inode)->i_crtime.tv_sec > inode->i_ctime.tv_sec ||
(UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec && (UDF_I(inode)->i_crtime.tv_sec == inode->i_ctime.tv_sec &&
UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec)) UDF_I(inode)->i_crtime.tv_nsec > inode->i_ctime.tv_nsec))
UDF_I_CRTIME(inode) = inode->i_ctime; UDF_I(inode)->i_crtime = inode->i_ctime;
if (udf_time_to_stamp(&cpu_time, inode->i_atime)) if (udf_time_to_stamp(&cpu_time, inode->i_atime))
efe->accessTime = cpu_to_lets(cpu_time); efe->accessTime = cpu_to_lets(cpu_time);
if (udf_time_to_stamp(&cpu_time, inode->i_mtime)) if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
efe->modificationTime = cpu_to_lets(cpu_time); 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); efe->createTime = cpu_to_lets(cpu_time);
if (udf_time_to_stamp(&cpu_time, inode->i_ctime)) if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
efe->attrTime = cpu_to_lets(cpu_time); efe->attrTime = cpu_to_lets(cpu_time);
...@@ -1594,13 +1599,13 @@ static int udf_update_inode(struct inode *inode, int do_sync) ...@@ -1594,13 +1599,13 @@ static int udf_update_inode(struct inode *inode, int do_sync)
strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER); strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
efe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode)); efe->uniqueID = cpu_to_le64(UDF_I(inode)->i_unique);
efe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode)); efe->lengthExtendedAttr = cpu_to_le32(UDF_I(inode)->i_lenEAttr);
efe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode)); efe->lengthAllocDescs = cpu_to_le32(UDF_I(inode)->i_lenAlloc);
efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE); efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
crclen = sizeof(struct extendedFileEntry); crclen = sizeof(struct extendedFileEntry);
} }
if (UDF_I_STRAT4096(inode)) { if (UDF_I(inode)->i_strat4096) {
fe->icbTag.strategyType = cpu_to_le16(4096); fe->icbTag.strategyType = cpu_to_le16(4096);
fe->icbTag.strategyParameter = cpu_to_le16(1); fe->icbTag.strategyParameter = cpu_to_le16(1);
fe->icbTag.numEntries = cpu_to_le16(2); fe->icbTag.numEntries = cpu_to_le16(2);
...@@ -1624,7 +1629,7 @@ static int udf_update_inode(struct inode *inode, int do_sync) ...@@ -1624,7 +1629,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
else if (S_ISSOCK(inode->i_mode)) else if (S_ISSOCK(inode->i_mode))
fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET; 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_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) | ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 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) ...@@ -1639,8 +1644,9 @@ static int udf_update_inode(struct inode *inode, int do_sync)
fe->descTag.descVersion = cpu_to_le16(2); fe->descTag.descVersion = cpu_to_le16(2);
fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number); fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
fe->descTag.tagLocation = cpu_to_le32( fe->descTag.tagLocation = cpu_to_le32(
UDF_I_LOCATION(inode).logicalBlockNum); UDF_I(inode)->i_location.logicalBlockNum);
crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag); crclen += UDF_I(inode)->i_lenEAttr + UDF_I(inode)->i_lenAlloc -
sizeof(tag);
fe->descTag.descCRCLength = cpu_to_le16(crclen); fe->descTag.descCRCLength = cpu_to_le16(crclen);
fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag),
crclen, 0)); crclen, 0));
...@@ -1671,7 +1677,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino) ...@@ -1671,7 +1677,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
return NULL; return NULL;
if (inode->i_state & I_NEW) { 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); __udf_read_inode(inode);
unlock_new_inode(inode); unlock_new_inode(inode);
} }
...@@ -1705,15 +1711,15 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, ...@@ -1705,15 +1711,15 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
uint8_t *ptr; uint8_t *ptr;
if (!epos->bh) 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_file_entry_alloc_offset(inode) +
UDF_I_LENEATTR(inode); UDF_I(inode)->i_lenEAttr;
else else
ptr = epos->bh->b_data + epos->offset; 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); 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); adsize = sizeof(long_ad);
else else
return -1; return -1;
...@@ -1763,7 +1769,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, ...@@ -1763,7 +1769,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
cpu_to_le32(le32_to_cpu( cpu_to_le32(le32_to_cpu(
aed->lengthAllocDescs) + adsize); aed->lengthAllocDescs) + adsize);
} else { } else {
UDF_I_LENALLOC(inode) += adsize; UDF_I(inode)->i_lenAlloc += adsize;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} }
} }
...@@ -1773,7 +1779,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, ...@@ -1773,7 +1779,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
else else
udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1, udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
epos->block.logicalBlockNum, sizeof(tag)); epos->block.logicalBlockNum, sizeof(tag));
switch (UDF_I_ALLOCTYPE(inode)) { switch (UDF_I(inode)->i_alloc_type) {
case ICBTAG_FLAG_AD_SHORT: case ICBTAG_FLAG_AD_SHORT:
sad = (short_ad *)sptr; sad = (short_ad *)sptr;
sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS | 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, ...@@ -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); etype = udf_write_aext(inode, epos, eloc, elen, inc);
if (!epos->bh) { if (!epos->bh) {
UDF_I_LENALLOC(inode) += adsize; UDF_I(inode)->i_lenAlloc += adsize;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} else { } else {
aed = (struct allocExtDesc *)epos->bh->b_data; aed = (struct allocExtDesc *)epos->bh->b_data;
...@@ -1836,13 +1842,13 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos, ...@@ -1836,13 +1842,13 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
long_ad *lad; long_ad *lad;
if (!epos->bh) 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_file_entry_alloc_offset(inode) +
UDF_I_LENEATTR(inode); UDF_I(inode)->i_lenEAttr;
else else
ptr = epos->bh->b_data + epos->offset; ptr = epos->bh->b_data + epos->offset;
switch (UDF_I_ALLOCTYPE(inode)) { switch (UDF_I(inode)->i_alloc_type) {
case ICBTAG_FLAG_AD_SHORT: case ICBTAG_FLAG_AD_SHORT:
sad = (short_ad *)ptr; sad = (short_ad *)ptr;
sad->extLength = cpu_to_le32(elen); sad->extLength = cpu_to_le32(elen);
...@@ -1914,11 +1920,11 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos, ...@@ -1914,11 +1920,11 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
if (!epos->bh) { if (!epos->bh) {
if (!epos->offset) if (!epos->offset)
epos->offset = udf_file_entry_alloc_offset(inode); 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_file_entry_alloc_offset(inode) +
UDF_I_LENEATTR(inode); UDF_I(inode)->i_lenEAttr;
alen = udf_file_entry_alloc_offset(inode) + alen = udf_file_entry_alloc_offset(inode) +
UDF_I_LENALLOC(inode); UDF_I(inode)->i_lenAlloc;
} else { } else {
if (!epos->offset) if (!epos->offset)
epos->offset = sizeof(struct allocExtDesc); epos->offset = sizeof(struct allocExtDesc);
...@@ -1928,7 +1934,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos, ...@@ -1928,7 +1934,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
lengthAllocDescs); lengthAllocDescs);
} }
switch (UDF_I_ALLOCTYPE(inode)) { switch (UDF_I(inode)->i_alloc_type) {
case ICBTAG_FLAG_AD_SHORT: case ICBTAG_FLAG_AD_SHORT:
sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc); sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
if (!sad) if (!sad)
...@@ -1936,7 +1942,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos, ...@@ -1936,7 +1942,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
etype = le32_to_cpu(sad->extLength) >> 30; etype = le32_to_cpu(sad->extLength) >> 30;
eloc->logicalBlockNum = le32_to_cpu(sad->extPosition); eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
eloc->partitionReferenceNum = eloc->partitionReferenceNum =
UDF_I_LOCATION(inode).partitionReferenceNum; UDF_I(inode)->i_location.partitionReferenceNum;
*elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK; *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
break; break;
case ICBTAG_FLAG_AD_LONG: case ICBTAG_FLAG_AD_LONG:
...@@ -1949,7 +1955,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos, ...@@ -1949,7 +1955,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
break; break;
default: default:
udf_debug("alloc_type = %d unsupported\n", udf_debug("alloc_type = %d unsupported\n",
UDF_I_ALLOCTYPE(inode)); UDF_I(inode)->i_alloc_type);
return -1; return -1;
} }
...@@ -1990,9 +1996,9 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, ...@@ -1990,9 +1996,9 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
get_bh(epos.bh); 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); 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); adsize = sizeof(long_ad);
else else
adsize = 0; adsize = 0;
...@@ -2019,7 +2025,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, ...@@ -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);
udf_write_aext(inode, &oepos, eloc, elen, 1); udf_write_aext(inode, &oepos, eloc, elen, 1);
if (!oepos.bh) { if (!oepos.bh) {
UDF_I_LENALLOC(inode) -= (adsize * 2); UDF_I(inode)->i_lenAlloc -= (adsize * 2);
mark_inode_dirty(inode); mark_inode_dirty(inode);
} else { } else {
aed = (struct allocExtDesc *)oepos.bh->b_data; aed = (struct allocExtDesc *)oepos.bh->b_data;
...@@ -2038,7 +2044,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, ...@@ -2038,7 +2044,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
} else { } else {
udf_write_aext(inode, &oepos, eloc, elen, 1); udf_write_aext(inode, &oepos, eloc, elen, 1);
if (!oepos.bh) { if (!oepos.bh) {
UDF_I_LENALLOC(inode) -= adsize; UDF_I(inode)->i_lenAlloc -= adsize;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} else { } else {
aed = (struct allocExtDesc *)oepos.bh->b_data; aed = (struct allocExtDesc *)oepos.bh->b_data;
...@@ -2077,7 +2083,7 @@ int8_t inode_bmap(struct inode *inode, sector_t block, ...@@ -2077,7 +2083,7 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
} }
pos->offset = 0; pos->offset = 0;
pos->block = UDF_I_LOCATION(inode); pos->block = UDF_I(inode)->i_location;
pos->bh = NULL; pos->bh = NULL;
*elen = 0; *elen = 0;
...@@ -2085,7 +2091,7 @@ int8_t inode_bmap(struct inode *inode, sector_t block, ...@@ -2085,7 +2091,7 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
etype = udf_next_aext(inode, pos, eloc, elen, 1); etype = udf_next_aext(inode, pos, eloc, elen, 1);
if (etype == -1) { if (etype == -1) {
*offset = (bcount - lbcount) >> blocksize_bits; *offset = (bcount - lbcount) >> blocksize_bits;
UDF_I_LENEXTENTS(inode) = lbcount; UDF_I(inode)->i_lenExtents = lbcount;
return -1; return -1;
} }
lbcount += *elen; lbcount += *elen;
......
...@@ -52,16 +52,16 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size, ...@@ -52,16 +52,16 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
int offset; int offset;
uint16_t crclen; uint16_t crclen;
ea = UDF_I_DATA(inode); ea = UDF_I(inode)->i_ext.i_data;
if (UDF_I_LENEATTR(inode)) { if (UDF_I(inode)->i_lenEAttr) {
ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode); ad = UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr;
} else { } else {
ad = ea; ad = ea;
size += sizeof(struct extendedAttrHeaderDesc); size += sizeof(struct extendedAttrHeaderDesc);
} }
offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) - 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 */ /* TODO - Check for FreeEASpace */
...@@ -69,21 +69,21 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size, ...@@ -69,21 +69,21 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
struct extendedAttrHeaderDesc *eahd; struct extendedAttrHeaderDesc *eahd;
eahd = (struct extendedAttrHeaderDesc *)ea; eahd = (struct extendedAttrHeaderDesc *)ea;
if (UDF_I_LENALLOC(inode)) if (UDF_I(inode)->i_lenAlloc)
memmove(&ad[size], ad, UDF_I_LENALLOC(inode)); memmove(&ad[size], ad, UDF_I(inode)->i_lenAlloc);
if (UDF_I_LENEATTR(inode)) { if (UDF_I(inode)->i_lenEAttr) {
/* check checksum/crc */ /* check checksum/crc */
if (eahd->descTag.tagIdent != if (eahd->descTag.tagIdent !=
cpu_to_le16(TAG_IDENT_EAHD) || cpu_to_le16(TAG_IDENT_EAHD) ||
le32_to_cpu(eahd->descTag.tagLocation) != le32_to_cpu(eahd->descTag.tagLocation) !=
UDF_I_LOCATION(inode).logicalBlockNum) UDF_I(inode)->i_location.logicalBlockNum)
return NULL; return NULL;
} else { } else {
struct udf_sb_info *sbi = UDF_SB(inode->i_sb); struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
size -= sizeof(struct extendedAttrHeaderDesc); size -= sizeof(struct extendedAttrHeaderDesc);
UDF_I_LENEATTR(inode) += UDF_I(inode)->i_lenEAttr +=
sizeof(struct extendedAttrHeaderDesc); sizeof(struct extendedAttrHeaderDesc);
eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD); eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
if (sbi->s_udfrev >= 0x0200) if (sbi->s_udfrev >= 0x0200)
...@@ -93,15 +93,15 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size, ...@@ -93,15 +93,15 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
eahd->descTag.tagSerialNum = eahd->descTag.tagSerialNum =
cpu_to_le16(sbi->s_serial_number); cpu_to_le16(sbi->s_serial_number);
eahd->descTag.tagLocation = cpu_to_le32( eahd->descTag.tagLocation = cpu_to_le32(
UDF_I_LOCATION(inode).logicalBlockNum); UDF_I(inode)->i_location.logicalBlockNum);
eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF); eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
eahd->appAttrLocation = 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 (type < 2048) {
if (le32_to_cpu(eahd->appAttrLocation) < if (le32_to_cpu(eahd->appAttrLocation) <
UDF_I_LENEATTR(inode)) { UDF_I(inode)->i_lenEAttr) {
uint32_t aal = uint32_t aal =
le32_to_cpu(eahd->appAttrLocation); le32_to_cpu(eahd->appAttrLocation);
memmove(&ea[offset - aal + size], memmove(&ea[offset - aal + size],
...@@ -111,7 +111,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size, ...@@ -111,7 +111,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
cpu_to_le32(aal + size); cpu_to_le32(aal + size);
} }
if (le32_to_cpu(eahd->impAttrLocation) < if (le32_to_cpu(eahd->impAttrLocation) <
UDF_I_LENEATTR(inode)) { UDF_I(inode)->i_lenEAttr) {
uint32_t ial = uint32_t ial =
le32_to_cpu(eahd->impAttrLocation); le32_to_cpu(eahd->impAttrLocation);
memmove(&ea[offset - ial + size], memmove(&ea[offset - ial + size],
...@@ -122,7 +122,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size, ...@@ -122,7 +122,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
} }
} else if (type < 65536) { } else if (type < 65536) {
if (le32_to_cpu(eahd->appAttrLocation) < if (le32_to_cpu(eahd->appAttrLocation) <
UDF_I_LENEATTR(inode)) { UDF_I(inode)->i_lenEAttr) {
uint32_t aal = uint32_t aal =
le32_to_cpu(eahd->appAttrLocation); le32_to_cpu(eahd->appAttrLocation);
memmove(&ea[offset - aal + size], memmove(&ea[offset - aal + size],
...@@ -138,7 +138,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t 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 + eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
sizeof(tag), crclen, 0)); sizeof(tag), crclen, 0));
eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag); eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag);
UDF_I_LENEATTR(inode) += size; UDF_I(inode)->i_lenEAttr += size;
return (struct genericFormat *)&ea[offset]; return (struct genericFormat *)&ea[offset];
} }
if (loc & 0x02) if (loc & 0x02)
...@@ -154,9 +154,9 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type, ...@@ -154,9 +154,9 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
uint8_t *ea = NULL; uint8_t *ea = NULL;
uint32_t offset; 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; struct extendedAttrHeaderDesc *eahd;
eahd = (struct extendedAttrHeaderDesc *)ea; eahd = (struct extendedAttrHeaderDesc *)ea;
...@@ -164,7 +164,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type, ...@@ -164,7 +164,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
if (eahd->descTag.tagIdent != if (eahd->descTag.tagIdent !=
cpu_to_le16(TAG_IDENT_EAHD) || cpu_to_le16(TAG_IDENT_EAHD) ||
le32_to_cpu(eahd->descTag.tagLocation) != le32_to_cpu(eahd->descTag.tagLocation) !=
UDF_I_LOCATION(inode).logicalBlockNum) UDF_I(inode)->i_location.logicalBlockNum)
return NULL; return NULL;
if (type < 2048) if (type < 2048)
...@@ -174,7 +174,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type, ...@@ -174,7 +174,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
else else
offset = le32_to_cpu(eahd->appAttrLocation); offset = le32_to_cpu(eahd->appAttrLocation);
while (offset < UDF_I_LENEATTR(inode)) { while (offset < UDF_I(inode)->i_lenEAttr) {
gaf = (struct genericFormat *)&ea[offset]; gaf = (struct genericFormat *)&ea[offset];
if (le32_to_cpu(gaf->attrType) == type && if (le32_to_cpu(gaf->attrType) == type &&
gaf->attrSubtype == subtype) gaf->attrSubtype == subtype)
......
...@@ -54,7 +54,7 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi, ...@@ -54,7 +54,7 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
sizeof(struct fileIdentDesc); sizeof(struct fileIdentDesc);
int adinicb = 0; 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; adinicb = 1;
offset = fibh->soffset + sizeof(struct fileIdentDesc); offset = fibh->soffset + sizeof(struct fileIdentDesc);
...@@ -164,16 +164,17 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir, ...@@ -164,16 +164,17 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
fibh->soffset = fibh->eoffset = fibh->soffset = fibh->eoffset =
(f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; (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; fibh->sbh = fibh->ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == &epos, &eloc, &elen, &offset) ==
(EXT_RECORDED_ALLOCATED >> 30)) { (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset); block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { 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); 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); epos.offset -= sizeof(long_ad);
} else } else
offset = 0; offset = 0;
...@@ -372,16 +373,17 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, ...@@ -372,16 +373,17 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
fibh->soffset = fibh->eoffset = fibh->soffset = fibh->eoffset =
(f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; (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; fibh->sbh = fibh->ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == &epos, &eloc, &elen, &offset) ==
(EXT_RECORDED_ALLOCATED >> 30)) { (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset); block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { 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); 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); epos.offset -= sizeof(long_ad);
} else } else
offset = 0; offset = 0;
...@@ -393,10 +395,10 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, ...@@ -393,10 +395,10 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
return NULL; return NULL;
} }
block = UDF_I_LOCATION(dir).logicalBlockNum; block = UDF_I(dir)->i_location.logicalBlockNum;
} else { } 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->sbh = fibh->ebh = NULL;
fibh->soffset = fibh->eoffset = sb->s_blocksize; fibh->soffset = fibh->eoffset = sb->s_blocksize;
goto add; goto add;
...@@ -475,7 +477,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, ...@@ -475,7 +477,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
add: add:
f_pos += nfidlen; 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) { sb->s_blocksize - fibh->eoffset < nfidlen) {
brelse(epos.bh); brelse(epos.bh);
epos.bh = NULL; epos.bh = NULL;
...@@ -489,15 +491,15 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, ...@@ -489,15 +491,15 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
udf_expand_dir_adinicb(dir, &block, err); udf_expand_dir_adinicb(dir, &block, err);
if (!fibh->sbh) if (!fibh->sbh)
return NULL; return NULL;
epos.block = UDF_I_LOCATION(dir); epos.block = UDF_I(dir)->i_location;
eloc.logicalBlockNum = block; eloc.logicalBlockNum = block;
eloc.partitionReferenceNum = eloc.partitionReferenceNum =
UDF_I_LOCATION(dir).partitionReferenceNum; UDF_I(dir)->i_location.partitionReferenceNum;
elen = dir->i_sb->s_blocksize; elen = dir->i_sb->s_blocksize;
epos.offset = udf_file_entry_alloc_offset(dir); 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); 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); epos.offset += sizeof(long_ad);
} }
...@@ -509,12 +511,13 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, ...@@ -509,12 +511,13 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
fibh->sbh = fibh->ebh; fibh->sbh = fibh->ebh;
} }
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) { if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
block = UDF_I_LOCATION(dir).logicalBlockNum; block = UDF_I(dir)->i_location.logicalBlockNum;
fi = (struct fileIdentDesc *) fi = (struct fileIdentDesc *)
(UDF_I_DATA(dir) + fibh->soffset - (UDF_I(dir)->i_ext.i_data +
fibh->soffset -
udf_ext0_offset(dir) + udf_ext0_offset(dir) +
UDF_I_LENEATTR(dir)); UDF_I(dir)->i_lenEAttr);
} else { } else {
block = eloc.logicalBlockNum + block = eloc.logicalBlockNum +
((elen - 1) >> ((elen - 1) >>
...@@ -572,8 +575,8 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, ...@@ -572,8 +575,8 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) { if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
brelse(epos.bh); brelse(epos.bh);
dir->i_size += nfidlen; dir->i_size += nfidlen;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
UDF_I_LENALLOC(dir) += nfidlen; UDF_I(dir)->i_lenAlloc += nfidlen;
mark_inode_dirty(dir); mark_inode_dirty(dir);
return fi; return fi;
} else { } else {
...@@ -613,7 +616,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, ...@@ -613,7 +616,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
return err; 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; inode->i_data.a_ops = &udf_adinicb_aops;
else else
inode->i_data.a_ops = &udf_aops; inode->i_data.a_ops = &udf_aops;
...@@ -631,11 +634,11 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, ...@@ -631,11 +634,11 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
return err; return err;
} }
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 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 = *(__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); 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(dir);
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
...@@ -674,11 +677,11 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode, ...@@ -674,11 +677,11 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
return err; return err;
} }
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 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 = *(__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); 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(dir);
mark_inode_dirty(inode); mark_inode_dirty(inode);
...@@ -721,9 +724,9 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode) ...@@ -721,9 +724,9 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
} }
inode->i_nlink = 2; inode->i_nlink = 2;
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 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 = *(__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 = cfi.fileCharacteristics =
FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT; FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL); 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) ...@@ -741,9 +744,9 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
goto out; goto out;
} }
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 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 = *(__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; cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
inc_nlink(dir); inc_nlink(dir);
...@@ -776,16 +779,17 @@ static int empty_dir(struct inode *dir) ...@@ -776,16 +779,17 @@ static int empty_dir(struct inode *dir)
fibh.soffset = fibh.eoffset = fibh.soffset = fibh.eoffset =
(f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; (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; fibh.sbh = fibh.ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == &epos, &eloc, &elen, &offset) ==
(EXT_RECORDED_ALLOCATED >> 30)) { (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset); block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { 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); 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); epos.offset -= sizeof(long_ad);
} else } else
offset = 0; offset = 0;
...@@ -945,28 +949,28 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry, ...@@ -945,28 +949,28 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
inode->i_data.a_ops = &udf_symlink_aops; inode->i_data.a_ops = &udf_symlink_aops;
inode->i_op = &page_symlink_inode_operations; 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; kernel_lb_addr eloc;
uint32_t elen; uint32_t elen;
block = udf_new_block(inode->i_sb, inode, block = udf_new_block(inode->i_sb, inode,
UDF_I_LOCATION(inode).partitionReferenceNum, UDF_I(inode)->i_location.partitionReferenceNum,
UDF_I_LOCATION(inode).logicalBlockNum, &err); UDF_I(inode)->i_location.logicalBlockNum, &err);
if (!block) if (!block)
goto out_no_entry; 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.offset = udf_file_entry_alloc_offset(inode);
epos.bh = NULL; epos.bh = NULL;
eloc.logicalBlockNum = block; eloc.logicalBlockNum = block;
eloc.partitionReferenceNum = eloc.partitionReferenceNum =
UDF_I_LOCATION(inode).partitionReferenceNum; UDF_I(inode)->i_location.partitionReferenceNum;
elen = inode->i_sb->s_blocksize; 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); udf_add_aext(inode, &epos, eloc, elen, 0);
brelse(epos.bh); brelse(epos.bh);
block = udf_get_pblock(inode->i_sb, block, block = udf_get_pblock(inode->i_sb, block,
UDF_I_LOCATION(inode).partitionReferenceNum, UDF_I(inode)->i_location.partitionReferenceNum,
0); 0);
epos.bh = udf_tread(inode->i_sb, block); epos.bh = udf_tread(inode->i_sb, block);
lock_buffer(epos.bh); lock_buffer(epos.bh);
...@@ -976,7 +980,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry, ...@@ -976,7 +980,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
mark_buffer_dirty_inode(epos.bh, inode); mark_buffer_dirty_inode(epos.bh, inode);
ea = epos.bh->b_data + udf_ext0_offset(inode); ea = epos.bh->b_data + udf_ext0_offset(inode);
} else { } 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); eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
...@@ -1045,15 +1049,15 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry, ...@@ -1045,15 +1049,15 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
brelse(epos.bh); brelse(epos.bh);
inode->i_size = elen; inode->i_size = elen;
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
UDF_I_LENALLOC(inode) = inode->i_size; UDF_I(inode)->i_lenAlloc = inode->i_size;
mark_inode_dirty(inode); mark_inode_dirty(inode);
fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
if (!fi) if (!fi)
goto out_no_entry; goto out_no_entry;
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 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; bh = UDF_SB(inode->i_sb)->s_lvid_bh;
if (bh) { if (bh) {
struct logicalVolIntegrityDesc *lvid = struct logicalVolIntegrityDesc *lvid =
...@@ -1071,7 +1075,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry, ...@@ -1071,7 +1075,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
} }
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 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(dir);
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
...@@ -1110,7 +1114,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir, ...@@ -1110,7 +1114,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
return err; return err;
} }
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 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; bh = UDF_SB(inode->i_sb)->s_lvid_bh;
if (bh) { if (bh) {
struct logicalVolIntegrityDesc *lvid = struct logicalVolIntegrityDesc *lvid =
...@@ -1128,7 +1132,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir, ...@@ -1128,7 +1132,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
} }
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 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(dir);
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
...@@ -1189,10 +1193,10 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry, ...@@ -1189,10 +1193,10 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
goto end_rename; goto end_rename;
} }
retval = -EIO; 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( dir_fi = udf_get_fileident(
UDF_I_DATA(old_inode) - UDF_I(old_inode)->i_ext.i_data -
(UDF_I_EFE(old_inode) ? (UDF_I(old_inode)->i_efe ?
sizeof(struct extendedFileEntry) : sizeof(struct extendedFileEntry) :
sizeof(struct fileEntry)), sizeof(struct fileEntry)),
old_inode->i_sb->s_blocksize, &offset); old_inode->i_sb->s_blocksize, &offset);
...@@ -1250,11 +1254,11 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry, ...@@ -1250,11 +1254,11 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
mark_inode_dirty(old_dir); mark_inode_dirty(old_dir);
if (dir_fi) { 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, udf_update_tag((char *)dir_fi,
(sizeof(struct fileIdentDesc) + (sizeof(struct fileIdentDesc) +
le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3); 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); mark_inode_dirty(old_inode);
else else
mark_buffer_dirty_inode(dir_bh, old_inode); mark_buffer_dirty_inode(dir_bh, old_inode);
......
...@@ -88,14 +88,14 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, ...@@ -88,14 +88,14 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
brelse(bh); brelse(bh);
if (UDF_I_LOCATION(sbi->s_vat_inode).partitionReferenceNum == if (UDF_I(sbi->s_vat_inode)->i_location.partitionReferenceNum ==
partition) { partition) {
udf_debug("recursive call to udf_get_pblock!\n"); udf_debug("recursive call to udf_get_pblock!\n");
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
return udf_get_pblock(sb, loc, return udf_get_pblock(sb, loc,
UDF_I_LOCATION(sbi->s_vat_inode). UDF_I(sbi->s_vat_inode)->i_location.
partitionReferenceNum, partitionReferenceNum,
offset); offset);
} }
......
...@@ -2046,7 +2046,7 @@ static unsigned int udf_count_free_table(struct super_block *sb, ...@@ -2046,7 +2046,7 @@ static unsigned int udf_count_free_table(struct super_block *sb,
lock_kernel(); lock_kernel();
epos.block = UDF_I_LOCATION(table); epos.block = UDF_I(table)->i_location;
epos.offset = sizeof(struct unallocSpaceEntry); epos.offset = sizeof(struct unallocSpaceEntry);
epos.bh = NULL; epos.bh = NULL;
......
...@@ -81,8 +81,8 @@ static int udf_symlink_filler(struct file *file, struct page *page) ...@@ -81,8 +81,8 @@ static int udf_symlink_filler(struct file *file, struct page *page)
char *p = kmap(page); char *p = kmap(page);
lock_kernel(); lock_kernel();
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) { if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
symlink = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode); symlink = UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr;
} else { } else {
bh = sb_bread(inode->i_sb, udf_block_map(inode, 0)); bh = sb_bread(inode->i_sb, udf_block_map(inode, 0));
......
...@@ -75,16 +75,16 @@ void udf_truncate_tail_extent(struct inode *inode) ...@@ -75,16 +75,16 @@ void udf_truncate_tail_extent(struct inode *inode)
int8_t etype = -1, netype; int8_t etype = -1, netype;
int adsize; int adsize;
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB || if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
inode->i_size == UDF_I_LENEXTENTS(inode)) inode->i_size == UDF_I(inode)->i_lenExtents)
return; return;
/* Are we going to delete the file anyway? */ /* Are we going to delete the file anyway? */
if (inode->i_nlink == 0) if (inode->i_nlink == 0)
return; 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); 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); adsize = sizeof(long_ad);
else else
BUG(); BUG();
...@@ -117,7 +117,7 @@ void udf_truncate_tail_extent(struct inode *inode) ...@@ -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 /* This inode entry is in-memory only and thus we don't have to mark
* the inode dirty */ * the inode dirty */
UDF_I_LENEXTENTS(inode) = inode->i_size; UDF_I(inode)->i_lenExtents = inode->i_size;
brelse(epos.bh); brelse(epos.bh);
} }
...@@ -130,18 +130,18 @@ void udf_discard_prealloc(struct inode *inode) ...@@ -130,18 +130,18 @@ void udf_discard_prealloc(struct inode *inode)
int8_t etype = -1, netype; int8_t etype = -1, netype;
int adsize; int adsize;
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB || if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
inode->i_size == UDF_I_LENEXTENTS(inode)) inode->i_size == UDF_I(inode)->i_lenExtents)
return; 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); 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); adsize = sizeof(long_ad);
else else
adsize = 0; adsize = 0;
epos.block = UDF_I_LOCATION(inode); epos.block = UDF_I(inode)->i_location;
/* Find the last extent in the file */ /* Find the last extent in the file */
while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) { while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
...@@ -153,7 +153,7 @@ void udf_discard_prealloc(struct inode *inode) ...@@ -153,7 +153,7 @@ void udf_discard_prealloc(struct inode *inode)
lbcount -= elen; lbcount -= elen;
extent_trunc(inode, &epos, eloc, etype, elen, 0); extent_trunc(inode, &epos, eloc, etype, elen, 0);
if (!epos.bh) { if (!epos.bh) {
UDF_I_LENALLOC(inode) = UDF_I(inode)->i_lenAlloc =
epos.offset - epos.offset -
udf_file_entry_alloc_offset(inode); udf_file_entry_alloc_offset(inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
...@@ -174,7 +174,7 @@ void udf_discard_prealloc(struct inode *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 /* This inode entry is in-memory only and thus we don't have to mark
* the inode dirty */ * the inode dirty */
UDF_I_LENEXTENTS(inode) = lbcount; UDF_I(inode)->i_lenExtents = lbcount;
brelse(epos.bh); brelse(epos.bh);
} }
...@@ -190,9 +190,9 @@ void udf_truncate_extents(struct inode *inode) ...@@ -190,9 +190,9 @@ void udf_truncate_extents(struct inode *inode)
loff_t byte_offset; loff_t byte_offset;
int adsize; 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); 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); adsize = sizeof(long_ad);
else else
BUG(); BUG();
...@@ -227,7 +227,7 @@ void udf_truncate_extents(struct inode *inode) ...@@ -227,7 +227,7 @@ void udf_truncate_extents(struct inode *inode)
0, indirect_ext_len); 0, indirect_ext_len);
} else { } else {
if (!epos.bh) { if (!epos.bh) {
UDF_I_LENALLOC(inode) = UDF_I(inode)->i_lenAlloc =
lenalloc; lenalloc;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} else { } else {
...@@ -275,7 +275,7 @@ void udf_truncate_extents(struct inode *inode) ...@@ -275,7 +275,7 @@ void udf_truncate_extents(struct inode *inode)
indirect_ext_len); indirect_ext_len);
} else { } else {
if (!epos.bh) { if (!epos.bh) {
UDF_I_LENALLOC(inode) = lenalloc; UDF_I(inode)->i_lenAlloc = lenalloc;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} else { } else {
struct allocExtDesc *aed = struct allocExtDesc *aed =
...@@ -325,7 +325,7 @@ void udf_truncate_extents(struct inode *inode) ...@@ -325,7 +325,7 @@ void udf_truncate_extents(struct inode *inode)
(sb->s_blocksize - 1)) != 0)); (sb->s_blocksize - 1)) != 0));
} }
} }
UDF_I_LENEXTENTS(inode) = inode->i_size; UDF_I(inode)->i_lenExtents = inode->i_size;
brelse(epos.bh); brelse(epos.bh);
} }
...@@ -7,20 +7,4 @@ static inline struct udf_inode_info *UDF_I(struct inode *inode) ...@@ -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); 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) */ #endif /* !defined(_LINUX_UDF_I_H) */
...@@ -24,14 +24,14 @@ ...@@ -24,14 +24,14 @@
#define UDF_PATH_LEN 1023 #define UDF_PATH_LEN 1023
#define udf_file_entry_alloc_offset(inode)\ #define udf_file_entry_alloc_offset(inode)\
(UDF_I_USE(inode) ?\ (UDF_I(inode)->i_use ?\
sizeof(struct unallocSpaceEntry) :\ sizeof(struct unallocSpaceEntry) :\
((UDF_I_EFE(inode) ?\ ((UDF_I(inode)->i_efe ?\
sizeof(struct extendedFileEntry) :\ sizeof(struct extendedFileEntry) :\
sizeof(struct fileEntry)) + UDF_I_LENEATTR(inode))) sizeof(struct fileEntry)) + UDF_I(inode)->i_lenEAttr))
#define udf_ext0_offset(inode)\ #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) udf_file_entry_alloc_offset(inode) : 0)
#define udf_get_lb_pblock(sb,loc,offset) udf_get_pblock((sb), (loc).logicalBlockNum, (loc).partitionReferenceNum, (offset)) #define udf_get_lb_pblock(sb,loc,offset) udf_get_pblock((sb), (loc).logicalBlockNum, (loc).partitionReferenceNum, (offset))
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment