dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

udf: remove UDF_I_* macros and open code them 

Signed-off-by: Marcin Slusarz <marcin.slusarz@gmail.com>
Acked-by: Jan Kara <jack@suse.cz>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Marcin Slusarz 2008-02-08 04:20:42 -08:00 committed by Linus Torvalds
parent 5e0f001736
commit c0b344385f
14 changed files with 315 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
fs/udf/balloc.c
View File

@ -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,
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,
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,
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,
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,
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,
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,
*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,
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 &&

7
fs/udf/dir.c
View File

@ -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;

6
fs/udf/directory.c
View File

@ -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,

24
fs/udf/file.c
View File

@ -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,
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,
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,
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,
(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,
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;
} }

50
fs/udf/ialloc.c
View File

@ -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)
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)
} }
*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)
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)
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);

296
fs/udf/inode.c
View File

@ -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)
/* 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)
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,
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,
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,
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,
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,
(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 @@ out:
} }
/* 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,
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,
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,
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,
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,
(*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)
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)
* 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)
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)
&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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
(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)
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)
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)
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)
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
} 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,
} }
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,
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;

38
fs/udf/misc.c
View File

@ -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,
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,
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,
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,
} }
} 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,
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,
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,
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,
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)

110
fs/udf/namei.c
View File

@ -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,
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,
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,
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,
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 @@ add:
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 @@ add:
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 @@ add:
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,
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,
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,
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)
} }
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)
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)
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,
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,
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,
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,
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,
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,
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,
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,
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);

4
fs/udf/partition.c
View File

@ -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);
} }

2
fs/udf/super.c
View File

@ -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;

4
fs/udf/symlink.c
View File

@ -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));

34
fs/udf/truncate.c
View File

@ -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)
} }
/* 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)
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)
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)
} }
/* 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)
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)
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)
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)
(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);
} }

16
fs/udf/udf_i.h
View File

@ -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) */

8
fs/udf/udfdecl.h
View File

@ -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))