leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

udf: cache struct udf_inode_info

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

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

35
fs/udf/balloc.c
View File

@ -436,6 +436,7 @@ static void udf_table_free_blocks(struct super_block *sb,
struct extent_position oepos, epos; struct extent_position oepos, epos;
int8_t etype; int8_t etype;
int i; int i;
struct udf_inode_info *iinfo;
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
if (bloc.logicalBlockNum < 0 || if (bloc.logicalBlockNum < 0 ||
@ -448,6 +449,7 @@ static void udf_table_free_blocks(struct super_block *sb,
goto error_return; goto error_return;
} }
iinfo = UDF_I(table);
/* We do this up front - There are some error conditions that /* We do this up front - There are some error conditions that
could occure, but.. oh well */ could occure, but.. oh well */
if (inode) if (inode)
@ -460,7 +462,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(table)->i_location; epos.block = oepos.block = iinfo->i_location;
epos.bh = oepos.bh = NULL; epos.bh = oepos.bh = NULL;
while (count && while (count &&
@ -539,11 +541,11 @@ 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(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) { if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
} else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG) { else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); adsize = sizeof(long_ad);
} else { else {
brelse(oepos.bh); brelse(oepos.bh);
brelse(epos.bh); brelse(epos.bh);
goto error_return; goto error_return;
@ -573,7 +575,7 @@ 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(table)->i_ext.i_data + epos.offset sptr = iinfo->i_ext.i_data + epos.offset
- adsize; - adsize;
dptr = epos.bh->b_data + dptr = epos.bh->b_data +
sizeof(struct allocExtDesc); sizeof(struct allocExtDesc);
@ -592,9 +594,9 @@ static void udf_table_free_blocks(struct super_block *sb,
aed->lengthAllocDescs) + aed->lengthAllocDescs) +
adsize); adsize);
} else { } else {
sptr = UDF_I(table)->i_ext.i_data + sptr = iinfo->i_ext.i_data +
epos.offset; epos.offset;
UDF_I(table)->i_lenAlloc += adsize; iinfo->i_lenAlloc += adsize;
mark_inode_dirty(table); mark_inode_dirty(table);
} }
epos.offset = sizeof(struct allocExtDesc); epos.offset = sizeof(struct allocExtDesc);
@ -608,7 +610,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(table)->i_alloc_type) { switch (iinfo->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(
@ -639,7 +641,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(table)->i_lenAlloc += adsize; iinfo->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;
@ -672,21 +674,23 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
kernel_lb_addr eloc; kernel_lb_addr eloc;
struct extent_position epos; struct extent_position epos;
int8_t etype = -1; int8_t etype = -1;
struct udf_inode_info *iinfo;
if (first_block < 0 || if (first_block < 0 ||
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(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) iinfo = UDF_I(table);
if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); 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(table)->i_location; epos.block = iinfo->i_location;
epos.bh = NULL; epos.bh = NULL;
eloc.logicalBlockNum = 0xFFFFFFFF; eloc.logicalBlockNum = 0xFFFFFFFF;
@ -739,12 +743,13 @@ static int udf_table_new_block(struct super_block *sb,
kernel_lb_addr eloc, uninitialized_var(goal_eloc); kernel_lb_addr eloc, uninitialized_var(goal_eloc);
struct extent_position epos, goal_epos; struct extent_position epos, goal_epos;
int8_t etype; int8_t etype;
struct udf_inode_info *iinfo = UDF_I(table);
*err = -ENOSPC; *err = -ENOSPC;
if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); adsize = sizeof(long_ad);
else else
return newblock; return newblock;
@ -759,7 +764,7 @@ static int udf_table_new_block(struct super_block *sb,
of the current closest match and use that when we are done. 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(table)->i_location; epos.block = iinfo->i_location;
epos.bh = goal_epos.bh = NULL; epos.bh = goal_epos.bh = NULL;
while (spread && while (spread &&

8
fs/udf/dir.c
View File

@ -117,6 +117,7 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
int i, num; int i, num;
unsigned int dt_type; unsigned int dt_type;
struct extent_position epos = { NULL, 0, {0, 0} }; struct extent_position epos = { NULL, 0, {0, 0} };
struct udf_inode_info *iinfo;
if (nf_pos >= size) if (nf_pos >= size)
return 0; return 0;
@ -125,15 +126,16 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
nf_pos = (udf_ext0_offset(dir) >> 2); 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(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { iinfo = UDF_I(dir);
if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
fibh.sbh = fibh.ebh = NULL; 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(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad); epos.offset -= sizeof(short_ad);
else if (UDF_I(dir)->i_alloc_type == else if (iinfo->i_alloc_type ==
ICBTAG_FLAG_AD_LONG) ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad); epos.offset -= sizeof(long_ad);
} else { } else {

7
fs/udf/directory.c
View File

@ -81,12 +81,13 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,
struct fileIdentDesc *fi; struct fileIdentDesc *fi;
int i, num, block; int i, num, block;
struct buffer_head *tmp, *bha[16]; struct buffer_head *tmp, *bha[16];
struct udf_inode_info *iinfo = UDF_I(dir);
fibh->soffset = fibh->eoffset; fibh->soffset = fibh->eoffset;
if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
fi = udf_get_fileident(UDF_I(dir)->i_ext.i_data - fi = udf_get_fileident(iinfo->i_ext.i_data -
(UDF_I(dir)->i_efe ? (iinfo->i_efe ?
sizeof(struct extendedFileEntry) : sizeof(struct extendedFileEntry) :
sizeof(struct fileEntry)), sizeof(struct fileEntry)),
dir->i_sb->s_blocksize, dir->i_sb->s_blocksize,

21
fs/udf/file.c
View File

@ -45,13 +45,13 @@ static int udf_adinicb_readpage(struct file *file, struct page *page)
{ {
struct inode *inode = page->mapping->host; struct inode *inode = page->mapping->host;
char *kaddr; char *kaddr;
struct udf_inode_info *iinfo = UDF_I(inode);
BUG_ON(!PageLocked(page)); BUG_ON(!PageLocked(page));
kaddr = kmap(page); kaddr = kmap(page);
memset(kaddr, 0, PAGE_CACHE_SIZE); memset(kaddr, 0, PAGE_CACHE_SIZE);
memcpy(kaddr, UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr, inode->i_size);
inode->i_size);
flush_dcache_page(page); flush_dcache_page(page);
SetPageUptodate(page); SetPageUptodate(page);
kunmap(page); kunmap(page);
@ -65,12 +65,12 @@ static int udf_adinicb_writepage(struct page *page,
{ {
struct inode *inode = page->mapping->host; struct inode *inode = page->mapping->host;
char *kaddr; char *kaddr;
struct udf_inode_info *iinfo = UDF_I(inode);
BUG_ON(!PageLocked(page)); BUG_ON(!PageLocked(page));
kaddr = kmap(page); kaddr = kmap(page);
memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, kaddr, memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr, kaddr, inode->i_size);
inode->i_size);
mark_inode_dirty(inode); mark_inode_dirty(inode);
SetPageUptodate(page); SetPageUptodate(page);
kunmap(page); kunmap(page);
@ -87,9 +87,10 @@ static int udf_adinicb_write_end(struct file *file,
struct inode *inode = mapping->host; struct inode *inode = mapping->host;
unsigned offset = pos & (PAGE_CACHE_SIZE - 1); unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
char *kaddr; char *kaddr;
struct udf_inode_info *iinfo = UDF_I(inode);
kaddr = kmap_atomic(page, KM_USER0); kaddr = kmap_atomic(page, KM_USER0);
memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr + offset, memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,
kaddr + offset, copied); kaddr + offset, copied);
kunmap_atomic(kaddr, KM_USER0); kunmap_atomic(kaddr, KM_USER0);
@ -112,8 +113,9 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
struct inode *inode = file->f_path.dentry->d_inode; struct inode *inode = file->f_path.dentry->d_inode;
int err, pos; int err, pos;
size_t count = iocb->ki_left; size_t count = iocb->ki_left;
struct udf_inode_info *iinfo = UDF_I(inode);
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
if (file->f_flags & O_APPEND) if (file->f_flags & O_APPEND)
pos = inode->i_size; pos = inode->i_size;
else else
@ -123,16 +125,15 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
(udf_file_entry_alloc_offset(inode) + (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(inode)->i_alloc_type == if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
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(inode)->i_lenAlloc = pos + count; iinfo->i_lenAlloc = pos + count;
else else
UDF_I(inode)->i_lenAlloc = inode->i_size; iinfo->i_lenAlloc = inode->i_size;
} }
} }

49
fs/udf/ialloc.c
View File

@ -67,6 +67,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
struct inode *inode; struct inode *inode;
int block; int block;
uint32_t start = UDF_I(dir)->i_location.logicalBlockNum; uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;
struct udf_inode_info *iinfo;
struct udf_inode_info *dinfo = UDF_I(dir);
inode = new_inode(sb); inode = new_inode(sb);
@ -76,14 +78,15 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
} }
*err = -ENOSPC; *err = -ENOSPC;
UDF_I(inode)->i_unique = 0; iinfo = UDF_I(inode);
UDF_I(inode)->i_lenExtents = 0; iinfo->i_unique = 0;
UDF_I(inode)->i_next_alloc_block = 0; iinfo->i_lenExtents = 0;
UDF_I(inode)->i_next_alloc_goal = 0; iinfo->i_next_alloc_block = 0;
UDF_I(inode)->i_strat4096 = 0; iinfo->i_next_alloc_goal = 0;
iinfo->i_strat4096 = 0;
block = udf_new_block(dir->i_sb, NULL, block = udf_new_block(dir->i_sb, NULL,
UDF_I(dir)->i_location.partitionReferenceNum, dinfo->i_location.partitionReferenceNum,
start, err); start, err);
if (*err) { if (*err) {
iput(inode); iput(inode);
@ -107,7 +110,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(inode)->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID); iinfo->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 +126,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(inode)->i_location.logicalBlockNum = block; iinfo->i_location.logicalBlockNum = block;
UDF_I(inode)->i_location.partitionReferenceNum = iinfo->i_location.partitionReferenceNum =
UDF_I(dir)->i_location.partitionReferenceNum; dinfo->i_location.partitionReferenceNum;
inode->i_ino = udf_get_lb_pblock(sb, UDF_I(inode)->i_location, 0); inode->i_ino = udf_get_lb_pblock(sb, iinfo->i_location, 0);
inode->i_blocks = 0; inode->i_blocks = 0;
UDF_I(inode)->i_lenEAttr = 0; iinfo->i_lenEAttr = 0;
UDF_I(inode)->i_lenAlloc = 0; iinfo->i_lenAlloc = 0;
UDF_I(inode)->i_use = 0; iinfo->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(inode)->i_efe = 1; iinfo->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(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize - iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
sizeof(struct extendedFileEntry), sizeof(struct extendedFileEntry),
GFP_KERNEL); GFP_KERNEL);
} else { } else {
UDF_I(inode)->i_efe = 0; iinfo->i_efe = 0;
UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize - iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
sizeof(struct fileEntry), sizeof(struct fileEntry),
GFP_KERNEL); GFP_KERNEL);
} }
if (!UDF_I(inode)->i_ext.i_data) { if (!iinfo->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(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB; iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT; iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
else else
UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG; iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
inode->i_mtime = inode->i_atime = inode->i_ctime = inode->i_mtime = inode->i_atime = inode->i_ctime =
UDF_I(inode)->i_crtime = current_fs_time(inode->i_sb); iinfo->i_crtime = current_fs_time(inode->i_sb);
insert_inode_hash(inode); insert_inode_hash(inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);

305
fs/udf/inode.c
View File

@ -112,6 +112,7 @@ no_delete:
*/ */
void udf_clear_inode(struct inode *inode) void udf_clear_inode(struct inode *inode)
{ {
struct udf_inode_info *iinfo;
if (!(inode->i_sb->s_flags & MS_RDONLY)) { if (!(inode->i_sb->s_flags & MS_RDONLY)) {
lock_kernel(); lock_kernel();
/* Discard preallocation for directories, symlinks, etc. */ /* Discard preallocation for directories, symlinks, etc. */
@ -120,8 +121,9 @@ void udf_clear_inode(struct inode *inode)
unlock_kernel(); unlock_kernel();
write_inode_now(inode, 1); write_inode_now(inode, 1);
} }
kfree(UDF_I(inode)->i_ext.i_data); iinfo = UDF_I(inode);
UDF_I(inode)->i_ext.i_data = NULL; kfree(iinfo->i_ext.i_data);
iinfo->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)
@ -161,6 +163,7 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
{ {
struct page *page; struct page *page;
char *kaddr; char *kaddr;
struct udf_inode_info *iinfo = UDF_I(inode);
struct writeback_control udf_wbc = { struct writeback_control udf_wbc = {
.sync_mode = WB_SYNC_NONE, .sync_mode = WB_SYNC_NONE,
.nr_to_write = 1, .nr_to_write = 1,
@ -169,11 +172,11 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
/* from now on we have normal address_space methods */ /* 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(inode)->i_lenAlloc) { if (!iinfo->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(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT; iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
else else
UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG; iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
mark_inode_dirty(inode); mark_inode_dirty(inode);
return; return;
} }
@ -183,21 +186,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(inode)->i_lenAlloc, 0x00, memset(kaddr + iinfo->i_lenAlloc, 0x00,
PAGE_CACHE_SIZE - UDF_I(inode)->i_lenAlloc); PAGE_CACHE_SIZE - iinfo->i_lenAlloc);
memcpy(kaddr, UDF_I(inode)->i_ext.i_data + memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr,
UDF_I(inode)->i_lenEAttr, UDF_I(inode)->i_lenAlloc); iinfo->i_lenAlloc);
flush_dcache_page(page); flush_dcache_page(page);
SetPageUptodate(page); SetPageUptodate(page);
kunmap(page); kunmap(page);
} }
memset(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, 0x00, memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00,
UDF_I(inode)->i_lenAlloc); iinfo->i_lenAlloc);
UDF_I(inode)->i_lenAlloc = 0; iinfo->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(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT; iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
else else
UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG; iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
inode->i_data.a_ops->writepage(page, &udf_wbc); inode->i_data.a_ops->writepage(page, &udf_wbc);
page_cache_release(page); page_cache_release(page);
@ -219,6 +222,7 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
loff_t f_pos = udf_ext0_offset(inode) >> 2; loff_t f_pos = udf_ext0_offset(inode) >> 2;
int size = (udf_ext0_offset(inode) + inode->i_size) >> 2; int size = (udf_ext0_offset(inode) + inode->i_size) >> 2;
struct fileIdentDesc cfi, *sfi, *dfi; struct fileIdentDesc cfi, *sfi, *dfi;
struct udf_inode_info *iinfo = UDF_I(inode);
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
alloctype = ICBTAG_FLAG_AD_SHORT; alloctype = ICBTAG_FLAG_AD_SHORT;
@ -226,19 +230,19 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
alloctype = ICBTAG_FLAG_AD_LONG; alloctype = ICBTAG_FLAG_AD_LONG;
if (!inode->i_size) { if (!inode->i_size) {
UDF_I(inode)->i_alloc_type = alloctype; iinfo->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(inode)->i_location.partitionReferenceNum, iinfo->i_location.partitionReferenceNum,
UDF_I(inode)->i_location.logicalBlockNum, err); iinfo->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(inode)->i_location.partitionReferenceNum, iinfo->i_location.partitionReferenceNum,
0); 0);
if (!newblock) if (!newblock)
return NULL; return NULL;
@ -257,14 +261,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(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB; iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, 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(inode)->i_alloc_type = alloctype; iinfo->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 +276,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(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB; iinfo->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(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, 0, memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0,
UDF_I(inode)->i_lenAlloc); iinfo->i_lenAlloc);
UDF_I(inode)->i_lenAlloc = 0; iinfo->i_lenAlloc = 0;
eloc.logicalBlockNum = *block; eloc.logicalBlockNum = *block;
eloc.partitionReferenceNum = eloc.partitionReferenceNum =
UDF_I(inode)->i_location.partitionReferenceNum; iinfo->i_location.partitionReferenceNum;
elen = inode->i_size; elen = inode->i_size;
UDF_I(inode)->i_lenExtents = elen; iinfo->i_lenExtents = elen;
epos.bh = NULL; epos.bh = NULL;
epos.block = UDF_I(inode)->i_location; epos.block = iinfo->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 */
@ -304,6 +308,7 @@ static int udf_get_block(struct inode *inode, sector_t block,
int err, new; int err, new;
struct buffer_head *bh; struct buffer_head *bh;
unsigned long phys; unsigned long phys;
struct udf_inode_info *iinfo;
if (!create) { if (!create) {
phys = udf_block_map(inode, block); phys = udf_block_map(inode, block);
@ -321,9 +326,10 @@ 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(inode)->i_next_alloc_block + 1) { iinfo = UDF_I(inode);
UDF_I(inode)->i_next_alloc_block++; if (block == iinfo->i_next_alloc_block + 1) {
UDF_I(inode)->i_next_alloc_goal++; iinfo->i_next_alloc_block++;
iinfo->i_next_alloc_goal++;
} }
err = 0; err = 0;
@ -380,20 +386,22 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
struct super_block *sb = inode->i_sb; struct super_block *sb = inode->i_sb;
kernel_lb_addr prealloc_loc = {}; kernel_lb_addr prealloc_loc = {};
int prealloc_len = 0; int prealloc_len = 0;
struct udf_inode_info *iinfo;
/* The previous extent is fake and we should not extend by anything /* The previous extent is fake and we should not extend by anything
* - there's nothing to do... */ * - there's nothing to do... */
if (!blocks && fake) if (!blocks && fake)
return 0; return 0;
iinfo = UDF_I(inode);
/* Round the last extent up to a multiple of block size */ /* Round the last extent up to a multiple of block size */
if (last_ext->extLength & (sb->s_blocksize - 1)) { if (last_ext->extLength & (sb->s_blocksize - 1)) {
last_ext->extLength = last_ext->extLength =
(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(inode)->i_lenExtents = iinfo->i_lenExtents =
(UDF_I(inode)->i_lenExtents + sb->s_blocksize - 1) & (iinfo->i_lenExtents + sb->s_blocksize - 1) &
~(sb->s_blocksize - 1); ~(sb->s_blocksize - 1);
} }
@ -470,9 +478,9 @@ out:
} }
/* last_pos should point to the last written extent... */ /* last_pos should point to the last written extent... */
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
last_pos->offset -= sizeof(short_ad); last_pos->offset -= sizeof(short_ad);
else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
last_pos->offset -= sizeof(long_ad); last_pos->offset -= sizeof(long_ad);
else else
return -1; return -1;
@ -495,11 +503,12 @@ 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(inode)->i_location.logicalBlockNum; struct udf_inode_info *iinfo = UDF_I(inode);
int goal = 0, pgoal = iinfo->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(inode)->i_location; prev_epos.block = iinfo->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,24 +658,23 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) 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(inode)->i_next_alloc_block == block) if (iinfo->i_next_alloc_block == block)
goal = UDF_I(inode)->i_next_alloc_goal; goal = iinfo->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(inode)-> goal = iinfo->i_location.logicalBlockNum + 1;
i_location.logicalBlockNum + 1;
} }
newblocknum = udf_new_block(inode->i_sb, inode, newblocknum = udf_new_block(inode->i_sb, inode,
UDF_I(inode)->i_location.partitionReferenceNum, iinfo->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(inode)->i_lenExtents += inode->i_sb->s_blocksize; iinfo->i_lenExtents += inode->i_sb->s_blocksize;
} }
/* if the extent the requsted block is located in contains multiple /* if the extent the requsted block is located in contains multiple
@ -691,14 +699,14 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
brelse(prev_epos.bh); brelse(prev_epos.bh);
newblock = udf_get_pblock(inode->i_sb, newblocknum, newblock = udf_get_pblock(inode->i_sb, newblocknum,
UDF_I(inode)->i_location.partitionReferenceNum, 0); iinfo->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(inode)->i_next_alloc_block = block; iinfo->i_next_alloc_block = block;
UDF_I(inode)->i_next_alloc_goal = newblocknum; iinfo->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))
@ -1027,6 +1035,7 @@ void udf_truncate(struct inode *inode)
{ {
int offset; int offset;
int err; int err;
struct udf_inode_info *iinfo;
if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
S_ISLNK(inode->i_mode))) S_ISLNK(inode->i_mode)))
@ -1035,25 +1044,24 @@ void udf_truncate(struct inode *inode)
return; return;
lock_kernel(); lock_kernel();
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { iinfo = UDF_I(inode);
if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
if (inode->i_sb->s_blocksize < 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(inode)->i_alloc_type == if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
ICBTAG_FLAG_AD_IN_ICB) { inode->i_size = iinfo->i_lenAlloc;
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(inode)->i_ext.i_data + memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,
UDF_I(inode)->i_lenEAttr + offset,
0x00, inode->i_sb->s_blocksize - 0x00, inode->i_sb->s_blocksize -
offset - udf_file_entry_alloc_offset(inode)); offset - udf_file_entry_alloc_offset(inode));
UDF_I(inode)->i_lenAlloc = inode->i_size; iinfo->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,
@ -1074,6 +1082,7 @@ static void __udf_read_inode(struct inode *inode)
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
struct fileEntry *fe; struct fileEntry *fe;
uint16_t ident; uint16_t ident;
struct udf_inode_info *iinfo = UDF_I(inode);
/* /*
* Set defaults, but the inode is still incomplete! * Set defaults, but the inode is still incomplete!
@ -1087,7 +1096,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(inode)->i_location, 0, &ident); bh = udf_read_ptagged(inode->i_sb, iinfo->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);
@ -1110,7 +1119,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(inode)->i_location, 1, ibh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 1,
&ident); &ident);
if (ident == TAG_IDENT_IE) { if (ident == TAG_IDENT_IE) {
if (ibh) { if (ibh) {
@ -1124,7 +1133,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(inode)->i_location, memcpy(&iinfo->i_location,
&loc, &loc,
sizeof(kernel_lb_addr)); sizeof(kernel_lb_addr));
brelse(bh); brelse(bh);
@ -1163,50 +1172,51 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
long convtime_usec; long convtime_usec;
int offset; int offset;
struct udf_sb_info *sbi = UDF_SB(inode->i_sb); struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
struct udf_inode_info *iinfo = UDF_I(inode);
fe = (struct fileEntry *)bh->b_data; fe = (struct fileEntry *)bh->b_data;
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(inode)->i_strat4096 = 0; iinfo->i_strat4096 = 0;
else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */ else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
UDF_I(inode)->i_strat4096 = 1; iinfo->i_strat4096 = 1;
UDF_I(inode)->i_alloc_type = le16_to_cpu(fe->icbTag.flags) & iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
ICBTAG_FLAG_AD_MASK; ICBTAG_FLAG_AD_MASK;
UDF_I(inode)->i_unique = 0; iinfo->i_unique = 0;
UDF_I(inode)->i_lenEAttr = 0; iinfo->i_lenEAttr = 0;
UDF_I(inode)->i_lenExtents = 0; iinfo->i_lenExtents = 0;
UDF_I(inode)->i_lenAlloc = 0; iinfo->i_lenAlloc = 0;
UDF_I(inode)->i_next_alloc_block = 0; iinfo->i_next_alloc_block = 0;
UDF_I(inode)->i_next_alloc_goal = 0; iinfo->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(inode)->i_efe = 1; iinfo->i_efe = 1;
UDF_I(inode)->i_use = 0; iinfo->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(inode)->i_ext.i_data, memcpy(iinfo->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(inode)->i_efe = 0; iinfo->i_efe = 0;
UDF_I(inode)->i_use = 0; iinfo->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(inode)->i_ext.i_data, memcpy(iinfo->i_ext.i_data,
bh->b_data + sizeof(struct fileEntry), 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(inode)->i_efe = 0; iinfo->i_efe = 0;
UDF_I(inode)->i_use = 1; iinfo->i_use = 1;
UDF_I(inode)->i_lenAlloc = le32_to_cpu( iinfo->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 -
@ -1214,7 +1224,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(inode)->i_ext.i_data, memcpy(iinfo->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));
@ -1238,12 +1248,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(inode)->i_lenExtents = inode->i_size; iinfo->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(inode)->i_efe == 0) { if (iinfo->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);
@ -1271,10 +1281,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(inode)->i_unique = le64_to_cpu(fe->uniqueID); iinfo->i_unique = le64_to_cpu(fe->uniqueID);
UDF_I(inode)->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr); iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
UDF_I(inode)->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs); iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
offset = sizeof(struct fileEntry) + UDF_I(inode)->i_lenEAttr; offset = sizeof(struct fileEntry) + iinfo->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);
@ -1297,10 +1307,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(inode)->i_crtime.tv_sec = convtime; iinfo->i_crtime.tv_sec = convtime;
UDF_I(inode)->i_crtime.tv_nsec = convtime_usec * 1000; iinfo->i_crtime.tv_nsec = convtime_usec * 1000;
} else { } else {
UDF_I(inode)->i_crtime = sbi->s_record_time; iinfo->i_crtime = sbi->s_record_time;
} }
if (udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
@ -1311,11 +1321,11 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
inode->i_ctime = sbi->s_record_time; inode->i_ctime = sbi->s_record_time;
} }
UDF_I(inode)->i_unique = le64_to_cpu(efe->uniqueID); iinfo->i_unique = le64_to_cpu(efe->uniqueID);
UDF_I(inode)->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr); iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
UDF_I(inode)->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs); iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
offset = sizeof(struct extendedFileEntry) + offset = sizeof(struct extendedFileEntry) +
UDF_I(inode)->i_lenEAttr; iinfo->i_lenEAttr;
} }
switch (fe->icbTag.fileType) { switch (fe->icbTag.fileType) {
@ -1328,7 +1338,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
case ICBTAG_FILE_TYPE_REALTIME: case ICBTAG_FILE_TYPE_REALTIME:
case ICBTAG_FILE_TYPE_REGULAR: case ICBTAG_FILE_TYPE_REGULAR:
case ICBTAG_FILE_TYPE_UNDEF: case ICBTAG_FILE_TYPE_UNDEF:
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
inode->i_data.a_ops = &udf_adinicb_aops; inode->i_data.a_ops = &udf_adinicb_aops;
else else
inode->i_data.a_ops = &udf_aops; inode->i_data.a_ops = &udf_aops;
@ -1375,9 +1385,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
static int udf_alloc_i_data(struct inode *inode, size_t size) static int udf_alloc_i_data(struct inode *inode, size_t size)
{ {
UDF_I(inode)->i_ext.i_data = kmalloc(size, GFP_KERNEL); struct udf_inode_info *iinfo = UDF_I(inode);
iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
if (!UDF_I(inode)->i_ext.i_data) { if (!iinfo->i_ext.i_data) {
printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) " 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;
@ -1448,10 +1459,11 @@ static int udf_update_inode(struct inode *inode, int do_sync)
int err = 0; int err = 0;
struct udf_sb_info *sbi = UDF_SB(inode->i_sb); struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
struct udf_inode_info *iinfo = UDF_I(inode);
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(inode)->i_location, 0)); iinfo->i_location, 0));
if (!bh) { if (!bh) {
udf_debug("bread failure\n"); udf_debug("bread failure\n");
return -EIO; return -EIO;
@ -1466,14 +1478,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(inode)->i_lenAlloc); use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
UDF_I(inode)->i_ext.i_data, inode->i_sb->s_blocksize - iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
sizeof(struct unallocSpaceEntry)); sizeof(struct unallocSpaceEntry));
crclen = sizeof(struct unallocSpaceEntry) + crclen = sizeof(struct unallocSpaceEntry) +
UDF_I(inode)->i_lenAlloc - sizeof(tag); iinfo->i_lenAlloc - sizeof(tag);
use->descTag.tagLocation = cpu_to_le32( use->descTag.tagLocation = cpu_to_le32(
UDF_I(inode)->i_location. iinfo->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 +
@ -1538,9 +1550,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(inode)->i_efe == 0) { if (iinfo->i_efe == 0) {
memcpy(bh->b_data + sizeof(struct fileEntry), memcpy(bh->b_data + sizeof(struct fileEntry),
UDF_I(inode)->i_ext.i_data, iinfo->i_ext.i_data,
inode->i_sb->s_blocksize - sizeof(struct fileEntry)); 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) >>
@ -1556,14 +1568,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(inode)->i_unique); fe->uniqueID = cpu_to_le64(iinfo->i_unique);
fe->lengthExtendedAttr = cpu_to_le32(UDF_I(inode)->i_lenEAttr); fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
fe->lengthAllocDescs = cpu_to_le32(UDF_I(inode)->i_lenAlloc); fe->lengthAllocDescs = cpu_to_le32(iinfo->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(inode)->i_ext.i_data, iinfo->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);
@ -1571,26 +1583,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(inode)->i_crtime.tv_sec > inode->i_atime.tv_sec || if (iinfo->i_crtime.tv_sec > inode->i_atime.tv_sec ||
(UDF_I(inode)->i_crtime.tv_sec == inode->i_atime.tv_sec && (iinfo->i_crtime.tv_sec == inode->i_atime.tv_sec &&
UDF_I(inode)->i_crtime.tv_nsec > inode->i_atime.tv_nsec)) iinfo->i_crtime.tv_nsec > inode->i_atime.tv_nsec))
UDF_I(inode)->i_crtime = inode->i_atime; iinfo->i_crtime = inode->i_atime;
if (UDF_I(inode)->i_crtime.tv_sec > inode->i_mtime.tv_sec || if (iinfo->i_crtime.tv_sec > inode->i_mtime.tv_sec ||
(UDF_I(inode)->i_crtime.tv_sec == inode->i_mtime.tv_sec && (iinfo->i_crtime.tv_sec == inode->i_mtime.tv_sec &&
UDF_I(inode)->i_crtime.tv_nsec > inode->i_mtime.tv_nsec)) iinfo->i_crtime.tv_nsec > inode->i_mtime.tv_nsec))
UDF_I(inode)->i_crtime = inode->i_mtime; iinfo->i_crtime = inode->i_mtime;
if (UDF_I(inode)->i_crtime.tv_sec > inode->i_ctime.tv_sec || if (iinfo->i_crtime.tv_sec > inode->i_ctime.tv_sec ||
(UDF_I(inode)->i_crtime.tv_sec == inode->i_ctime.tv_sec && (iinfo->i_crtime.tv_sec == inode->i_ctime.tv_sec &&
UDF_I(inode)->i_crtime.tv_nsec > inode->i_ctime.tv_nsec)) iinfo->i_crtime.tv_nsec > inode->i_ctime.tv_nsec))
UDF_I(inode)->i_crtime = inode->i_ctime; iinfo->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(inode)->i_crtime)) if (udf_time_to_stamp(&cpu_time, iinfo->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);
@ -1599,13 +1611,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(inode)->i_unique); efe->uniqueID = cpu_to_le64(iinfo->i_unique);
efe->lengthExtendedAttr = cpu_to_le32(UDF_I(inode)->i_lenEAttr); efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
efe->lengthAllocDescs = cpu_to_le32(UDF_I(inode)->i_lenAlloc); efe->lengthAllocDescs = cpu_to_le32(iinfo->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(inode)->i_strat4096) { if (iinfo->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);
@ -1629,7 +1641,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(inode)->i_alloc_type | icbflags = iinfo->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) |
@ -1644,8 +1656,8 @@ 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(inode)->i_location.logicalBlockNum); iinfo->i_location.logicalBlockNum);
crclen += UDF_I(inode)->i_lenEAttr + UDF_I(inode)->i_lenAlloc - crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc -
sizeof(tag); 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),
@ -1709,17 +1721,18 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
struct allocExtDesc *aed; struct allocExtDesc *aed;
int8_t etype; int8_t etype;
uint8_t *ptr; uint8_t *ptr;
struct udf_inode_info *iinfo = UDF_I(inode);
if (!epos->bh) if (!epos->bh)
ptr = UDF_I(inode)->i_ext.i_data + epos->offset - ptr = iinfo->i_ext.i_data + epos->offset -
udf_file_entry_alloc_offset(inode) + udf_file_entry_alloc_offset(inode) +
UDF_I(inode)->i_lenEAttr; iinfo->i_lenEAttr;
else else
ptr = epos->bh->b_data + epos->offset; ptr = epos->bh->b_data + epos->offset;
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); adsize = sizeof(long_ad);
else else
return -1; return -1;
@ -1769,7 +1782,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(inode)->i_lenAlloc += adsize; iinfo->i_lenAlloc += adsize;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} }
} }
@ -1779,7 +1792,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(inode)->i_alloc_type) { switch (iinfo->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 |
@ -1813,7 +1826,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
etype = udf_write_aext(inode, epos, eloc, elen, inc); etype = udf_write_aext(inode, epos, eloc, elen, inc);
if (!epos->bh) { if (!epos->bh) {
UDF_I(inode)->i_lenAlloc += adsize; iinfo->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;
@ -1840,15 +1853,16 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
uint8_t *ptr; uint8_t *ptr;
short_ad *sad; short_ad *sad;
long_ad *lad; long_ad *lad;
struct udf_inode_info *iinfo = UDF_I(inode);
if (!epos->bh) if (!epos->bh)
ptr = UDF_I(inode)->i_ext.i_data + epos->offset - ptr = iinfo->i_ext.i_data + epos->offset -
udf_file_entry_alloc_offset(inode) + udf_file_entry_alloc_offset(inode) +
UDF_I(inode)->i_lenEAttr; iinfo->i_lenEAttr;
else else
ptr = epos->bh->b_data + epos->offset; ptr = epos->bh->b_data + epos->offset;
switch (UDF_I(inode)->i_alloc_type) { switch (iinfo->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);
@ -1916,15 +1930,16 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
uint8_t *ptr; uint8_t *ptr;
short_ad *sad; short_ad *sad;
long_ad *lad; long_ad *lad;
struct udf_inode_info *iinfo = UDF_I(inode);
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(inode)->i_ext.i_data + epos->offset - ptr = iinfo->i_ext.i_data + epos->offset -
udf_file_entry_alloc_offset(inode) + udf_file_entry_alloc_offset(inode) +
UDF_I(inode)->i_lenEAttr; iinfo->i_lenEAttr;
alen = udf_file_entry_alloc_offset(inode) + alen = udf_file_entry_alloc_offset(inode) +
UDF_I(inode)->i_lenAlloc; iinfo->i_lenAlloc;
} else { } else {
if (!epos->offset) if (!epos->offset)
epos->offset = sizeof(struct allocExtDesc); epos->offset = sizeof(struct allocExtDesc);
@ -1934,7 +1949,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
lengthAllocDescs); lengthAllocDescs);
} }
switch (UDF_I(inode)->i_alloc_type) { switch (iinfo->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)
@ -1942,7 +1957,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(inode)->i_location.partitionReferenceNum; iinfo->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:
@ -1955,7 +1970,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(inode)->i_alloc_type); iinfo->i_alloc_type);
return -1; return -1;
} }
@ -1990,15 +2005,17 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
int adsize; int adsize;
int8_t etype; int8_t etype;
struct allocExtDesc *aed; struct allocExtDesc *aed;
struct udf_inode_info *iinfo;
if (epos.bh) { if (epos.bh) {
get_bh(epos.bh); get_bh(epos.bh);
get_bh(epos.bh); get_bh(epos.bh);
} }
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) iinfo = UDF_I(inode);
if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); adsize = sizeof(long_ad);
else else
adsize = 0; adsize = 0;
@ -2025,7 +2042,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
udf_write_aext(inode, &oepos, eloc, elen, 1); udf_write_aext(inode, &oepos, eloc, elen, 1);
udf_write_aext(inode, &oepos, eloc, elen, 1); udf_write_aext(inode, &oepos, eloc, elen, 1);
if (!oepos.bh) { if (!oepos.bh) {
UDF_I(inode)->i_lenAlloc -= (adsize * 2); iinfo->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;
@ -2044,7 +2061,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(inode)->i_lenAlloc -= adsize; iinfo->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;
@ -2076,14 +2093,16 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
loff_t lbcount = 0, bcount = loff_t lbcount = 0, bcount =
(loff_t) block << blocksize_bits; (loff_t) block << blocksize_bits;
int8_t etype; int8_t etype;
struct udf_inode_info *iinfo;
if (block < 0) { if (block < 0) {
printk(KERN_ERR "udf: inode_bmap: block < 0\n"); printk(KERN_ERR "udf: inode_bmap: block < 0\n");
return -1; return -1;
} }
iinfo = UDF_I(inode);
pos->offset = 0; pos->offset = 0;
pos->block = UDF_I(inode)->i_location; pos->block = iinfo->i_location;
pos->bh = NULL; pos->bh = NULL;
*elen = 0; *elen = 0;
@ -2091,7 +2110,7 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
etype = udf_next_aext(inode, pos, eloc, elen, 1); 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(inode)->i_lenExtents = lbcount; iinfo->i_lenExtents = lbcount;
return -1; return -1;
} }
lbcount += *elen; lbcount += *elen;

40
fs/udf/misc.c
View File

@ -51,17 +51,18 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
uint8_t *ea = NULL, *ad = NULL; uint8_t *ea = NULL, *ad = NULL;
int offset; int offset;
uint16_t crclen; uint16_t crclen;
struct udf_inode_info *iinfo = UDF_I(inode);
ea = UDF_I(inode)->i_ext.i_data; ea = iinfo->i_ext.i_data;
if (UDF_I(inode)->i_lenEAttr) { if (iinfo->i_lenEAttr) {
ad = UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr; ad = iinfo->i_ext.i_data + iinfo->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(inode)->i_lenAlloc; iinfo->i_lenAlloc;
/* TODO - Check for FreeEASpace */ /* TODO - Check for FreeEASpace */
@ -69,21 +70,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(inode)->i_lenAlloc) if (iinfo->i_lenAlloc)
memmove(&ad[size], ad, UDF_I(inode)->i_lenAlloc); memmove(&ad[size], ad, iinfo->i_lenAlloc);
if (UDF_I(inode)->i_lenEAttr) { if (iinfo->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(inode)->i_location.logicalBlockNum) iinfo->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(inode)->i_lenEAttr += iinfo->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 +94,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(inode)->i_location.logicalBlockNum); iinfo->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(inode)->i_lenEAttr; offset = iinfo->i_lenEAttr;
if (type < 2048) { if (type < 2048) {
if (le32_to_cpu(eahd->appAttrLocation) < if (le32_to_cpu(eahd->appAttrLocation) <
UDF_I(inode)->i_lenEAttr) { iinfo->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 +112,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(inode)->i_lenEAttr) { iinfo->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 +123,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(inode)->i_lenEAttr) { iinfo->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 +139,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(inode)->i_lenEAttr += size; iinfo->i_lenEAttr += size;
return (struct genericFormat *)&ea[offset]; return (struct genericFormat *)&ea[offset];
} }
if (loc & 0x02) if (loc & 0x02)
@ -153,10 +154,11 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
struct genericFormat *gaf; struct genericFormat *gaf;
uint8_t *ea = NULL; uint8_t *ea = NULL;
uint32_t offset; uint32_t offset;
struct udf_inode_info *iinfo = UDF_I(inode);
ea = UDF_I(inode)->i_ext.i_data; ea = iinfo->i_ext.i_data;
if (UDF_I(inode)->i_lenEAttr) { if (iinfo->i_lenEAttr) {
struct extendedAttrHeaderDesc *eahd; struct extendedAttrHeaderDesc *eahd;
eahd = (struct extendedAttrHeaderDesc *)ea; eahd = (struct extendedAttrHeaderDesc *)ea;
@ -164,7 +166,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(inode)->i_location.logicalBlockNum) iinfo->i_location.logicalBlockNum)
return NULL; return NULL;
if (type < 2048) if (type < 2048)
@ -174,7 +176,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(inode)->i_lenEAttr) { while (offset < iinfo->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)

112
fs/udf/namei.c
View File

@ -158,23 +158,23 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
uint32_t elen; uint32_t elen;
sector_t offset; sector_t offset;
struct extent_position epos = {}; struct extent_position epos = {};
struct udf_inode_info *dinfo = UDF_I(dir);
size = (udf_ext0_offset(dir) + dir->i_size) >> 2; size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
f_pos = (udf_ext0_offset(dir) >> 2); f_pos = (udf_ext0_offset(dir) >> 2);
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(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) if (dinfo->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(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad); epos.offset -= sizeof(short_ad);
else if (UDF_I(dir)->i_alloc_type == else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad); epos.offset -= sizeof(long_ad);
} else } else
offset = 0; offset = 0;
@ -351,6 +351,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
uint32_t elen; uint32_t elen;
sector_t offset; sector_t offset;
struct extent_position epos = {}; struct extent_position epos = {};
struct udf_inode_info *dinfo;
if (dentry) { if (dentry) {
if (!dentry->d_name.len) { if (!dentry->d_name.len) {
@ -373,17 +374,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(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) dinfo = UDF_I(dir);
if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
fibh->sbh = fibh->ebh = NULL; 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(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad); epos.offset -= sizeof(short_ad);
else if (UDF_I(dir)->i_alloc_type == else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad); epos.offset -= sizeof(long_ad);
} else } else
offset = 0; offset = 0;
@ -395,10 +396,10 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
return NULL; return NULL;
} }
block = UDF_I(dir)->i_location.logicalBlockNum; block = dinfo->i_location.logicalBlockNum;
} else { } else {
block = udf_get_lb_pblock(dir->i_sb, UDF_I(dir)->i_location, 0); block = udf_get_lb_pblock(dir->i_sb, dinfo->i_location, 0);
fibh->sbh = fibh->ebh = NULL; fibh->sbh = fibh->ebh = NULL;
fibh->soffset = fibh->eoffset = sb->s_blocksize; fibh->soffset = fibh->eoffset = sb->s_blocksize;
goto add; goto add;
@ -477,7 +478,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
add: add:
f_pos += nfidlen; f_pos += nfidlen;
if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB && if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
sb->s_blocksize - fibh->eoffset < nfidlen) { sb->s_blocksize - fibh->eoffset < nfidlen) {
brelse(epos.bh); brelse(epos.bh);
epos.bh = NULL; epos.bh = NULL;
@ -491,15 +492,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(dir)->i_location; epos.block = dinfo->i_location;
eloc.logicalBlockNum = block; eloc.logicalBlockNum = block;
eloc.partitionReferenceNum = eloc.partitionReferenceNum =
UDF_I(dir)->i_location.partitionReferenceNum; dinfo->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(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
epos.offset += sizeof(short_ad); epos.offset += sizeof(short_ad);
else if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
epos.offset += sizeof(long_ad); epos.offset += sizeof(long_ad);
} }
@ -511,13 +512,13 @@ add:
fibh->sbh = fibh->ebh; fibh->sbh = fibh->ebh;
} }
if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
block = UDF_I(dir)->i_location.logicalBlockNum; block = dinfo->i_location.logicalBlockNum;
fi = (struct fileIdentDesc *) fi = (struct fileIdentDesc *)
(UDF_I(dir)->i_ext.i_data + (dinfo->i_ext.i_data +
fibh->soffset - fibh->soffset -
udf_ext0_offset(dir) + udf_ext0_offset(dir) +
UDF_I(dir)->i_lenEAttr); dinfo->i_lenEAttr);
} else { } else {
block = eloc.logicalBlockNum + block = eloc.logicalBlockNum +
((elen - 1) >> ((elen - 1) >>
@ -575,8 +576,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(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
UDF_I(dir)->i_lenAlloc += nfidlen; dinfo->i_lenAlloc += nfidlen;
mark_inode_dirty(dir); mark_inode_dirty(dir);
return fi; return fi;
} else { } else {
@ -608,6 +609,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
struct inode *inode; struct inode *inode;
struct fileIdentDesc cfi, *fi; struct fileIdentDesc cfi, *fi;
int err; int err;
struct udf_inode_info *iinfo;
lock_kernel(); lock_kernel();
inode = udf_new_inode(dir, mode, &err); inode = udf_new_inode(dir, mode, &err);
@ -616,7 +618,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
return err; return err;
} }
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) iinfo = UDF_I(inode);
if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
inode->i_data.a_ops = &udf_adinicb_aops; inode->i_data.a_ops = &udf_adinicb_aops;
else else
inode->i_data.a_ops = &udf_aops; inode->i_data.a_ops = &udf_aops;
@ -634,9 +637,9 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
return err; 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(inode)->i_location); cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL); cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I(dir)->i_alloc_type == 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);
@ -656,6 +659,7 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct fileIdentDesc cfi, *fi; struct fileIdentDesc cfi, *fi;
int err; int err;
struct udf_inode_info *iinfo;
if (!old_valid_dev(rdev)) if (!old_valid_dev(rdev))
return -EINVAL; return -EINVAL;
@ -666,6 +670,7 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
if (!inode) if (!inode)
goto out; goto out;
iinfo = UDF_I(inode);
inode->i_uid = current->fsuid; inode->i_uid = current->fsuid;
init_special_inode(inode, mode, rdev); init_special_inode(inode, mode, rdev);
fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
@ -677,9 +682,9 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
return err; 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(inode)->i_location); cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL); cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I(dir)->i_alloc_type == 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);
@ -702,6 +707,8 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct fileIdentDesc cfi, *fi; struct fileIdentDesc cfi, *fi;
int err; int err;
struct udf_inode_info *dinfo = UDF_I(dir);
struct udf_inode_info *iinfo;
lock_kernel(); lock_kernel();
err = -EMLINK; err = -EMLINK;
@ -713,6 +720,7 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
if (!inode) if (!inode)
goto out; goto out;
iinfo = UDF_I(inode);
inode->i_op = &udf_dir_inode_operations; inode->i_op = &udf_dir_inode_operations;
inode->i_fop = &udf_dir_operations; inode->i_fop = &udf_dir_operations;
fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err); fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
@ -724,9 +732,9 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
} }
inode->i_nlink = 2; 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(dir)->i_location); cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I(dir)->i_unique & 0x00000000FFFFFFFFUL); cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL);
cfi.fileCharacteristics = 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);
@ -744,9 +752,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(inode)->i_location); cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I(inode)->i_unique & 0x00000000FFFFFFFFUL); cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY; 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);
@ -773,23 +781,23 @@ static int empty_dir(struct inode *dir)
uint32_t elen; uint32_t elen;
sector_t offset; sector_t offset;
struct extent_position epos = {}; struct extent_position epos = {};
struct udf_inode_info *dinfo = UDF_I(dir);
f_pos = (udf_ext0_offset(dir) >> 2); f_pos = (udf_ext0_offset(dir) >> 2);
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(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) if (dinfo->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(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad); epos.offset -= sizeof(short_ad);
else if (UDF_I(dir)->i_alloc_type == else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad); epos.offset -= sizeof(long_ad);
} else } else
offset = 0; offset = 0;
@ -939,38 +947,40 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
char name[UDF_NAME_LEN]; char name[UDF_NAME_LEN];
int namelen; int namelen;
struct buffer_head *bh; struct buffer_head *bh;
struct udf_inode_info *iinfo;
lock_kernel(); lock_kernel();
inode = udf_new_inode(dir, S_IFLNK, &err); inode = udf_new_inode(dir, S_IFLNK, &err);
if (!inode) if (!inode)
goto out; goto out;
iinfo = UDF_I(inode);
inode->i_mode = S_IFLNK | S_IRWXUGO; inode->i_mode = S_IFLNK | S_IRWXUGO;
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(inode)->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { if (iinfo->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(inode)->i_location.partitionReferenceNum, iinfo->i_location.partitionReferenceNum,
UDF_I(inode)->i_location.logicalBlockNum, &err); iinfo->i_location.logicalBlockNum, &err);
if (!block) if (!block)
goto out_no_entry; goto out_no_entry;
epos.block = UDF_I(inode)->i_location; epos.block = iinfo->i_location;
epos.offset = udf_file_entry_alloc_offset(inode); epos.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(inode)->i_location.partitionReferenceNum; iinfo->i_location.partitionReferenceNum;
elen = inode->i_sb->s_blocksize; elen = inode->i_sb->s_blocksize;
UDF_I(inode)->i_lenExtents = elen; iinfo->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(inode)->i_location.partitionReferenceNum, iinfo->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);
@ -979,9 +989,8 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
unlock_buffer(epos.bh); unlock_buffer(epos.bh);
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(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr; ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
}
eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode); eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
pc = (struct pathComponent *)ea; pc = (struct pathComponent *)ea;
@ -1049,15 +1058,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(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
UDF_I(inode)->i_lenAlloc = inode->i_size; iinfo->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(inode)->i_location); cfi.icb.extLocation = cpu_to_lelb(iinfo->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 =
@ -1162,6 +1171,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
struct buffer_head *dir_bh = NULL; struct buffer_head *dir_bh = NULL;
int retval = -ENOENT; int retval = -ENOENT;
kernel_lb_addr tloc; kernel_lb_addr tloc;
struct udf_inode_info *old_iinfo = UDF_I(old_inode);
lock_kernel(); lock_kernel();
ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi); ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi);
@ -1193,10 +1203,10 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
goto end_rename; goto end_rename;
} }
retval = -EIO; retval = -EIO;
if (UDF_I(old_inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
dir_fi = udf_get_fileident( dir_fi = udf_get_fileident(
UDF_I(old_inode)->i_ext.i_data - old_iinfo->i_ext.i_data -
(UDF_I(old_inode)->i_efe ? (old_iinfo->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);
@ -1258,7 +1268,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
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(old_inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
mark_inode_dirty(old_inode); mark_inode_dirty(old_inode);
else else
mark_buffer_dirty_inode(dir_bh, old_inode); mark_buffer_dirty_inode(dir_bh, old_inode);

8
fs/udf/partition.c
View File

@ -55,6 +55,7 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
struct udf_part_map *map; struct udf_part_map *map;
struct udf_virtual_data *vdata; struct udf_virtual_data *vdata;
struct udf_inode_info *iinfo;
map = &sbi->s_partmaps[partition]; map = &sbi->s_partmaps[partition];
vdata = &map->s_type_specific.s_virtual; vdata = &map->s_type_specific.s_virtual;
@ -88,15 +89,14 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
brelse(bh); brelse(bh);
if (UDF_I(sbi->s_vat_inode)->i_location.partitionReferenceNum == iinfo = UDF_I(sbi->s_vat_inode);
partition) { if (iinfo->i_location.partitionReferenceNum == 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(sbi->s_vat_inode)->i_location. iinfo->i_location.partitionReferenceNum,
partitionReferenceNum,
offset); offset);
} }

6
fs/udf/symlink.c
View File

@ -79,10 +79,12 @@ static int udf_symlink_filler(struct file *file, struct page *page)
char *symlink; char *symlink;
int err = -EIO; int err = -EIO;
char *p = kmap(page); char *p = kmap(page);
struct udf_inode_info *iinfo;
lock_kernel(); lock_kernel();
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { iinfo = UDF_I(inode);
symlink = UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr; if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
symlink = iinfo->i_ext.i_data + iinfo->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));

37
fs/udf/truncate.c
View File

@ -74,17 +74,18 @@ void udf_truncate_tail_extent(struct inode *inode)
uint64_t lbcount = 0; uint64_t lbcount = 0;
int8_t etype = -1, netype; int8_t etype = -1, netype;
int adsize; int adsize;
struct udf_inode_info *iinfo = UDF_I(inode);
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB || if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
inode->i_size == UDF_I(inode)->i_lenExtents) inode->i_size == iinfo->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(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); adsize = sizeof(long_ad);
else else
BUG(); BUG();
@ -117,7 +118,7 @@ void udf_truncate_tail_extent(struct inode *inode)
} }
/* This inode entry is in-memory only and thus we don't have to mark /* This inode entry is in-memory only and thus we don't have to mark
* the inode dirty */ * the inode dirty */
UDF_I(inode)->i_lenExtents = inode->i_size; iinfo->i_lenExtents = inode->i_size;
brelse(epos.bh); brelse(epos.bh);
} }
@ -129,19 +130,20 @@ void udf_discard_prealloc(struct inode *inode)
uint64_t lbcount = 0; uint64_t lbcount = 0;
int8_t etype = -1, netype; int8_t etype = -1, netype;
int adsize; int adsize;
struct udf_inode_info *iinfo = UDF_I(inode);
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB || if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
inode->i_size == UDF_I(inode)->i_lenExtents) inode->i_size == iinfo->i_lenExtents)
return; return;
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); adsize = sizeof(long_ad);
else else
adsize = 0; adsize = 0;
epos.block = UDF_I(inode)->i_location; epos.block = iinfo->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 +155,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(inode)->i_lenAlloc = iinfo->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 +176,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(inode)->i_lenExtents = lbcount; iinfo->i_lenExtents = lbcount;
brelse(epos.bh); brelse(epos.bh);
} }
@ -189,10 +191,11 @@ void udf_truncate_extents(struct inode *inode)
sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset; sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;
loff_t byte_offset; loff_t byte_offset;
int adsize; int adsize;
struct udf_inode_info *iinfo = UDF_I(inode);
if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG) else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); adsize = sizeof(long_ad);
else else
BUG(); BUG();
@ -227,7 +230,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(inode)->i_lenAlloc = iinfo->i_lenAlloc =
lenalloc; lenalloc;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} else { } else {
@ -275,7 +278,7 @@ void udf_truncate_extents(struct inode *inode)
indirect_ext_len); indirect_ext_len);
} else { } else {
if (!epos.bh) { if (!epos.bh) {
UDF_I(inode)->i_lenAlloc = lenalloc; iinfo->i_lenAlloc = lenalloc;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} else { } else {
struct allocExtDesc *aed = struct allocExtDesc *aed =
@ -325,7 +328,7 @@ void udf_truncate_extents(struct inode *inode)
(sb->s_blocksize - 1)) != 0)); (sb->s_blocksize - 1)) != 0));
} }
} }
UDF_I(inode)->i_lenExtents = inode->i_size; iinfo->i_lenExtents = inode->i_size;
brelse(epos.bh); brelse(epos.bh);
} }