openharmony/kernel_linux
1
0
Fork 0
mirror of https://gitee.com/openharmony/kernel_linux synced 2025-01-25 11:25:11 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

UDF: coding style conversion - lindent fixups

Browse Source 
This patch fixes up sources after conversion by Lindent.

Signed-off-by: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Jan Kara <jack@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Cyrill Gorcunov 2007-07-21 04:37:18 -07:00 committed by Linus Torvalds
parent 71133027fe
commit 28de7948a8
23 changed files with 1912 additions and 2704 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

420
fs/udf/balloc.c
View File

@ -70,9 +70,9 @@ static inline int find_next_one_bit(void *addr, int size, int offset)
if (!size)
return result;
tmp = leBPL_to_cpup(p);
found_first:
found_first:
tmp &= ~0UL >> (BITS_PER_LONG - size);
found_middle:
found_middle:
return result + ffz(~tmp);
}
@ -110,11 +110,11 @@ static int __load_block_bitmap(struct super_block *sb,
nr_groups);
}
if (bitmap->s_block_bitmap[block_group])
if (bitmap->s_block_bitmap[block_group]) {
return block_group;
else {
retval =
read_block_bitmap(sb, bitmap, block_group, block_group);
} else {
retval = read_block_bitmap(sb, bitmap, block_group,
block_group);
if (retval < 0)
return retval;
return block_group;
@ -155,22 +155,16 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
mutex_lock(&sbi->s_alloc_mutex);
if (bloc.logicalBlockNum < 0 ||
(bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb,
bloc.
partitionReferenceNum))
{
udf_debug("%d < %d || %d + %d > %d\n", bloc.logicalBlockNum, 0,
bloc.logicalBlockNum, count, UDF_SB_PARTLEN(sb,
bloc.
partitionReferenceNum));
(bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
udf_debug("%d < %d || %d + %d > %d\n",
bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
goto error_return;
}
block =
bloc.logicalBlockNum + offset +
(sizeof(struct spaceBitmapDesc) << 3);
block = bloc.logicalBlockNum + offset + (sizeof(struct spaceBitmapDesc) << 3);
do_more:
do_more:
overflow = 0;
block_group = block >> (sb->s_blocksize_bits + 3);
bit = block % (sb->s_blocksize << 3);
@ -190,18 +184,13 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
for (i = 0; i < count; i++) {
if (udf_set_bit(bit + i, bh->b_data)) {
udf_debug("bit %ld already set\n", bit + i);
udf_debug("byte=%2x\n",
((char *)bh->b_data)[(bit + i) >> 3]);
udf_debug("byte=%2x\n", ((char *)bh->b_data)[(bit + i) >> 3]);
} else {
if (inode)
DQUOT_FREE_BLOCK(inode, 1);
if (UDF_SB_LVIDBH(sb)) {
UDF_SB_LVID(sb)->
freeSpaceTable[UDF_SB_PARTITION(sb)] =
cpu_to_le32(le32_to_cpu
(UDF_SB_LVID(sb)->
freeSpaceTable[UDF_SB_PARTITION
(sb)]) + 1);
UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + 1);
}
}
}
@ -211,7 +200,7 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
count = overflow;
goto do_more;
}
error_return:
error_return:
sb->s_dirt = 1;
if (UDF_SB_LVIDBH(sb))
mark_buffer_dirty(UDF_SB_LVIDBH(sb));
@ -238,7 +227,7 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
if (first_block + block_count > UDF_SB_PARTLEN(sb, partition))
block_count = UDF_SB_PARTLEN(sb, partition) - first_block;
repeat:
repeat:
nr_groups = (UDF_SB_PARTLEN(sb, partition) +
(sizeof(struct spaceBitmapDesc) << 3) +
(sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
@ -254,11 +243,11 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
bit = block % (sb->s_blocksize << 3);
while (bit < (sb->s_blocksize << 3) && block_count > 0) {
if (!udf_test_bit(bit, bh->b_data))
if (!udf_test_bit(bit, bh->b_data)) {
goto out;
else if (DQUOT_PREALLOC_BLOCK(inode, 1))
} else if (DQUOT_PREALLOC_BLOCK(inode, 1)) {
goto out;
else if (!udf_clear_bit(bit, bh->b_data)) {
} else if (!udf_clear_bit(bit, bh->b_data)) {
udf_debug("bit already cleared for block %d\n", bit);
DQUOT_FREE_BLOCK(inode, 1);
goto out;
@ -271,12 +260,10 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
mark_buffer_dirty(bh);
if (block_count > 0)
goto repeat;
out:
out:
if (UDF_SB_LVIDBH(sb)) {
UDF_SB_LVID(sb)->freeSpaceTable[partition] =
cpu_to_le32(le32_to_cpu
(UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
alloc_count);
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
mark_buffer_dirty(UDF_SB_LVIDBH(sb));
}
sb->s_dirt = 1;
@ -299,7 +286,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
*err = -ENOSPC;
mutex_lock(&sbi->s_alloc_mutex);
repeat:
repeat:
if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
goal = 0;
@ -312,31 +299,27 @@ static int udf_bitmap_new_block(struct super_block *sb,
if (bitmap_nr < 0)
goto error_return;
bh = bitmap->s_block_bitmap[bitmap_nr];
ptr =
memscan((char *)bh->b_data + group_start, 0xFF,
sb->s_blocksize - group_start);
ptr = memscan((char *)bh->b_data + group_start, 0xFF,
sb->s_blocksize - group_start);
if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
bit = block % (sb->s_blocksize << 3);
if (udf_test_bit(bit, bh->b_data)) {
if (udf_test_bit(bit, bh->b_data))
goto got_block;
}
end_goal = (bit + 63) & ~63;
bit = udf_find_next_one_bit(bh->b_data, end_goal, bit);
if (bit < end_goal)
goto got_block;
ptr =
memscan((char *)bh->b_data + (bit >> 3), 0xFF,
sb->s_blocksize - ((bit + 7) >> 3));
ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF, sb->s_blocksize - ((bit + 7) >> 3));
newbit = (ptr - ((char *)bh->b_data)) << 3;
if (newbit < sb->s_blocksize << 3) {
bit = newbit;
goto search_back;
}
newbit =
udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
bit);
newbit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, bit);
if (newbit < sb->s_blocksize << 3) {
bit = newbit;
goto got_block;
@ -354,18 +337,16 @@ static int udf_bitmap_new_block(struct super_block *sb,
goto error_return;
bh = bitmap->s_block_bitmap[bitmap_nr];
if (i < nr_groups) {
ptr =
memscan((char *)bh->b_data + group_start, 0xFF,
sb->s_blocksize - group_start);
ptr = memscan((char *)bh->b_data + group_start, 0xFF,
sb->s_blocksize - group_start);
if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
bit = (ptr - ((char *)bh->b_data)) << 3;
break;
}
} else {
bit =
udf_find_next_one_bit((char *)bh->b_data,
sb->s_blocksize << 3,
group_start << 3);
bit = udf_find_next_one_bit((char *)bh->b_data,
sb->s_blocksize << 3,
group_start << 3);
if (bit < sb->s_blocksize << 3)
break;
}
@ -377,20 +358,17 @@ static int udf_bitmap_new_block(struct super_block *sb,
if (bit < sb->s_blocksize << 3)
goto search_back;
else
bit =
udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
group_start << 3);
bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, group_start << 3);
if (bit >= sb->s_blocksize << 3) {
mutex_unlock(&sbi->s_alloc_mutex);
return 0;
}
search_back:
for (i = 0;
i < 7 && bit > (group_start << 3)
&& udf_test_bit(bit - 1, bh->b_data); i++, bit--) ;
search_back:
for (i = 0; i < 7 && bit > (group_start << 3) && udf_test_bit(bit - 1, bh->b_data); i++, bit--)
; /* empty loop */
got_block:
got_block:
/*
* Check quota for allocation of this block.
@ -402,7 +380,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
}
newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
(sizeof(struct spaceBitmapDesc) << 3);
(sizeof(struct spaceBitmapDesc) << 3);
if (!udf_clear_bit(bit, bh->b_data)) {
udf_debug("bit already cleared for block %d\n", bit);
@ -413,9 +391,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
if (UDF_SB_LVIDBH(sb)) {
UDF_SB_LVID(sb)->freeSpaceTable[partition] =
cpu_to_le32(le32_to_cpu
(UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
1);
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
mark_buffer_dirty(UDF_SB_LVIDBH(sb));
}
sb->s_dirt = 1;
@ -423,7 +399,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
*err = 0;
return newblock;
error_return:
error_return:
*err = -EIO;
mutex_unlock(&sbi->s_alloc_mutex);
return 0;
@ -445,14 +421,10 @@ static void udf_table_free_blocks(struct super_block *sb,
mutex_lock(&sbi->s_alloc_mutex);
if (bloc.logicalBlockNum < 0 ||
(bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb,
bloc.
partitionReferenceNum))
{
udf_debug("%d < %d || %d + %d > %d\n", bloc.logicalBlockNum, 0,
bloc.logicalBlockNum, count, UDF_SB_PARTLEN(sb,
bloc.
partitionReferenceNum));
(bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
udf_debug("%d < %d || %d + %d > %d\n",
bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
goto error_return;
}
@ -462,9 +434,7 @@ static void udf_table_free_blocks(struct super_block *sb,
DQUOT_FREE_BLOCK(inode, count);
if (UDF_SB_LVIDBH(sb)) {
UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
cpu_to_le32(le32_to_cpu
(UDF_SB_LVID(sb)->
freeSpaceTable[UDF_SB_PARTITION(sb)]) + count);
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + count);
mark_buffer_dirty(UDF_SB_LVIDBH(sb));
}
@ -476,47 +446,28 @@ static void udf_table_free_blocks(struct super_block *sb,
epos.block = oepos.block = UDF_I_LOCATION(table);
epos.bh = oepos.bh = NULL;
while (count && (etype =
udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==
start)) {
if ((0x3FFFFFFF - elen) <
(count << sb->s_blocksize_bits)) {
count -=
((0x3FFFFFFF -
elen) >> sb->s_blocksize_bits);
start +=
((0x3FFFFFFF -
elen) >> sb->s_blocksize_bits);
elen =
(etype << 30) | (0x40000000 -
sb->s_blocksize);
while (count &&
(etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) == start)) {
if ((0x3FFFFFFF - elen) < (count << sb->s_blocksize_bits)) {
count -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
start += ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
elen = (etype << 30) | (0x40000000 - sb->s_blocksize);
} else {
elen = (etype << 30) |
(elen + (count << sb->s_blocksize_bits));
elen = (etype << 30) | (elen + (count << sb->s_blocksize_bits));
start += count;
count = 0;
}
udf_write_aext(table, &oepos, eloc, elen, 1);
} else if (eloc.logicalBlockNum == (end + 1)) {
if ((0x3FFFFFFF - elen) <
(count << sb->s_blocksize_bits)) {
count -=
((0x3FFFFFFF -
elen) >> sb->s_blocksize_bits);
end -=
((0x3FFFFFFF -
elen) >> sb->s_blocksize_bits);
eloc.logicalBlockNum -=
((0x3FFFFFFF -
elen) >> sb->s_blocksize_bits);
elen =
(etype << 30) | (0x40000000 -
sb->s_blocksize);
if ((0x3FFFFFFF - elen) < (count << sb->s_blocksize_bits)) {
count -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
end -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
eloc.logicalBlockNum -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
elen = (etype << 30) | (0x40000000 - sb->s_blocksize);
} else {
eloc.logicalBlockNum = start;
elen = (etype << 30) |
(elen + (count << sb->s_blocksize_bits));
elen = (etype << 30) | (elen + (count << sb->s_blocksize_bits));
end -= count;
count = 0;
}
@ -530,21 +481,23 @@ static void udf_table_free_blocks(struct super_block *sb,
get_bh(epos.bh);
oepos.bh = epos.bh;
oepos.offset = 0;
} else
} else {
oepos.offset = epos.offset;
}
}
if (count) {
/* NOTE: we CANNOT use udf_add_aext here, as it can try to allocate
a new block, and since we hold the super block lock already
very bad things would happen :)
We copy the behavior of udf_add_aext, but instead of
trying to allocate a new block close to the existing one,
we just steal a block from the extent we are trying to add.
It would be nice if the blocks were close together, but it
isn't required.
/*
* NOTE: we CANNOT use udf_add_aext here, as it can try to allocate
* a new block, and since we hold the super block lock already
* very bad things would happen :)
*
* We copy the behavior of udf_add_aext, but instead of
* trying to allocate a new block close to the existing one,
* we just steal a block from the extent we are trying to add.
*
* It would be nice if the blocks were close together, but it
* isn't required.
*/
int adsize;
@ -553,13 +506,14 @@ static void udf_table_free_blocks(struct super_block *sb,
struct allocExtDesc *aed;
eloc.logicalBlockNum = start;
elen = EXT_RECORDED_ALLOCATED | (count << sb->s_blocksize_bits);
elen = EXT_RECORDED_ALLOCATED |
(count << sb->s_blocksize_bits);
if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT) {
adsize = sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)
} else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG) {
adsize = sizeof(long_ad);
else {
} else {
brelse(oepos.bh);
brelse(epos.bh);
goto error_return;
@ -577,28 +531,21 @@ static void udf_table_free_blocks(struct super_block *sb,
eloc.logicalBlockNum++;
elen -= sb->s_blocksize;
if (!(epos.bh = udf_tread(sb,
udf_get_lb_pblock(sb,
epos.block,
0)))) {
if (!(epos.bh = udf_tread(sb, udf_get_lb_pblock(sb, epos.block, 0)))) {
brelse(oepos.bh);
goto error_return;
}
aed = (struct allocExtDesc *)(epos.bh->b_data);
aed->previousAllocExtLocation =
cpu_to_le32(oepos.block.logicalBlockNum);
aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum);
if (epos.offset + adsize > sb->s_blocksize) {
loffset = epos.offset;
aed->lengthAllocDescs = cpu_to_le32(adsize);
sptr = UDF_I_DATA(inode) + epos.offset -
udf_file_entry_alloc_offset(inode) +
UDF_I_LENEATTR(inode) - adsize;
dptr =
epos.bh->b_data +
sizeof(struct allocExtDesc);
udf_file_entry_alloc_offset(inode) +
UDF_I_LENEATTR(inode) - adsize;
dptr = epos.bh->b_data + sizeof(struct allocExtDesc);
memcpy(dptr, sptr, adsize);
epos.offset =
sizeof(struct allocExtDesc) + adsize;
epos.offset = sizeof(struct allocExtDesc) + adsize;
} else {
loffset = epos.offset + adsize;
aed->lengthAllocDescs = cpu_to_le32(0);
@ -606,60 +553,46 @@ static void udf_table_free_blocks(struct super_block *sb,
epos.offset = sizeof(struct allocExtDesc);
if (oepos.bh) {
aed =
(struct allocExtDesc *)oepos.bh->
b_data;
aed = (struct allocExtDesc *)oepos.bh->b_data;
aed->lengthAllocDescs =
cpu_to_le32(le32_to_cpu
(aed->
lengthAllocDescs) +
adsize);
cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
} else {
UDF_I_LENALLOC(table) += adsize;
mark_inode_dirty(table);
}
}
if (UDF_SB_UDFREV(sb) >= 0x0200)
udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3,
1, epos.block.logicalBlockNum,
sizeof(tag));
udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
epos.block.logicalBlockNum, sizeof(tag));
else
udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2,
1, epos.block.logicalBlockNum,
sizeof(tag));
udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1,
epos.block.logicalBlockNum, sizeof(tag));
switch (UDF_I_ALLOCTYPE(table)) {
case ICBTAG_FLAG_AD_SHORT:
{
sad = (short_ad *) sptr;
sad->extLength =
cpu_to_le32
(EXT_NEXT_EXTENT_ALLOCDECS | sb->
s_blocksize);
sad->extPosition =
cpu_to_le32(epos.block.
logicalBlockNum);
case ICBTAG_FLAG_AD_SHORT:
sad = (short_ad *)sptr;
sad->extLength = cpu_to_le32(
EXT_NEXT_EXTENT_ALLOCDECS |
sb->s_blocksize);
sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum);
break;
}
case ICBTAG_FLAG_AD_LONG:
{
lad = (long_ad *) sptr;
lad->extLength =
cpu_to_le32
(EXT_NEXT_EXTENT_ALLOCDECS | sb->
s_blocksize);
lad->extLocation =
cpu_to_lelb(epos.block);
case ICBTAG_FLAG_AD_LONG:
lad = (long_ad *)sptr;
lad->extLength = cpu_to_le32(
EXT_NEXT_EXTENT_ALLOCDECS |
sb->s_blocksize);
lad->extLocation = cpu_to_lelb(epos.block);
break;
}
}
if (oepos.bh) {
udf_update_tag(oepos.bh->b_data, loffset);
mark_buffer_dirty(oepos.bh);
} else
} else {
mark_inode_dirty(table);
}
}
if (elen) { /* It's possible that stealing the block emptied the extent */
if (elen) { /* It's possible that stealing the block emptied the extent */
udf_write_aext(table, &epos, eloc, elen, 1);
if (!epos.bh) {
@ -668,9 +601,7 @@ static void udf_table_free_blocks(struct super_block *sb,
} else {
aed = (struct allocExtDesc *)epos.bh->b_data;
aed->lengthAllocDescs =
cpu_to_le32(le32_to_cpu
(aed->lengthAllocDescs) +
adsize);
cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
udf_update_tag(epos.bh->b_data, epos.offset);
mark_buffer_dirty(epos.bh);
}
@ -680,7 +611,7 @@ static void udf_table_free_blocks(struct super_block *sb,
brelse(epos.bh);
brelse(oepos.bh);
error_return:
error_return:
sb->s_dirt = 1;
mutex_unlock(&sbi->s_alloc_mutex);
return;
@ -714,47 +645,36 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
epos.bh = NULL;
eloc.logicalBlockNum = 0xFFFFFFFF;
while (first_block != eloc.logicalBlockNum && (etype =
udf_next_aext(table,
&epos,
&eloc,
&elen,
1)) !=
-1) {
while (first_block != eloc.logicalBlockNum &&
(etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
udf_debug("eloc=%d, elen=%d, first_block=%d\n",
eloc.logicalBlockNum, elen, first_block);
; /* empty loop body */
; /* empty loop body */
}
if (first_block == eloc.logicalBlockNum) {
epos.offset -= adsize;
alloc_count = (elen >> sb->s_blocksize_bits);
if (inode
&& DQUOT_PREALLOC_BLOCK(inode,
alloc_count >
block_count ? block_count :
alloc_count))
if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count)) {
alloc_count = 0;
else if (alloc_count > block_count) {
} else if (alloc_count > block_count) {
alloc_count = block_count;
eloc.logicalBlockNum += alloc_count;
elen -= (alloc_count << sb->s_blocksize_bits);
udf_write_aext(table, &epos, eloc, (etype << 30) | elen,
1);
} else
udf_delete_aext(table, epos, eloc,
(etype << 30) | elen);
} else
udf_write_aext(table, &epos, eloc, (etype << 30) | elen, 1);
} else {
udf_delete_aext(table, epos, eloc, (etype << 30) | elen);
}
} else {
alloc_count = 0;
}
brelse(epos.bh);
if (alloc_count && UDF_SB_LVIDBH(sb)) {
UDF_SB_LVID(sb)->freeSpaceTable[partition] =
cpu_to_le32(le32_to_cpu
(UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
alloc_count);
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
mark_buffer_dirty(UDF_SB_LVIDBH(sb));
sb->s_dirt = 1;
}
@ -797,18 +717,17 @@ static int udf_table_new_block(struct super_block *sb,
epos.block = UDF_I_LOCATION(table);
epos.bh = goal_epos.bh = NULL;
while (spread && (etype =
udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
while (spread &&
(etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
if (goal >= eloc.logicalBlockNum) {
if (goal <
eloc.logicalBlockNum +
(elen >> sb->s_blocksize_bits))
if (goal < eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits))
nspread = 0;
else
nspread = goal - eloc.logicalBlockNum -
(elen >> sb->s_blocksize_bits);
} else
(elen >> sb->s_blocksize_bits);
} else {
nspread = eloc.logicalBlockNum - goal;
}
if (nspread < spread) {
spread = nspread;
@ -856,9 +775,7 @@ static int udf_table_new_block(struct super_block *sb,
if (UDF_SB_LVIDBH(sb)) {
UDF_SB_LVID(sb)->freeSpaceTable[partition] =
cpu_to_le32(le32_to_cpu
(UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
1);
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
mark_buffer_dirty(UDF_SB_LVIDBH(sb));
}
@ -877,27 +794,23 @@ inline void udf_free_blocks(struct super_block *sb,
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
return udf_bitmap_free_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_uspace.s_bitmap, bloc, offset,
count);
} else if (UDF_SB_PARTFLAGS(sb, partition) &
UDF_PART_FLAG_UNALLOC_TABLE) {
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
bloc, offset, count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
return udf_table_free_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_uspace.s_table, bloc, offset,
count);
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
bloc, offset, count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
return udf_bitmap_free_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_fspace.s_bitmap, bloc, offset,
count);
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
bloc, offset, count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
return udf_table_free_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_fspace.s_table, bloc, offset,
count);
} else
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
bloc, offset, count);
} else {
return;
}
}
inline int udf_prealloc_blocks(struct super_block *sb,
@ -907,29 +820,23 @@ inline int udf_prealloc_blocks(struct super_block *sb,
{
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
return udf_bitmap_prealloc_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)
[partition].s_uspace.s_bitmap,
partition, first_block,
block_count);
} else if (UDF_SB_PARTFLAGS(sb, partition) &
UDF_PART_FLAG_UNALLOC_TABLE) {
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
partition, first_block, block_count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
return udf_table_prealloc_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_uspace.s_table, partition,
first_block, block_count);
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
partition, first_block, block_count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
return udf_bitmap_prealloc_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)
[partition].s_fspace.s_bitmap,
partition, first_block,
block_count);
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
partition, first_block, block_count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
return udf_table_prealloc_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_fspace.s_table, partition,
first_block, block_count);
} else
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
partition, first_block, block_count);
} else {
return 0;
}
}
inline int udf_new_block(struct super_block *sb,
@ -940,26 +847,21 @@ inline int udf_new_block(struct super_block *sb,
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
ret = udf_bitmap_new_block(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_uspace.s_bitmap, partition, goal,
err);
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
partition, goal, err);
return ret;
} else if (UDF_SB_PARTFLAGS(sb, partition) &
UDF_PART_FLAG_UNALLOC_TABLE) {
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
return udf_table_new_block(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_uspace.s_table, partition, goal,
err);
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
partition, goal, err);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
return udf_bitmap_new_block(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_fspace.s_bitmap, partition, goal,
err);
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
partition, goal, err);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
return udf_table_new_block(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].
s_fspace.s_table, partition, goal,
err);
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
partition, goal, err);
} else {
*err = -EIO;
return 0;

4
fs/udf/crc.c
View File

@ -111,7 +111,7 @@ int main(void)
return 0;
}
#endif /* defined(TEST) */
#endif /* defined(TEST) */
/****************************************************************************/
#if defined(GENERATE)
@ -169,4 +169,4 @@ int main(int argc, char **argv)
return 0;
}
#endif /* defined(GENERATE) */
#endif /* defined(GENERATE) */

60
fs/udf/dir.c
View File

@ -43,10 +43,10 @@ static int do_udf_readdir(struct inode *, struct file *, filldir_t, void *);
/* readdir and lookup functions */
const struct file_operations udf_dir_operations = {
.read = generic_read_dir,
.readdir = udf_readdir,
.ioctl = udf_ioctl,
.fsync = udf_fsync_file,
.read = generic_read_dir,
.readdir = udf_readdir,
.ioctl = udf_ioctl,
.fsync = udf_fsync_file,
};
/*
@ -83,8 +83,7 @@ int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
lock_kernel();
if (filp->f_pos == 0) {
if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) <
0) {
if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) < 0) {
unlock_kernel();
return 0;
}
@ -93,7 +92,7 @@ int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
result = do_udf_readdir(dir, filp, filldir, dirent);
unlock_kernel();
return result;
return result;
}
static int
@ -125,21 +124,20 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
if (nf_pos == 0)
nf_pos = (udf_ext0_offset(dir) >> 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)
fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
fibh.sbh = fibh.ebh = NULL;
else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen,
&offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
} else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad);
} else
} else {
offset = 0;
}
if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) {
brelse(epos.bh);
@ -149,15 +147,11 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
if (!(offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1))) {
i = 16 >> (dir->i_sb->s_blocksize_bits - 9);
if (i + offset > (elen >> dir->i_sb->s_blocksize_bits))
i = (elen >> dir->i_sb->s_blocksize_bits) -
offset;
i = (elen >> dir->i_sb->s_blocksize_bits) - offset;
for (num = 0; i > 0; i--) {
block =
udf_get_lb_pblock(dir->i_sb, eloc,
offset + i);
block = udf_get_lb_pblock(dir->i_sb, eloc, offset + i);
tmp = udf_tgetblk(dir->i_sb, block);
if (tmp && !buffer_uptodate(tmp)
&& !buffer_locked(tmp))
if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp))
bha[num++] = tmp;
else
brelse(tmp);
@ -178,7 +172,6 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc,
&elen, &offset);
if (!fi) {
if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh);
@ -190,19 +183,16 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
liu = le16_to_cpu(cfi.lengthOfImpUse);
lfi = cfi.lengthFileIdent;
if (fibh.sbh == fibh.ebh)
if (fibh.sbh == fibh.ebh) {
nameptr = fi->fileIdent + liu;
else {
} else {
int poffset; /* Unpaded ending offset */
poffset =
fibh.soffset + sizeof(struct fileIdentDesc) + liu +
lfi;
poffset = fibh.soffset + sizeof(struct fileIdentDesc) + liu + lfi;
if (poffset >= lfi)
nameptr =
(char *)(fibh.ebh->b_data + poffset - lfi);
else {
if (poffset >= lfi) {
nameptr = (char *)(fibh.ebh->b_data + poffset - lfi);
} else {
nameptr = fname;
memcpy(nameptr, fi->fileIdent + liu,
lfi - poffset);
@ -235,17 +225,15 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
}
if (flen) {
if (filldir
(dirent, fname, flen, filp->f_pos, iblock,
dt_type) < 0) {
if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0) {
if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh);
brelse(fibh.sbh);
brelse(epos.bh);
return 0;
return 0;
}
}
} /* end while */
} /* end while */
filp->f_pos = nf_pos + 1;

68
fs/udf/directory.c
View File

@ -31,7 +31,7 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
*error = 0;
ad = (uint8_t *) (*bh)->b_data + *offset;
ad = (uint8_t *)(*bh)->b_data + *offset;
*offset += ad_size;
if (!ad) {
@ -51,7 +51,7 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
ad = tmpad;
remainder = dir->i_sb->s_blocksize - loffset;
memcpy((uint8_t *) ad, (*bh)->b_data + loffset, remainder);
memcpy((uint8_t *)ad, (*bh)->b_data + loffset, remainder);
brelse(*bh);
block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
@ -60,10 +60,10 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
if (!((*bh) = udf_tread(dir->i_sb, block)))
return NULL;
memcpy((uint8_t *) ad + remainder, (*bh)->b_data,
ad_size - remainder);
memcpy((uint8_t *)ad + remainder, (*bh)->b_data, ad_size - remainder);
*offset = ad_size - remainder;
}
return ad;
}
#endif
@ -86,15 +86,13 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
(UDF_I_EFE(dir) ?
sizeof(struct extendedFileEntry) :
sizeof(struct fileEntry)),
dir->i_sb->s_blocksize,
&(fibh->eoffset));
dir->i_sb->s_blocksize, &(fibh->eoffset));
if (!fi)
return NULL;
*nf_pos += ((fibh->eoffset - fibh->soffset) >> 2);
memcpy((uint8_t *) cfi, (uint8_t *) fi,
memcpy((uint8_t *)cfi, (uint8_t *)fi,
sizeof(struct fileIdentDesc));
return fi;
@ -121,21 +119,14 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
return NULL;
fibh->soffset = fibh->eoffset = 0;
if (!
(*offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1)))
{
if (!(*offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1))) {
i = 16 >> (dir->i_sb->s_blocksize_bits - 9);
if (i + *offset >
(*elen >> dir->i_sb->s_blocksize_bits))
i = (*elen >> dir->i_sb->s_blocksize_bits) -
*offset;
if (i + *offset > (*elen >> dir->i_sb->s_blocksize_bits))
i = (*elen >> dir->i_sb->s_blocksize_bits)-*offset;
for (num = 0; i > 0; i--) {
block =
udf_get_lb_pblock(dir->i_sb, *eloc,
*offset + i);
block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset + i);
tmp = udf_tgetblk(dir->i_sb, block);
if (tmp && !buffer_uptodate(tmp)
&& !buffer_locked(tmp))
if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp))
bha[num++] = tmp;
else
brelse(tmp);
@ -160,7 +151,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
*nf_pos += ((fibh->eoffset - fibh->soffset) >> 2);
if (fibh->eoffset <= dir->i_sb->s_blocksize) {
memcpy((uint8_t *) cfi, (uint8_t *) fi,
memcpy((uint8_t *)cfi, (uint8_t *)fi,
sizeof(struct fileIdentDesc));
} else if (fibh->eoffset > dir->i_sb->s_blocksize) {
int lextoffset = epos->offset;
@ -187,21 +178,17 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
if (sizeof(struct fileIdentDesc) > -fibh->soffset) {
int fi_len;
memcpy((uint8_t *) cfi, (uint8_t *) fi, -fibh->soffset);
memcpy((uint8_t *) cfi - fibh->soffset,
fibh->ebh->b_data,
memcpy((uint8_t *)cfi, (uint8_t *)fi, -fibh->soffset);
memcpy((uint8_t *)cfi - fibh->soffset, fibh->ebh->b_data,
sizeof(struct fileIdentDesc) + fibh->soffset);
fi_len =
(sizeof(struct fileIdentDesc) +
cfi->lengthFileIdent +
le16_to_cpu(cfi->lengthOfImpUse) + 3) & ~3;
fi_len = (sizeof(struct fileIdentDesc) + cfi->lengthFileIdent +
le16_to_cpu(cfi->lengthOfImpUse) + 3) & ~3;
*nf_pos +=
((fi_len - (fibh->eoffset - fibh->soffset)) >> 2);
*nf_pos += ((fi_len - (fibh->eoffset - fibh->soffset)) >> 2);
fibh->eoffset = fibh->soffset + fi_len;
} else {
memcpy((uint8_t *) cfi, (uint8_t *) fi,
memcpy((uint8_t *)cfi, (uint8_t *)fi,
sizeof(struct fileIdentDesc));
}
}
@ -237,9 +224,10 @@ struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, int *offset)
}
if ((*offset + sizeof(struct fileIdentDesc)) > bufsize) {
lengthThisIdent = sizeof(struct fileIdentDesc);
} else
} else {
lengthThisIdent = sizeof(struct fileIdentDesc) +
fi->lengthFileIdent + le16_to_cpu(fi->lengthOfImpUse);
fi->lengthFileIdent + le16_to_cpu(fi->lengthOfImpUse);
}
/* we need to figure padding, too! */
padlen = lengthThisIdent % UDF_NAME_PAD;
@ -270,22 +258,20 @@ static extent_ad *udf_get_fileextent(void *buffer, int bufsize, int *offset)
return NULL;
}
ptr =
(uint8_t *) (fe->extendedAttr) +
le32_to_cpu(fe->lengthExtendedAttr);
ptr = (uint8_t *)(fe->extendedAttr) + le32_to_cpu(fe->lengthExtendedAttr);
if ((*offset > 0) && (*offset < le32_to_cpu(fe->lengthAllocDescs))) {
ptr += *offset;
}
ext = (extent_ad *) ptr;
ext = (extent_ad *)ptr;
*offset = *offset + sizeof(extent_ad);
return ext;
}
#endif
short_ad *udf_get_fileshortad(uint8_t * ptr, int maxoffset, int *offset,
short_ad *udf_get_fileshortad(uint8_t *ptr, int maxoffset, int *offset,
int inc)
{
short_ad *sa;
@ -297,7 +283,7 @@ short_ad *udf_get_fileshortad(uint8_t * ptr, int maxoffset, int *offset,
if ((*offset < 0) || ((*offset + sizeof(short_ad)) > maxoffset))
return NULL;
else if ((sa = (short_ad *) ptr)->extLength == 0)
else if ((sa = (short_ad *)ptr)->extLength == 0)
return NULL;
if (inc)
@ -305,7 +291,7 @@ short_ad *udf_get_fileshortad(uint8_t * ptr, int maxoffset, int *offset,
return sa;
}
long_ad *udf_get_filelongad(uint8_t * ptr, int maxoffset, int *offset, int inc)
long_ad *udf_get_filelongad(uint8_t *ptr, int maxoffset, int *offset, int inc)
{
long_ad *la;
@ -316,7 +302,7 @@ long_ad *udf_get_filelongad(uint8_t * ptr, int maxoffset, int *offset, int inc)
if ((*offset < 0) || ((*offset + sizeof(long_ad)) > maxoffset))
return NULL;
else if ((la = (long_ad *) ptr)->extLength == 0)
else if ((la = (long_ad *)ptr)->extLength == 0)
return NULL;
if (inc)

680
fs/udf/ecma_167.h
View File

@ -39,8 +39,8 @@
/* Character set specification (ECMA 167r3 1/7.2.1) */
typedef struct {
uint8_t charSetType;
uint8_t charSetInfo[63];
uint8_t charSetType;
uint8_t charSetInfo[63];
} __attribute__ ((packed)) charspec;
/* Character Set Type (ECMA 167r3 1/7.2.1.1) */
@ -54,33 +54,33 @@ typedef struct {
#define CHARSPEC_TYPE_CS7 0x07 /* (1/7.2.9) */
#define CHARSPEC_TYPE_CS8 0x08 /* (1/7.2.10) */
typedef uint8_t dstring;
typedef uint8_t dstring;
/* Timestamp (ECMA 167r3 1/7.3) */
typedef struct {
__le16 typeAndTimezone;
__le16 year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
uint8_t centiseconds;
uint8_t hundredsOfMicroseconds;
uint8_t microseconds;
__le16 typeAndTimezone;
__le16 year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
uint8_t centiseconds;
uint8_t hundredsOfMicroseconds;
uint8_t microseconds;
} __attribute__ ((packed)) timestamp;
typedef struct {
uint16_t typeAndTimezone;
int16_t year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
uint8_t centiseconds;
uint8_t hundredsOfMicroseconds;
uint8_t microseconds;
uint16_t typeAndTimezone;
int16_t year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
uint8_t centiseconds;
uint8_t hundredsOfMicroseconds;
uint8_t microseconds;
} __attribute__ ((packed)) kernel_timestamp;
/* Type and Time Zone (ECMA 167r3 1/7.3.1) */
@ -92,9 +92,9 @@ typedef struct {
/* Entity identifier (ECMA 167r3 1/7.4) */
typedef struct {
uint8_t flags;
uint8_t ident[23];
uint8_t identSuffix[8];
uint8_t flags;
uint8_t ident[23];
uint8_t identSuffix[8];
} __attribute__ ((packed)) regid;
/* Flags (ECMA 167r3 1/7.4.1) */
@ -104,10 +104,10 @@ typedef struct {
/* Volume Structure Descriptor (ECMA 167r3 2/9.1) */
#define VSD_STD_ID_LEN 5
struct volStructDesc {
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t structData[2041];
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t structData[2041];
} __attribute__ ((packed));
/* Standard Identifier (EMCA 167r2 2/9.1.2) */
@ -123,36 +123,36 @@ struct volStructDesc {
/* Beginning Extended Area Descriptor (ECMA 167r3 2/9.2) */
struct beginningExtendedAreaDesc {
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t structData[2041];
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t structData[2041];
} __attribute__ ((packed));
/* Terminating Extended Area Descriptor (ECMA 167r3 2/9.3) */
struct terminatingExtendedAreaDesc {
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t structData[2041];
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t structData[2041];
} __attribute__ ((packed));
/* Boot Descriptor (ECMA 167r3 2/9.4) */
struct bootDesc {
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t reserved1;
regid archType;
regid bootIdent;
__le32 bootExtLocation;
__le32 bootExtLength;
__le64 loadAddress;
__le64 startAddress;
timestamp descCreationDateAndTime;
__le16 flags;
uint8_t reserved2[32];
uint8_t bootUse[1906];
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t reserved1;
regid archType;
regid bootIdent;
__le32 bootExtLocation;
__le32 bootExtLength;
__le64 loadAddress;
__le64 startAddress;
timestamp descCreationDateAndTime;
__le16 flags;
uint8_t reserved2[32];
uint8_t bootUse[1906];
} __attribute__ ((packed));
/* Flags (ECMA 167r3 2/9.4.12) */
@ -160,25 +160,25 @@ struct bootDesc {
/* Extent Descriptor (ECMA 167r3 3/7.1) */
typedef struct {
__le32 extLength;
__le32 extLocation;
__le32 extLength;
__le32 extLocation;
} __attribute__ ((packed)) extent_ad;
typedef struct {
uint32_t extLength;
uint32_t extLocation;
uint32_t extLength;
uint32_t extLocation;
} kernel_extent_ad;
/* Descriptor Tag (ECMA 167r3 3/7.2) */
typedef struct {
__le16 tagIdent;
__le16 descVersion;
uint8_t tagChecksum;
uint8_t reserved;
__le16 tagSerialNum;
__le16 descCRC;
__le16 descCRCLength;
__le32 tagLocation;
__le16 tagIdent;
__le16 descVersion;
uint8_t tagChecksum;
uint8_t reserved;
__le16 tagSerialNum;
__le16 descCRC;
__le16 descCRCLength;
__le32 tagLocation;
} __attribute__ ((packed)) tag;
/* Tag Identifier (ECMA 167r3 3/7.2.1) */
@ -194,37 +194,37 @@ typedef struct {
/* NSR Descriptor (ECMA 167r3 3/9.1) */
struct NSRDesc {
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t reserved;
uint8_t structData[2040];
uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion;
uint8_t reserved;
uint8_t structData[2040];
} __attribute__ ((packed));
/* Primary Volume Descriptor (ECMA 167r3 3/10.1) */
struct primaryVolDesc {
tag descTag;
__le32 volDescSeqNum;
__le32 primaryVolDescNum;
dstring volIdent[32];
__le16 volSeqNum;
__le16 maxVolSeqNum;
__le16 interchangeLvl;
__le16 maxInterchangeLvl;
__le32 charSetList;
__le32 maxCharSetList;
dstring volSetIdent[128];
charspec descCharSet;
charspec explanatoryCharSet;
extent_ad volAbstract;
extent_ad volCopyright;
regid appIdent;
timestamp recordingDateAndTime;
regid impIdent;
uint8_t impUse[64];
__le32 predecessorVolDescSeqLocation;
__le16 flags;
uint8_t reserved[22];
tag descTag;
__le32 volDescSeqNum;
__le32 primaryVolDescNum;
dstring volIdent[32];
__le16 volSeqNum;
__le16 maxVolSeqNum;
__le16 interchangeLvl;
__le16 maxInterchangeLvl;
__le32 charSetList;
__le32 maxCharSetList;
dstring volSetIdent[128];
charspec descCharSet;
charspec explanatoryCharSet;
extent_ad volAbstract;
extent_ad volCopyright;
regid appIdent;
timestamp recordingDateAndTime;
regid impIdent;
uint8_t impUse[64];
__le32 predecessorVolDescSeqLocation;
__le16 flags;
uint8_t reserved[22];
} __attribute__ ((packed));
/* Flags (ECMA 167r3 3/10.1.21) */
@ -232,26 +232,26 @@ struct primaryVolDesc {
/* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) */
struct anchorVolDescPtr {
tag descTag;
extent_ad mainVolDescSeqExt;
extent_ad reserveVolDescSeqExt;
uint8_t reserved[480];
tag descTag;
extent_ad mainVolDescSeqExt;
extent_ad reserveVolDescSeqExt;
uint8_t reserved[480];
} __attribute__ ((packed));
/* Volume Descriptor Pointer (ECMA 167r3 3/10.3) */
struct volDescPtr {
tag descTag;
__le32 volDescSeqNum;
extent_ad nextVolDescSeqExt;
uint8_t reserved[484];
tag descTag;
__le32 volDescSeqNum;
extent_ad nextVolDescSeqExt;
uint8_t reserved[484];
} __attribute__ ((packed));
/* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) */
struct impUseVolDesc {
tag descTag;
__le32 volDescSeqNum;
regid impIdent;
uint8_t impUse[460];
tag descTag;
__le32 volDescSeqNum;
regid impIdent;
uint8_t impUse[460];
} __attribute__ ((packed));
/* Partition Descriptor (ECMA 167r3 3/10.5) */
@ -291,26 +291,26 @@ struct partitionDesc {
/* Logical Volume Descriptor (ECMA 167r3 3/10.6) */
struct logicalVolDesc {
tag descTag;
__le32 volDescSeqNum;
charspec descCharSet;
dstring logicalVolIdent[128];
__le32 logicalBlockSize;
regid domainIdent;
uint8_t logicalVolContentsUse[16];
__le32 mapTableLength;
__le32 numPartitionMaps;
regid impIdent;
uint8_t impUse[128];
extent_ad integritySeqExt;
uint8_t partitionMaps[0];
tag descTag;
__le32 volDescSeqNum;
charspec descCharSet;
dstring logicalVolIdent[128];
__le32 logicalBlockSize;
regid domainIdent;
uint8_t logicalVolContentsUse[16];
__le32 mapTableLength;
__le32 numPartitionMaps;
regid impIdent;
uint8_t impUse[128];
extent_ad integritySeqExt;
uint8_t partitionMaps[0];
} __attribute__ ((packed));
/* Generic Partition Map (ECMA 167r3 3/10.7.1) */
struct genericPartitionMap {
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t partitionMapping[0];
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t partitionMapping[0];
} __attribute__ ((packed));
/* Partition Map Type (ECMA 167r3 3/10.7.1.1) */
@ -320,45 +320,45 @@ struct genericPartitionMap {
/* Type 1 Partition Map (ECMA 167r3 3/10.7.2) */
struct genericPartitionMap1 {
uint8_t partitionMapType;
uint8_t partitionMapLength;
__le16 volSeqNum;
__le16 partitionNum;
uint8_t partitionMapType;
uint8_t partitionMapLength;
__le16 volSeqNum;
__le16 partitionNum;
} __attribute__ ((packed));
/* Type 2 Partition Map (ECMA 167r3 3/10.7.3) */
struct genericPartitionMap2 {
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t partitionIdent[62];
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t partitionIdent[62];
} __attribute__ ((packed));
/* Unallocated Space Descriptor (ECMA 167r3 3/10.8) */
struct unallocSpaceDesc {
tag descTag;
__le32 volDescSeqNum;
__le32 numAllocDescs;
extent_ad allocDescs[0];
tag descTag;
__le32 volDescSeqNum;
__le32 numAllocDescs;
extent_ad allocDescs[0];
} __attribute__ ((packed));
/* Terminating Descriptor (ECMA 167r3 3/10.9) */
struct terminatingDesc {
tag descTag;
uint8_t reserved[496];
tag descTag;
uint8_t reserved[496];
} __attribute__ ((packed));
/* Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) */
struct logicalVolIntegrityDesc {
tag descTag;
timestamp recordingDateAndTime;
__le32 integrityType;
extent_ad nextIntegrityExt;
uint8_t logicalVolContentsUse[32];
__le32 numOfPartitions;
__le32 lengthOfImpUse;
__le32 freeSpaceTable[0];
__le32 sizeTable[0];
uint8_t impUse[0];
tag descTag;
timestamp recordingDateAndTime;
__le32 integrityType;
extent_ad nextIntegrityExt;
uint8_t logicalVolContentsUse[32];
__le32 numOfPartitions;
__le32 lengthOfImpUse;
__le32 freeSpaceTable[0];
__le32 sizeTable[0];
uint8_t impUse[0];
} __attribute__ ((packed));
/* Integrity Type (ECMA 167r3 3/10.10.3) */
@ -367,48 +367,48 @@ struct logicalVolIntegrityDesc {
/* Recorded Address (ECMA 167r3 4/7.1) */
typedef struct {
__le32 logicalBlockNum;
__le16 partitionReferenceNum;
__le32 logicalBlockNum;
__le16 partitionReferenceNum;
} __attribute__ ((packed)) lb_addr;
/* ... and its in-core analog */
typedef struct {
uint32_t logicalBlockNum;
uint16_t partitionReferenceNum;
uint32_t logicalBlockNum;
uint16_t partitionReferenceNum;
} kernel_lb_addr;
/* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */
typedef struct {
__le32 extLength;
__le32 extPosition;
__le32 extLength;
__le32 extPosition;
} __attribute__ ((packed)) short_ad;
/* Long Allocation Descriptor (ECMA 167r3 4/14.14.2) */
typedef struct {
__le32 extLength;
lb_addr extLocation;
uint8_t impUse[6];
__le32 extLength;
lb_addr extLocation;
uint8_t impUse[6];
} __attribute__ ((packed)) long_ad;
typedef struct {
uint32_t extLength;
kernel_lb_addr extLocation;
uint8_t impUse[6];
uint32_t extLength;
kernel_lb_addr extLocation;
uint8_t impUse[6];
} kernel_long_ad;
/* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */
typedef struct {
__le32 extLength;
__le32 recordedLength;
__le32 informationLength;
lb_addr extLocation;
__le32 extLength;
__le32 recordedLength;
__le32 informationLength;
lb_addr extLocation;
} __attribute__ ((packed)) ext_ad;
typedef struct {
uint32_t extLength;
uint32_t recordedLength;
uint32_t informationLength;
kernel_lb_addr extLocation;
uint32_t extLength;
uint32_t recordedLength;
uint32_t informationLength;
kernel_lb_addr extLocation;
} kernel_ext_ad;
/* Descriptor Tag (ECMA 167r3 4/7.2 - See 3/7.2) */
@ -428,48 +428,48 @@ typedef struct {
/* File Set Descriptor (ECMA 167r3 4/14.1) */
struct fileSetDesc {
tag descTag;
timestamp recordingDateAndTime;
__le16 interchangeLvl;
__le16 maxInterchangeLvl;
__le32 charSetList;
__le32 maxCharSetList;
__le32 fileSetNum;
__le32 fileSetDescNum;
charspec logicalVolIdentCharSet;
dstring logicalVolIdent[128];
charspec fileSetCharSet;
dstring fileSetIdent[32];
dstring copyrightFileIdent[32];
dstring abstractFileIdent[32];
long_ad rootDirectoryICB;
regid domainIdent;
long_ad nextExt;
long_ad streamDirectoryICB;
uint8_t reserved[32];
tag descTag;
timestamp recordingDateAndTime;
__le16 interchangeLvl;
__le16 maxInterchangeLvl;
__le32 charSetList;
__le32 maxCharSetList;
__le32 fileSetNum;
__le32 fileSetDescNum;
charspec logicalVolIdentCharSet;
dstring logicalVolIdent[128];
charspec fileSetCharSet;
dstring fileSetIdent[32];
dstring copyrightFileIdent[32];
dstring abstractFileIdent[32];
long_ad rootDirectoryICB;
regid domainIdent;
long_ad nextExt;
long_ad streamDirectoryICB;
uint8_t reserved[32];
} __attribute__ ((packed));
/* Partition Header Descriptor (ECMA 167r3 4/14.3) */
struct partitionHeaderDesc {
short_ad unallocSpaceTable;
short_ad unallocSpaceBitmap;
short_ad partitionIntegrityTable;
short_ad freedSpaceTable;
short_ad freedSpaceBitmap;
uint8_t reserved[88];
short_ad unallocSpaceTable;
short_ad unallocSpaceBitmap;
short_ad partitionIntegrityTable;
short_ad freedSpaceTable;
short_ad freedSpaceBitmap;
uint8_t reserved[88];
} __attribute__ ((packed));
/* File Identifier Descriptor (ECMA 167r3 4/14.4) */
struct fileIdentDesc {
tag descTag;
__le16 fileVersionNum;
uint8_t fileCharacteristics;
uint8_t lengthFileIdent;
long_ad icb;
__le16 lengthOfImpUse;
uint8_t impUse[0];
uint8_t fileIdent[0];
uint8_t padding[0];
tag descTag;
__le16 fileVersionNum;
uint8_t fileCharacteristics;
uint8_t lengthFileIdent;
long_ad icb;
__le16 lengthOfImpUse;
uint8_t impUse[0];
uint8_t fileIdent[0];
uint8_t padding[0];
} __attribute__ ((packed));
/* File Characteristics (ECMA 167r3 4/14.4.3) */
@ -481,21 +481,21 @@ struct fileIdentDesc {
/* Allocation Ext Descriptor (ECMA 167r3 4/14.5) */
struct allocExtDesc {
tag descTag;
__le32 previousAllocExtLocation;
__le32 lengthAllocDescs;
tag descTag;
__le32 previousAllocExtLocation;
__le32 lengthAllocDescs;
} __attribute__ ((packed));
/* ICB Tag (ECMA 167r3 4/14.6) */
typedef struct {
__le32 priorRecordedNumDirectEntries;
__le16 strategyType;
__le16 strategyParameter;
__le16 numEntries;
uint8_t reserved;
uint8_t fileType;
lb_addr parentICBLocation;
__le16 flags;
__le32 priorRecordedNumDirectEntries;
__le16 strategyType;
__le16 strategyParameter;
__le16 numEntries;
uint8_t reserved;
uint8_t fileType;
lb_addr parentICBLocation;
__le16 flags;
} __attribute__ ((packed)) icbtag;
/* Strategy Type (ECMA 167r3 4/14.6.2) */
@ -541,41 +541,41 @@ typedef struct {
/* Indirect Entry (ECMA 167r3 4/14.7) */
struct indirectEntry {
tag descTag;
icbtag icbTag;
long_ad indirectICB;
tag descTag;
icbtag icbTag;
long_ad indirectICB;
} __attribute__ ((packed));
/* Terminal Entry (ECMA 167r3 4/14.8) */
struct terminalEntry {
tag descTag;
icbtag icbTag;
tag descTag;
icbtag icbTag;
} __attribute__ ((packed));
/* File Entry (ECMA 167r3 4/14.9) */
struct fileEntry {
tag descTag;
icbtag icbTag;
__le32 uid;
__le32 gid;
__le32 permissions;
__le16 fileLinkCount;
uint8_t recordFormat;
uint8_t recordDisplayAttr;
__le32 recordLength;
__le64 informationLength;
__le64 logicalBlocksRecorded;
timestamp accessTime;
timestamp modificationTime;
timestamp attrTime;
__le32 checkpoint;
long_ad extendedAttrICB;
regid impIdent;
__le64 uniqueID;
__le32 lengthExtendedAttr;
__le32 lengthAllocDescs;
uint8_t extendedAttr[0];
uint8_t allocDescs[0];
tag descTag;
icbtag icbTag;
__le32 uid;
__le32 gid;
__le32 permissions;
__le16 fileLinkCount;
uint8_t recordFormat;
uint8_t recordDisplayAttr;
__le32 recordLength;
__le64 informationLength;
__le64 logicalBlocksRecorded;
timestamp accessTime;
timestamp modificationTime;
timestamp attrTime;
__le32 checkpoint;
long_ad extendedAttrICB;
regid impIdent;
__le64 uniqueID;
__le32 lengthExtendedAttr;
__le32 lengthAllocDescs;
uint8_t extendedAttr[0];
uint8_t allocDescs[0];
} __attribute__ ((packed));
/* Permissions (ECMA 167r3 4/14.9.5) */
@ -617,51 +617,51 @@ struct fileEntry {
/* Extended Attribute Header Descriptor (ECMA 167r3 4/14.10.1) */
struct extendedAttrHeaderDesc {
tag descTag;
__le32 impAttrLocation;
__le32 appAttrLocation;
tag descTag;
__le32 impAttrLocation;
__le32 appAttrLocation;
} __attribute__ ((packed));
/* Generic Format (ECMA 167r3 4/14.10.2) */
struct genericFormat {
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
uint8_t attrData[0];
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
uint8_t attrData[0];
} __attribute__ ((packed));
/* Character Set Information (ECMA 167r3 4/14.10.3) */
struct charSetInfo {
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 escapeSeqLength;
uint8_t charSetType;
uint8_t escapeSeq[0];
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 escapeSeqLength;
uint8_t charSetType;
uint8_t escapeSeq[0];
} __attribute__ ((packed));
/* Alternate Permissions (ECMA 167r3 4/14.10.4) */
struct altPerms {
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le16 ownerIdent;
__le16 groupIdent;
__le16 permission;
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le16 ownerIdent;
__le16 groupIdent;
__le16 permission;
} __attribute__ ((packed));
/* File Times Extended Attribute (ECMA 167r3 4/14.10.5) */
struct fileTimesExtAttr {
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 dataLength;
__le32 fileTimeExistence;
uint8_t fileTimes;
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 dataLength;
__le32 fileTimeExistence;
uint8_t fileTimes;
} __attribute__ ((packed));
/* FileTimeExistence (ECMA 167r3 4/14.10.5.6) */
@ -672,47 +672,47 @@ struct fileTimesExtAttr {
/* Information Times Extended Attribute (ECMA 167r3 4/14.10.6) */
struct infoTimesExtAttr {
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 dataLength;
__le32 infoTimeExistence;
uint8_t infoTimes[0];
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 dataLength;
__le32 infoTimeExistence;
uint8_t infoTimes[0];
} __attribute__ ((packed));
/* Device Specification (ECMA 167r3 4/14.10.7) */
struct deviceSpec {
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 impUseLength;
__le32 majorDeviceIdent;
__le32 minorDeviceIdent;
uint8_t impUse[0];
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 impUseLength;
__le32 majorDeviceIdent;
__le32 minorDeviceIdent;
uint8_t impUse[0];
} __attribute__ ((packed));
/* Implementation Use Extended Attr (ECMA 167r3 4/14.10.8) */
struct impUseExtAttr {
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 impUseLength;
regid impIdent;
uint8_t impUse[0];
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 impUseLength;
regid impIdent;
uint8_t impUse[0];
} __attribute__ ((packed));
/* Application Use Extended Attribute (ECMA 167r3 4/14.10.9) */
struct appUseExtAttr {
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 appUseLength;
regid appIdent;
uint8_t appUse[0];
__le32 attrType;
uint8_t attrSubtype;
uint8_t reserved[3];
__le32 attrLength;
__le32 appUseLength;
regid appIdent;
uint8_t appUse[0];
} __attribute__ ((packed));
#define EXTATTR_CHAR_SET 1
@ -725,29 +725,29 @@ struct appUseExtAttr {
/* Unallocated Space Entry (ECMA 167r3 4/14.11) */
struct unallocSpaceEntry {
tag descTag;
icbtag icbTag;
__le32 lengthAllocDescs;
uint8_t allocDescs[0];
tag descTag;
icbtag icbTag;
__le32 lengthAllocDescs;
uint8_t allocDescs[0];
} __attribute__ ((packed));
/* Space Bitmap Descriptor (ECMA 167r3 4/14.12) */
struct spaceBitmapDesc {
tag descTag;
__le32 numOfBits;
__le32 numOfBytes;
uint8_t bitmap[0];
tag descTag;
__le32 numOfBits;
__le32 numOfBytes;
uint8_t bitmap[0];
} __attribute__ ((packed));
/* Partition Integrity Entry (ECMA 167r3 4/14.13) */
struct partitionIntegrityEntry {
tag descTag;
icbtag icbTag;
timestamp recordingDateAndTime;
uint8_t integrityType;
uint8_t reserved[175];
regid impIdent;
uint8_t impUse[256];
tag descTag;
icbtag icbTag;
timestamp recordingDateAndTime;
uint8_t integrityType;
uint8_t reserved[175];
regid impIdent;
uint8_t impUse[256];
} __attribute__ ((packed));
/* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */
@ -764,46 +764,46 @@ struct partitionIntegrityEntry {
/* Logical Volume Header Descriptor (ECMA 167r3 4/14.15) */
struct logicalVolHeaderDesc {
__le64 uniqueID;
uint8_t reserved[24];
__le64 uniqueID;
uint8_t reserved[24];
} __attribute__ ((packed));
/* Path Component (ECMA 167r3 4/14.16.1) */
struct pathComponent {
uint8_t componentType;
uint8_t lengthComponentIdent;
__le16 componentFileVersionNum;
dstring componentIdent[0];
uint8_t componentType;
uint8_t lengthComponentIdent;
__le16 componentFileVersionNum;
dstring componentIdent[0];
} __attribute__ ((packed));
/* File Entry (ECMA 167r3 4/14.17) */
struct extendedFileEntry {
tag descTag;
icbtag icbTag;
__le32 uid;
__le32 gid;
__le32 permissions;
__le16 fileLinkCount;
uint8_t recordFormat;
uint8_t recordDisplayAttr;
__le32 recordLength;
__le64 informationLength;
__le64 objectSize;
__le64 logicalBlocksRecorded;
timestamp accessTime;
timestamp modificationTime;
timestamp createTime;
timestamp attrTime;
__le32 checkpoint;
__le32 reserved;
long_ad extendedAttrICB;
long_ad streamDirectoryICB;
regid impIdent;
__le64 uniqueID;
__le32 lengthExtendedAttr;
__le32 lengthAllocDescs;
uint8_t extendedAttr[0];
uint8_t allocDescs[0];
tag descTag;
icbtag icbTag;
__le32 uid;
__le32 gid;
__le32 permissions;
__le16 fileLinkCount;
uint8_t recordFormat;
uint8_t recordDisplayAttr;
__le32 recordLength;
__le64 informationLength;
__le64 objectSize;
__le64 logicalBlocksRecorded;
timestamp accessTime;
timestamp modificationTime;
timestamp createTime;
timestamp attrTime;
__le32 checkpoint;
__le32 reserved;
long_ad extendedAttrICB;
long_ad streamDirectoryICB;
regid impIdent;
__le64 uniqueID;
__le32 lengthExtendedAttr;
__le32 lengthAllocDescs;
uint8_t extendedAttr[0];
uint8_t allocDescs[0];
} __attribute__ ((packed));
#endif /* _ECMA_167_H */
#endif /* _ECMA_167_H */

72
fs/udf/file.c
View File

@ -30,7 +30,7 @@
#include <linux/udf_fs.h>
#include <asm/uaccess.h>
#include <linux/kernel.h>
#include <linux/string.h> /* memset */
#include <linux/string.h> /* memset */
#include <linux/capability.h>
#include <linux/errno.h>
#include <linux/smp_lock.h>
@ -55,11 +55,11 @@ static int udf_adinicb_readpage(struct file *file, struct page *page)
SetPageUptodate(page);
kunmap(page);
unlock_page(page);
return 0;
}
static int udf_adinicb_writepage(struct page *page,
struct writeback_control *wbc)
static int udf_adinicb_writepage(struct page *page, struct writeback_control *wbc)
{
struct inode *inode = page->mapping->host;
char *kaddr;
@ -72,6 +72,7 @@ static int udf_adinicb_writepage(struct page *page,
SetPageUptodate(page);
kunmap(page);
unlock_page(page);
return 0;
}
@ -100,11 +101,11 @@ static int udf_adinicb_commit_write(struct file *file, struct page *page,
}
const struct address_space_operations udf_adinicb_aops = {
.readpage = udf_adinicb_readpage,
.writepage = udf_adinicb_writepage,
.sync_page = block_sync_page,
.prepare_write = udf_adinicb_prepare_write,
.commit_write = udf_adinicb_commit_write,
.readpage = udf_adinicb_readpage,
.writepage = udf_adinicb_writepage,
.sync_page = block_sync_page,
.prepare_write = udf_adinicb_prepare_write,
.commit_write = udf_adinicb_commit_write,
};
static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
@ -122,8 +123,8 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
else
pos = ppos;
if (inode->i_sb->s_blocksize <
(udf_file_entry_alloc_offset(inode) + pos + count)) {
if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
pos + count)) {
udf_expand_file_adinicb(inode, pos + count, &err);
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
udf_debug("udf_expand_adinicb: err=%d\n", err);
@ -138,9 +139,9 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
}
retval = generic_file_aio_write(iocb, iov, nr_segs, ppos);
if (retval > 0)
mark_inode_dirty(inode);
return retval;
}
@ -181,10 +182,12 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
unsigned long arg)
{
long old_block, new_block;
int result = -EINVAL;
if (file_permission(filp, MAY_READ) != 0) {
udf_debug("no permission to access inode %lu\n", inode->i_ino);
udf_debug("no permission to access inode %lu\n",
inode->i_ino);
return -EPERM;
}
@ -196,26 +199,19 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
switch (cmd) {
case UDF_GETVOLIDENT:
return copy_to_user((char __user *)arg,
UDF_SB_VOLIDENT(inode->i_sb),
32) ? -EFAULT : 0;
UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;
case UDF_RELOCATE_BLOCKS:
{
long old, new;
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
if (get_user(old, (long __user *)arg))
return -EFAULT;
if ((result = udf_relocate_blocks(inode->i_sb,
old, &new)) == 0)
result = put_user(new, (long __user *)arg);
return result;
}
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
if (get_user(old_block, (long __user *)arg))
return -EFAULT;
if ((result = udf_relocate_blocks(inode->i_sb,
old_block, &new_block)) == 0)
result = put_user(new_block, (long __user *)arg);
return result;
case UDF_GETEASIZE:
result = put_user(UDF_I_LENEATTR(inode), (int __user *)arg);
break;
case UDF_GETEABLOCK:
result = copy_to_user((char __user *)arg, UDF_I_DATA(inode),
UDF_I_LENEATTR(inode)) ? -EFAULT : 0;
@ -248,16 +244,16 @@ static int udf_release_file(struct inode *inode, struct file *filp)
}
const struct file_operations udf_file_operations = {
.read = do_sync_read,
.aio_read = generic_file_aio_read,
.ioctl = udf_ioctl,
.open = generic_file_open,
.mmap = generic_file_mmap,
.write = do_sync_write,
.aio_write = udf_file_aio_write,
.release = udf_release_file,
.fsync = udf_fsync_file,
.splice_read = generic_file_splice_read,
.read = do_sync_read,
.aio_read = generic_file_aio_read,
.ioctl = udf_ioctl,
.open = generic_file_open,
.mmap = generic_file_mmap,
.write = do_sync_write,
.aio_write = udf_file_aio_write,
.release = udf_release_file,
.fsync = udf_fsync_file,
.splice_read = generic_file_splice_read,
};
const struct inode_operations udf_file_inode_operations = {

2
fs/udf/fsync.c
View File

@ -32,6 +32,7 @@ static int udf_fsync_inode(struct inode *, int);
int udf_fsync_file(struct file *file, struct dentry *dentry, int datasync)
{
struct inode *inode = dentry->d_inode;
return udf_fsync_inode(inode, datasync);
}
@ -46,5 +47,6 @@ static int udf_fsync_inode(struct inode *inode, int datasync)
return err;
err |= udf_sync_inode(inode);
return err ? -EIO : 0;
}

38
fs/udf/ialloc.c
View File

@ -46,12 +46,10 @@ void udf_free_inode(struct inode *inode)
if (sbi->s_lvidbh) {
if (S_ISDIR(inode->i_mode))
UDF_SB_LVIDIU(sb)->numDirs =
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)
- 1);
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) - 1);
else
UDF_SB_LVIDIU(sb)->numFiles =
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles)
- 1);
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) - 1);
mark_buffer_dirty(sbi->s_lvidbh);
}
@ -82,10 +80,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
UDF_I_STRAT4096(inode) = 0;
block =
udf_new_block(dir->i_sb, NULL,
UDF_I_LOCATION(dir).partitionReferenceNum, start,
err);
block = udf_new_block(dir->i_sb, NULL, UDF_I_LOCATION(dir).partitionReferenceNum,
start, err);
if (*err) {
iput(inode);
return NULL;
@ -95,17 +91,13 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
if (UDF_SB_LVIDBH(sb)) {
struct logicalVolHeaderDesc *lvhd;
uint64_t uniqueID;
lvhd =
(struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->
logicalVolContentsUse);
lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->logicalVolContentsUse);
if (S_ISDIR(mode))
UDF_SB_LVIDIU(sb)->numDirs =
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)
+ 1);
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) + 1);
else
UDF_SB_LVIDIU(sb)->numFiles =
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles)
+ 1);
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) + 1);
UDF_I_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);
if (!(++uniqueID & 0x00000000FFFFFFFFUL))
uniqueID += 16;
@ -118,12 +110,12 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
inode->i_gid = dir->i_gid;
if (S_ISDIR(mode))
mode |= S_ISGID;
} else
} else {
inode->i_gid = current->fsgid;
}
UDF_I_LOCATION(inode).logicalBlockNum = block;
UDF_I_LOCATION(inode).partitionReferenceNum =
UDF_I_LOCATION(dir).partitionReferenceNum;
UDF_I_LOCATION(inode).partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);
inode->i_blocks = 0;
UDF_I_LENEATTR(inode) = 0;
@ -132,14 +124,10 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
UDF_I_EFE(inode) = 1;
UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);
UDF_I_DATA(inode) =
kzalloc(inode->i_sb->s_blocksize -
sizeof(struct extendedFileEntry), GFP_KERNEL);
UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
} else {
UDF_I_EFE(inode) = 0;
UDF_I_DATA(inode) =
kzalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry),
GFP_KERNEL);
UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
}
if (!UDF_I_DATA(inode)) {
iput(inode);
@ -154,7 +142,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
else
UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
inode->i_mtime = inode->i_atime = inode->i_ctime =
UDF_I_CRTIME(inode) = current_fs_time(inode->i_sb);
UDF_I_CRTIME(inode) = current_fs_time(inode->i_sb);
insert_inode_hash(inode);
mark_inode_dirty(inode);
mutex_unlock(&sbi->s_alloc_mutex);

950
fs/udf/inode.c
View File

File diff suppressed because it is too large Load Diff

4
fs/udf/lowlevel.c
View File

@ -43,7 +43,7 @@ unsigned int udf_get_last_session(struct super_block *sb)
udf_debug("XA disk: %s, vol_desc_start=%d\n",
(ms_info.xa_flag ? "yes" : "no"), ms_info.addr.lba);
#if WE_OBEY_THE_WRITTEN_STANDARDS
if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
#endif
vol_desc_start = ms_info.addr.lba;
} else {
@ -57,7 +57,7 @@ unsigned long udf_get_last_block(struct super_block *sb)
struct block_device *bdev = sb->s_bdev;
unsigned long lblock = 0;
if (ioctl_by_bdev(bdev, CDROM_LAST_WRITTEN, (unsigned long)&lblock))
if (ioctl_by_bdev(bdev, CDROM_LAST_WRITTEN, (unsigned long) &lblock))
lblock = bdev->bd_inode->i_size >> sb->s_blocksize_bits;
if (lblock)

87
fs/udf/misc.c
View File

@ -54,15 +54,15 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
int i;
ea = UDF_I_DATA(inode);
if (UDF_I_LENEATTR(inode))
if (UDF_I_LENEATTR(inode)) {
ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
else {
} else {
ad = ea;
size += sizeof(struct extendedAttrHeaderDesc);
}
offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
UDF_I_LENALLOC(inode);
UDF_I_LENALLOC(inode);
/* TODO - Check for FreeEASpace */
@ -76,56 +76,45 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
if (UDF_I_LENEATTR(inode)) {
/* check checksum/crc */
if (le16_to_cpu(eahd->descTag.tagIdent) !=
TAG_IDENT_EAHD
|| le32_to_cpu(eahd->descTag.tagLocation) !=
UDF_I_LOCATION(inode).logicalBlockNum) {
if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD ||
le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) {
return NULL;
}
} else {
size -= sizeof(struct extendedAttrHeaderDesc);
UDF_I_LENEATTR(inode) +=
sizeof(struct extendedAttrHeaderDesc);
UDF_I_LENEATTR(inode) += sizeof(struct extendedAttrHeaderDesc);
eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
eahd->descTag.descVersion = cpu_to_le16(3);
else
eahd->descTag.descVersion = cpu_to_le16(2);
eahd->descTag.tagSerialNum =
cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
eahd->descTag.tagLocation =
cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
}
offset = UDF_I_LENEATTR(inode);
if (type < 2048) {
if (le32_to_cpu(eahd->appAttrLocation) <
UDF_I_LENEATTR(inode)) {
uint32_t aal =
le32_to_cpu(eahd->appAttrLocation);
memmove(&ea[offset - aal + size], &ea[aal],
offset - aal);
if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) {
uint32_t aal = le32_to_cpu(eahd->appAttrLocation);
memmove(&ea[offset - aal + size],
&ea[aal], offset - aal);
offset -= aal;
eahd->appAttrLocation = cpu_to_le32(aal + size);
}
if (le32_to_cpu(eahd->impAttrLocation) <
UDF_I_LENEATTR(inode)) {
uint32_t ial =
le32_to_cpu(eahd->impAttrLocation);
memmove(&ea[offset - ial + size], &ea[ial],
offset - ial);
if (le32_to_cpu(eahd->impAttrLocation) < UDF_I_LENEATTR(inode)) {
uint32_t ial = le32_to_cpu(eahd->impAttrLocation);
memmove(&ea[offset - ial + size],
&ea[ial], offset - ial);
offset -= ial;
eahd->impAttrLocation = cpu_to_le32(ial + size);
}
} else if (type < 65536) {
if (le32_to_cpu(eahd->appAttrLocation) <
UDF_I_LENEATTR(inode)) {
uint32_t aal =
le32_to_cpu(eahd->appAttrLocation);
memmove(&ea[offset - aal + size], &ea[aal],
offset - aal);
if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) {
uint32_t aal = le32_to_cpu(eahd->appAttrLocation);
memmove(&ea[offset - aal + size],
&ea[aal], offset - aal);
offset -= aal;
eahd->appAttrLocation = cpu_to_le32(aal + size);
}
@ -133,18 +122,18 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
/* rewrite CRC + checksum of eahd */
crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag);
eahd->descTag.descCRCLength = cpu_to_le16(crclen);
eahd->descTag.descCRC =
cpu_to_le16(udf_crc((char *)eahd + sizeof(tag), crclen, 0));
eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
sizeof(tag), crclen, 0));
eahd->descTag.tagChecksum = 0;
for (i = 0; i < 16; i++)
if (i != 4)
eahd->descTag.tagChecksum +=
((uint8_t *) & (eahd->descTag))[i];
eahd->descTag.tagChecksum += ((uint8_t *)&(eahd->descTag))[i];
UDF_I_LENEATTR(inode) += size;
return (struct genericFormat *)&ea[offset];
}
if (loc & 0x02) {
}
return NULL;
}
@ -163,8 +152,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
/* check checksum/crc */
if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD ||
le32_to_cpu(eahd->descTag.tagLocation) !=
UDF_I_LOCATION(inode).logicalBlockNum) {
le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) {
return NULL;
}
@ -177,13 +165,13 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
while (offset < UDF_I_LENEATTR(inode)) {
gaf = (struct genericFormat *)&ea[offset];
if (le32_to_cpu(gaf->attrType) == type
&& gaf->attrSubtype == subtype)
if (le32_to_cpu(gaf->attrType) == type && gaf->attrSubtype == subtype)
return gaf;
else
offset += le32_to_cpu(gaf->attrLength);
}
}
return NULL;
}
@ -216,23 +204,22 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
return NULL;
}
tag_p = (tag *) (bh->b_data);
tag_p = (tag *)(bh->b_data);
*ident = le16_to_cpu(tag_p->tagIdent);
if (location != le32_to_cpu(tag_p->tagLocation)) {
udf_debug("location mismatch block %u, tag %u != %u\n",
block + UDF_SB_SESSION(sb),
le32_to_cpu(tag_p->tagLocation), location);
block + UDF_SB_SESSION(sb), le32_to_cpu(tag_p->tagLocation), location);
goto error_out;
}
/* Verify the tag checksum */
checksum = 0U;
for (i = 0; i < 4; i++)
checksum += (uint8_t) (bh->b_data[i]);
checksum += (uint8_t)(bh->b_data[i]);
for (i = 5; i < 16; i++)
checksum += (uint8_t) (bh->b_data[i]);
checksum += (uint8_t)(bh->b_data[i]);
if (checksum != tag_p->tagChecksum) {
printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
goto error_out;
@ -249,16 +236,14 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
/* Verify the descriptor CRC */
if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize ||
le16_to_cpu(tag_p->descCRC) == udf_crc(bh->b_data + sizeof(tag),
le16_to_cpu(tag_p->
descCRCLength),
0)) {
le16_to_cpu(tag_p->descCRCLength), 0)) {
return bh;
}
udf_debug("Crc failure block %d: crc = %d, crclen = %d\n",
block + UDF_SB_SESSION(sb), le16_to_cpu(tag_p->descCRC),
le16_to_cpu(tag_p->descCRCLength));
error_out:
error_out:
brelse(bh);
return NULL;
}
@ -272,7 +257,7 @@ struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
void udf_update_tag(char *data, int length)
{
tag *tptr = (tag *) data;
tag *tptr = (tag *)data;
int i;
length -= sizeof(tag);
@ -283,13 +268,13 @@ void udf_update_tag(char *data, int length)
for (i = 0; i < 16; i++)
if (i != 4)
tptr->tagChecksum += (uint8_t) (data[i]);
tptr->tagChecksum += (uint8_t)(data[i]);
}
void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
uint32_t loc, int length)
{
tag *tptr = (tag *) data;
tag *tptr = (tag *)data;
tptr->tagIdent = cpu_to_le16(ident);
tptr->descVersion = cpu_to_le16(version);
tptr->tagSerialNum = cpu_to_le16(snum);

408
fs/udf/namei.c
View File

@ -37,6 +37,7 @@ static inline int udf_match(int len1, const char *name1, int len2,
{
if (len1 != len2)
return 0;
return !memcmp(name1, name2, len1);
}
@ -52,7 +53,7 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse);
uint8_t lfi = cfi->lengthFileIdent;
int padlen = fibh->eoffset - fibh->soffset - liu - lfi -
sizeof(struct fileIdentDesc);
sizeof(struct fileIdentDesc);
int adinicb = 0;
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
@ -61,85 +62,75 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
offset = fibh->soffset + sizeof(struct fileIdentDesc);
if (impuse) {
if (adinicb || (offset + liu < 0))
memcpy((uint8_t *) sfi->impUse, impuse, liu);
else if (offset >= 0)
if (adinicb || (offset + liu < 0)) {
memcpy((uint8_t *)sfi->impUse, impuse, liu);
} else if (offset >= 0) {
memcpy(fibh->ebh->b_data + offset, impuse, liu);
else {
memcpy((uint8_t *) sfi->impUse, impuse, -offset);
memcpy(fibh->ebh->b_data, impuse - offset,
liu + offset);
} else {
memcpy((uint8_t *)sfi->impUse, impuse, -offset);
memcpy(fibh->ebh->b_data, impuse - offset, liu + offset);
}
}
offset += liu;
if (fileident) {
if (adinicb || (offset + lfi < 0))
memcpy((uint8_t *) sfi->fileIdent + liu, fileident,
lfi);
else if (offset >= 0)
if (adinicb || (offset + lfi < 0)) {
memcpy((uint8_t *)sfi->fileIdent + liu, fileident, lfi);
} else if (offset >= 0) {
memcpy(fibh->ebh->b_data + offset, fileident, lfi);
else {
memcpy((uint8_t *) sfi->fileIdent + liu, fileident,
-offset);
memcpy(fibh->ebh->b_data, fileident - offset,
lfi + offset);
} else {
memcpy((uint8_t *)sfi->fileIdent + liu, fileident, -offset);
memcpy(fibh->ebh->b_data, fileident - offset, lfi + offset);
}
}
offset += lfi;
if (adinicb || (offset + padlen < 0))
memset((uint8_t *) sfi->padding + liu + lfi, 0x00, padlen);
else if (offset >= 0)
if (adinicb || (offset + padlen < 0)) {
memset((uint8_t *)sfi->padding + liu + lfi, 0x00, padlen);
} else if (offset >= 0) {
memset(fibh->ebh->b_data + offset, 0x00, padlen);
else {
memset((uint8_t *) sfi->padding + liu + lfi, 0x00, -offset);
} else {
memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset);
memset(fibh->ebh->b_data, 0x00, padlen + offset);
}
crc =
udf_crc((uint8_t *) cfi + sizeof(tag),
sizeof(struct fileIdentDesc) - sizeof(tag), 0);
crc = udf_crc((uint8_t *)cfi + sizeof(tag),
sizeof(struct fileIdentDesc) - sizeof(tag), 0);
if (fibh->sbh == fibh->ebh)
crc = udf_crc((uint8_t *) sfi->impUse,
crclen + sizeof(tag) -
sizeof(struct fileIdentDesc), crc);
else if (sizeof(struct fileIdentDesc) >= -fibh->soffset)
crc =
udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) +
fibh->soffset,
crclen + sizeof(tag) - sizeof(struct fileIdentDesc),
crc);
else {
crc = udf_crc((uint8_t *) sfi->impUse,
-fibh->soffset - sizeof(struct fileIdentDesc),
crc);
if (fibh->sbh == fibh->ebh) {
crc = udf_crc((uint8_t *)sfi->impUse,
crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc);
} else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) {
crc = udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) + fibh->soffset,
crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc);
} else {
crc = udf_crc((uint8_t *)sfi->impUse,
-fibh->soffset - sizeof(struct fileIdentDesc), crc);
crc = udf_crc(fibh->ebh->b_data, fibh->eoffset, crc);
}
cfi->descTag.descCRC = cpu_to_le16(crc);
cfi->descTag.descCRCLength = cpu_to_le16(crclen);
for (i = 0; i < 16; i++)
for (i = 0; i < 16; i++) {
if (i != 4)
checksum += ((uint8_t *) & cfi->descTag)[i];
checksum += ((uint8_t *)&cfi->descTag)[i];
}
cfi->descTag.tagChecksum = checksum;
if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset))
memcpy((uint8_t *) sfi, (uint8_t *) cfi,
sizeof(struct fileIdentDesc));
else {
memcpy((uint8_t *) sfi, (uint8_t *) cfi, -fibh->soffset);
memcpy(fibh->ebh->b_data, (uint8_t *) cfi - fibh->soffset,
if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) {
memcpy((uint8_t *)sfi, (uint8_t *)cfi, sizeof(struct fileIdentDesc));
} else {
memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset);
memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset,
sizeof(struct fileIdentDesc) + fibh->soffset);
}
if (adinicb)
if (adinicb) {
mark_inode_dirty(inode);
else {
} else {
if (fibh->sbh != fibh->ebh)
mark_buffer_dirty_inode(fibh->ebh, inode);
mark_buffer_dirty_inode(fibh->sbh, inode);
@ -163,26 +154,25 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
kernel_lb_addr eloc;
uint32_t elen;
sector_t offset;
struct extent_position epos = { NULL, 0, {0, 0} };
struct extent_position epos = {};
size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
f_pos = (udf_ext0_offset(dir) >> 2);
fibh->soffset = fibh->eoffset =
(f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
fibh->sbh = fibh->ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen,
&offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
} else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad);
} else
} else {
offset = 0;
}
if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) {
brelse(epos.bh);
@ -196,7 +186,6 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
while ((f_pos < size)) {
fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
&elen, &offset);
if (!fi) {
if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh);
@ -213,20 +202,14 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
} else {
int poffset; /* Unpaded ending offset */
poffset =
fibh->soffset + sizeof(struct fileIdentDesc) + liu +
lfi;
poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi;
if (poffset >= lfi)
nameptr =
(uint8_t *) (fibh->ebh->b_data + poffset -
lfi);
else {
if (poffset >= lfi) {
nameptr = (uint8_t *)(fibh->ebh->b_data + poffset - lfi);
} else {
nameptr = fname;
memcpy(nameptr, fi->fileIdent + liu,
lfi - poffset);
memcpy(nameptr + lfi - poffset,
fibh->ebh->b_data, poffset);
memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
}
}
@ -244,18 +227,18 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
continue;
if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi))) {
if (udf_match
(flen, fname, dentry->d_name.len,
dentry->d_name.name)) {
if (udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) {
brelse(epos.bh);
return fi;
}
}
}
if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh);
brelse(fibh->sbh);
brelse(epos.bh);
return NULL;
}
@ -306,15 +289,19 @@ static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
#ifdef UDF_RECOVERY
/* temporary shorthand for specifying files by inode number */
if (!strncmp(dentry->d_name.name, ".B=", 3)) {
kernel_lb_addr lb =
{ 0, simple_strtoul(dentry->d_name.name + 3, NULL, 0) };
kernel_lb_addr lb = {
.logicalBlockNum = 0,
.partitionReferenceNum = simple_strtoul(dentry->d_name.name + 3,
NULL, 0),
};
inode = udf_iget(dir->i_sb, lb);
if (!inode) {
unlock_kernel();
return ERR_PTR(-EACCES);
}
} else
#endif /* UDF_RECOVERY */
}
else
#endif /* UDF_RECOVERY */
if (udf_find_entry(dir, dentry, &fibh, &cfi)) {
if (fibh.sbh != fibh.ebh)
@ -329,6 +316,7 @@ static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
}
unlock_kernel();
d_add(dentry, inode);
return NULL;
}
@ -352,7 +340,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
kernel_lb_addr eloc;
uint32_t elen;
sector_t offset;
struct extent_position epos = { NULL, 0, {0, 0} };
struct extent_position epos = {};
sb = dir->i_sb;
@ -361,36 +349,33 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
*err = -EINVAL;
return NULL;
}
if (!
(namelen =
udf_put_filename(sb, dentry->d_name.name, name,
dentry->d_name.len))) {
if (!(namelen = udf_put_filename(sb, dentry->d_name.name, name,
dentry->d_name.len))) {
*err = -ENAMETOOLONG;
return NULL;
}
} else
} else {
namelen = 0;
}
nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;
f_pos = (udf_ext0_offset(dir) >> 2);
fibh->soffset = fibh->eoffset =
(f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
fibh->sbh = fibh->ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen,
&offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
} else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad);
} else
} else {
offset = 0;
}
if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) {
brelse(epos.bh);
@ -423,40 +408,33 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
liu = le16_to_cpu(cfi->lengthOfImpUse);
lfi = cfi->lengthFileIdent;
if (fibh->sbh == fibh->ebh)
if (fibh->sbh == fibh->ebh) {
nameptr = fi->fileIdent + liu;
else {
} else {
int poffset; /* Unpaded ending offset */
poffset =
fibh->soffset + sizeof(struct fileIdentDesc) + liu +
lfi;
poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi;
if (poffset >= lfi)
nameptr =
(char *)(fibh->ebh->b_data + poffset - lfi);
else {
if (poffset >= lfi) {
nameptr = (char *)(fibh->ebh->b_data + poffset - lfi);
} else {
nameptr = fname;
memcpy(nameptr, fi->fileIdent + liu,
lfi - poffset);
memcpy(nameptr + lfi - poffset,
fibh->ebh->b_data, poffset);
memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
}
}
if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
if (((sizeof(struct fileIdentDesc) + liu + lfi +
3) & ~3) == nfidlen) {
if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen) {
brelse(epos.bh);
cfi->descTag.tagSerialNum = cpu_to_le16(1);
cfi->fileVersionNum = cpu_to_le16(1);
cfi->fileCharacteristics = 0;
cfi->lengthFileIdent = namelen;
cfi->lengthOfImpUse = cpu_to_le16(0);
if (!udf_write_fi
(dir, cfi, fi, fibh, NULL, name))
if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
return fi;
else {
} else {
*err = -EIO;
return NULL;
}
@ -467,8 +445,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
continue;
if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi)) &&
udf_match(flen, fname, dentry->d_name.len,
dentry->d_name.name)) {
udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) {
if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh);
brelse(fibh->sbh);
@ -478,7 +455,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
}
}
add:
add:
f_pos += nfidlen;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&
@ -491,14 +468,11 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh);
brelse(fibh->sbh);
if (!
(fibh->sbh = fibh->ebh =
udf_expand_dir_adinicb(dir, &block, err)))
if (!(fibh->sbh = fibh->ebh = udf_expand_dir_adinicb(dir, &block, err)))
return NULL;
epos.block = UDF_I_LOCATION(dir);
eloc.logicalBlockNum = block;
eloc.partitionReferenceNum =
UDF_I_LOCATION(dir).partitionReferenceNum;
eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
elen = dir->i_sb->s_blocksize;
epos.offset = udf_file_entry_alloc_offset(dir);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
@ -517,16 +491,13 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
block = UDF_I_LOCATION(dir).logicalBlockNum;
fi = (struct fileIdentDesc *)(UDF_I_DATA(dir) +
fibh->soffset -
fi = (struct fileIdentDesc *)(UDF_I_DATA(dir) + fibh->soffset -
udf_ext0_offset(dir) +
UDF_I_LENEATTR(dir));
} else {
block = eloc.logicalBlockNum + ((elen - 1) >>
dir->i_sb->
s_blocksize_bits);
fi = (struct fileIdentDesc *)(fibh->sbh->b_data +
fibh->soffset);
dir->i_sb->s_blocksize_bits);
fi = (struct fileIdentDesc *)(fibh->sbh->b_data + fibh->soffset);
}
} else {
fibh->soffset = fibh->eoffset - sb->s_blocksize;
@ -538,42 +509,36 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
block = eloc.logicalBlockNum + ((elen - 1) >>
dir->i_sb->s_blocksize_bits);
if (!
(fibh->ebh =
udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
1, err))) {
fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err);
if (!fibh->ebh) {
brelse(epos.bh);
brelse(fibh->sbh);
return NULL;
}
if (!(fibh->soffset)) {
if (!fibh->soffset) {
if (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
(EXT_RECORDED_ALLOCATED >> 30)) {
block = eloc.logicalBlockNum + ((elen - 1) >>
dir->i_sb->
s_blocksize_bits);
} else
dir->i_sb->s_blocksize_bits);
} else {
block++;
}
brelse(fibh->sbh);
fibh->sbh = fibh->ebh;
fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
} else {
fi = (struct fileIdentDesc *)
(fibh->sbh->b_data + sb->s_blocksize +
fibh->soffset);
(fibh->sbh->b_data + sb->s_blocksize + fibh->soffset);
}
}
memset(cfi, 0, sizeof(struct fileIdentDesc));
if (UDF_SB_UDFREV(sb) >= 0x0200)
udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block,
sizeof(tag));
udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, sizeof(tag));
else
udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block,
sizeof(tag));
udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, sizeof(tag));
cfi->fileVersionNum = cpu_to_le16(1);
cfi->lengthFileIdent = namelen;
cfi->lengthOfImpUse = cpu_to_le16(0);
@ -599,8 +564,10 @@ static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
struct fileIdentDesc *cfi)
{
cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED;
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
memset(&(cfi->icb), 0x00, sizeof(long_ad));
return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL);
}
@ -637,8 +604,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
}
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
*(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
mark_inode_dirty(dir);
@ -648,6 +615,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
brelse(fibh.sbh);
unlock_kernel();
d_instantiate(dentry, inode);
return 0;
}
@ -679,8 +647,8 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
}
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
*(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
mark_inode_dirty(dir);
@ -692,7 +660,8 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
brelse(fibh.sbh);
d_instantiate(dentry, inode);
err = 0;
out:
out:
unlock_kernel();
return err;
}
@ -725,10 +694,9 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
inode->i_nlink = 2;
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(dir));
*(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
cfi.fileCharacteristics =
FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
cfi.fileCharacteristics = FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
brelse(fibh.sbh);
inode->i_mode = S_IFDIR | mode;
@ -744,8 +712,8 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
}
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
*(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
inc_nlink(dir);
@ -755,7 +723,8 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
brelse(fibh.ebh);
brelse(fibh.sbh);
err = 0;
out:
out:
unlock_kernel();
return err;
}
@ -770,26 +739,25 @@ static int empty_dir(struct inode *dir)
kernel_lb_addr eloc;
uint32_t elen;
sector_t offset;
struct extent_position epos = { NULL, 0, {0, 0} };
struct extent_position epos = {};
f_pos = (udf_ext0_offset(dir) >> 2);
fibh.soffset = fibh.eoffset =
(f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
fibh.soffset = fibh.eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
fibh.sbh = fibh.ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen,
&offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
} else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad);
} else
} else {
offset = 0;
}
if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) {
brelse(epos.bh);
@ -803,7 +771,6 @@ static int empty_dir(struct inode *dir)
while ((f_pos < size)) {
fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc,
&elen, &offset);
if (!fi) {
if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh);
@ -812,8 +779,8 @@ static int empty_dir(struct inode *dir)
return 0;
}
if (cfi.lengthFileIdent
&& (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) {
if (cfi.lengthFileIdent &&
(cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) {
if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh);
brelse(fibh.sbh);
@ -821,10 +788,12 @@ static int empty_dir(struct inode *dir)
return 0;
}
}
if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh);
brelse(fibh.sbh);
brelse(epos.bh);
return 1;
}
@ -859,15 +828,15 @@ static int udf_rmdir(struct inode *dir, struct dentry *dentry)
clear_nlink(inode);
inode->i_size = 0;
inode_dec_link_count(dir);
inode->i_ctime = dir->i_ctime = dir->i_mtime =
current_fs_time(dir->i_sb);
inode->i_ctime = dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
mark_inode_dirty(dir);
end_rmdir:
end_rmdir:
if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh);
brelse(fibh.sbh);
out:
out:
unlock_kernel();
return retval;
}
@ -906,11 +875,12 @@ static int udf_unlink(struct inode *dir, struct dentry *dentry)
inode->i_ctime = dir->i_ctime;
retval = 0;
end_unlink:
end_unlink:
if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh);
brelse(fibh.sbh);
out:
out:
unlock_kernel();
return retval;
}
@ -922,7 +892,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
struct pathComponent *pc;
char *compstart;
struct udf_fileident_bh fibh;
struct extent_position epos = { NULL, 0, {0, 0} };
struct extent_position epos = {};
int eoffset, elen = 0;
struct fileIdentDesc *fi;
struct fileIdentDesc cfi;
@ -945,26 +915,22 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
uint32_t elen;
block = udf_new_block(inode->i_sb, inode,
UDF_I_LOCATION(inode).
partitionReferenceNum,
UDF_I_LOCATION(inode).logicalBlockNum,
&err);
UDF_I_LOCATION(inode).partitionReferenceNum,
UDF_I_LOCATION(inode).logicalBlockNum, &err);
if (!block)
goto out_no_entry;
epos.block = UDF_I_LOCATION(inode);
epos.offset = udf_file_entry_alloc_offset(inode);
epos.bh = NULL;
eloc.logicalBlockNum = block;
eloc.partitionReferenceNum =
UDF_I_LOCATION(inode).partitionReferenceNum;
eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
elen = inode->i_sb->s_blocksize;
UDF_I_LENEXTENTS(inode) = elen;
udf_add_aext(inode, &epos, eloc, elen, 0);
brelse(epos.bh);
block = udf_get_pblock(inode->i_sb, block,
UDF_I_LOCATION(inode).
partitionReferenceNum, 0);
UDF_I_LOCATION(inode).partitionReferenceNum, 0);
epos.bh = udf_tread(inode->i_sb, block);
lock_buffer(epos.bh);
memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
@ -972,8 +938,9 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
unlock_buffer(epos.bh);
mark_buffer_dirty_inode(epos.bh, inode);
ea = epos.bh->b_data + udf_ext0_offset(inode);
} else
} else {
ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
}
eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
pc = (struct pathComponent *)ea;
@ -1010,20 +977,17 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
if (compstart[0] == '.') {
if ((symname - compstart) == 1)
pc->componentType = 4;
else if ((symname - compstart) == 2
&& compstart[1] == '.')
else if ((symname - compstart) == 2 && compstart[1] == '.')
pc->componentType = 3;
}
if (pc->componentType == 5) {
if (!
(namelen =
udf_put_filename(inode->i_sb, compstart, name,
symname - compstart)))
namelen = udf_put_filename(inode->i_sb, compstart, name,
symname - compstart);
if (!namelen)
goto out_no_entry;
if (elen + sizeof(struct pathComponent) + namelen >
eoffset)
if (elen + sizeof(struct pathComponent) + namelen > eoffset)
goto out_no_entry;
else
pc->lengthComponentIdent = namelen;
@ -1053,12 +1017,10 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
if (UDF_SB_LVIDBH(inode->i_sb)) {
struct logicalVolHeaderDesc *lvhd;
uint64_t uniqueID;
lvhd =
(struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->
logicalVolContentsUse);
lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
uniqueID = le64_to_cpu(lvhd->uniqueID);
*(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
if (!(++uniqueID & 0x00000000FFFFFFFFUL))
uniqueID += 16;
lvhd->uniqueID = cpu_to_le64(uniqueID);
@ -1074,11 +1036,11 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
d_instantiate(dentry, inode);
err = 0;
out:
out:
unlock_kernel();
return err;
out_no_entry:
out_no_entry:
inode_dec_link_count(inode);
iput(inode);
goto out;
@ -1107,12 +1069,10 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
if (UDF_SB_LVIDBH(inode->i_sb)) {
struct logicalVolHeaderDesc *lvhd;
uint64_t uniqueID;
lvhd =
(struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->
logicalVolContentsUse);
lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
uniqueID = le64_to_cpu(lvhd->uniqueID);
*(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
if (!(++uniqueID & 0x00000000FFFFFFFFUL))
uniqueID += 16;
lvhd->uniqueID = cpu_to_le64(uniqueID);
@ -1122,6 +1082,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
mark_inode_dirty(dir);
}
if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh);
brelse(fibh.sbh);
@ -1131,6 +1092,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
atomic_inc(&inode->i_count);
d_instantiate(dentry, inode);
unlock_kernel();
return 0;
}
@ -1143,8 +1105,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *old_inode = old_dentry->d_inode;
struct inode *new_inode = new_dentry->d_inode;
struct udf_fileident_bh ofibh, nfibh;
struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi =
NULL, ocfi, ncfi;
struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL, ocfi, ncfi;
struct buffer_head *dir_bh = NULL;
int retval = -ENOENT;
kernel_lb_addr tloc;
@ -1181,36 +1142,27 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) {
dir_fi = udf_get_fileident(UDF_I_DATA(old_inode) -
(UDF_I_EFE(old_inode) ?
sizeof(struct
extendedFileEntry) :
sizeof(struct extendedFileEntry) :
sizeof(struct fileEntry)),
old_inode->i_sb->s_blocksize,
&offset);
old_inode->i_sb->s_blocksize, &offset);
} else {
dir_bh = udf_bread(old_inode, 0, 0, &retval);
if (!dir_bh)
goto end_rename;
dir_fi =
udf_get_fileident(dir_bh->b_data,
old_inode->i_sb->s_blocksize,
&offset);
dir_fi = udf_get_fileident(dir_bh->b_data, old_inode->i_sb->s_blocksize, &offset);
}
if (!dir_fi)
goto end_rename;
tloc = lelb_to_cpu(dir_fi->icb.extLocation);
if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0)
!= old_dir->i_ino)
if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0) != old_dir->i_ino)
goto end_rename;
retval = -EMLINK;
if (!new_inode
&& new_dir->i_nlink >=
(256 << sizeof(new_dir->i_nlink)) - 1)
if (!new_inode && new_dir->i_nlink >= (256 << sizeof(new_dir->i_nlink)) - 1)
goto end_rename;
}
if (!nfi) {
nfi =
udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval);
nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval);
if (!nfi)
goto end_rename;
}
@ -1244,13 +1196,12 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
if (dir_fi) {
dir_fi->icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(new_dir));
udf_update_tag((char *)dir_fi, (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) {
mark_inode_dirty(old_inode);
} else
} else {
mark_buffer_dirty_inode(dir_bh, old_inode);
}
inode_dec_link_count(old_dir);
if (new_inode) {
inode_dec_link_count(new_inode);
@ -1268,7 +1219,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
retval = 0;
end_rename:
end_rename:
brelse(dir_bh);
if (nfi) {
if (nfibh.sbh != nfibh.ebh)
@ -1276,17 +1227,18 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
brelse(nfibh.sbh);
}
unlock_kernel();
return retval;
}
const struct inode_operations udf_dir_inode_operations = {
.lookup = udf_lookup,
.create = udf_create,
.link = udf_link,
.unlink = udf_unlink,
.symlink = udf_symlink,
.mkdir = udf_mkdir,
.rmdir = udf_rmdir,
.mknod = udf_mknod,
.rename = udf_rename,
.lookup = udf_lookup,
.create = udf_create,
.link = udf_link,
.unlink = udf_unlink,
.symlink = udf_symlink,
.mkdir = udf_mkdir,
.rmdir = udf_rmdir,
.mknod = udf_mknod,
.rename = udf_rename,
};

164
fs/udf/osta_udf.h
View File

@ -66,64 +66,64 @@
#define IS_DF_SOFT_WRITE_PROTECT 0x02
struct UDFIdentSuffix {
__le16 UDFRevision;
uint8_t OSClass;
uint8_t OSIdentifier;
uint8_t reserved[4];
__le16 UDFRevision;
uint8_t OSClass;
uint8_t OSIdentifier;
uint8_t reserved[4];
} __attribute__ ((packed));
struct impIdentSuffix {
uint8_t OSClass;
uint8_t OSIdentifier;
uint8_t reserved[6];
uint8_t OSClass;
uint8_t OSIdentifier;
uint8_t reserved[6];
} __attribute__ ((packed));
struct appIdentSuffix {
uint8_t impUse[8];
uint8_t impUse[8];
} __attribute__ ((packed));
/* Logical Volume Integrity Descriptor (UDF 2.50 2.2.6) */
/* Implementation Use (UDF 2.50 2.2.6.4) */
struct logicalVolIntegrityDescImpUse {
regid impIdent;
__le32 numFiles;
__le32 numDirs;
__le16 minUDFReadRev;
__le16 minUDFWriteRev;
__le16 maxUDFWriteRev;
uint8_t impUse[0];
regid impIdent;
__le32 numFiles;
__le32 numDirs;
__le16 minUDFReadRev;
__le16 minUDFWriteRev;
__le16 maxUDFWriteRev;
uint8_t impUse[0];
} __attribute__ ((packed));
/* Implementation Use Volume Descriptor (UDF 2.50 2.2.7) */
/* Implementation Use (UDF 2.50 2.2.7.2) */
struct impUseVolDescImpUse {
charspec LVICharset;
dstring logicalVolIdent[128];
dstring LVInfo1[36];
dstring LVInfo2[36];
dstring LVInfo3[36];
regid impIdent;
uint8_t impUse[128];
charspec LVICharset;
dstring logicalVolIdent[128];
dstring LVInfo1[36];
dstring LVInfo2[36];
dstring LVInfo3[36];
regid impIdent;
uint8_t impUse[128];
} __attribute__ ((packed));
struct udfPartitionMap2 {
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t reserved1[2];
regid partIdent;
__le16 volSeqNum;
__le16 partitionNum;
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t reserved1[2];
regid partIdent;
__le16 volSeqNum;
__le16 partitionNum;
} __attribute__ ((packed));
/* Virtual Partition Map (UDF 2.50 2.2.8) */
struct virtualPartitionMap {
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t reserved1[2];
regid partIdent;
__le16 volSeqNum;
__le16 partitionNum;
uint8_t reserved2[24];
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t reserved1[2];
regid partIdent;
__le16 volSeqNum;
__le16 partitionNum;
uint8_t reserved2[24];
} __attribute__ ((packed));
/* Sparable Partition Map (UDF 2.50 2.2.9) */
@ -143,62 +143,62 @@ struct sparablePartitionMap {
/* Metadata Partition Map (UDF 2.4.0 2.2.10) */
struct metadataPartitionMap {
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t reserved1[2];
regid partIdent;
__le16 volSeqNum;
__le16 partitionNum;
__le32 metadataFileLoc;
__le32 metadataMirrorFileLoc;
__le32 metadataBitmapFileLoc;
__le32 allocUnitSize;
__le16 alignUnitSize;
uint8_t flags;
uint8_t reserved2[5];
uint8_t partitionMapType;
uint8_t partitionMapLength;
uint8_t reserved1[2];
regid partIdent;
__le16 volSeqNum;
__le16 partitionNum;
__le32 metadataFileLoc;
__le32 metadataMirrorFileLoc;
__le32 metadataBitmapFileLoc;
__le32 allocUnitSize;
__le16 alignUnitSize;
uint8_t flags;
uint8_t reserved2[5];
} __attribute__ ((packed));
/* Virtual Allocation Table (UDF 1.5 2.2.10) */
struct virtualAllocationTable15 {
__le32 VirtualSector[0];
regid vatIdent;
__le32 previousVATICBLoc;
__le32 VirtualSector[0];
regid vatIdent;
__le32 previousVATICBLoc;
} __attribute__ ((packed));
#define ICBTAG_FILE_TYPE_VAT15 0x00U
/* Virtual Allocation Table (UDF 2.50 2.2.11) */
struct virtualAllocationTable20 {
__le16 lengthHeader;
__le16 lengthImpUse;
dstring logicalVolIdent[128];
__le32 previousVATICBLoc;
__le32 numFiles;
__le32 numDirs;
__le16 minReadRevision;
__le16 minWriteRevision;
__le16 maxWriteRevision;
__le16 reserved;
uint8_t impUse[0];
__le32 vatEntry[0];
__le16 lengthHeader;
__le16 lengthImpUse;
dstring logicalVolIdent[128];
__le32 previousVATICBLoc;
__le32 numFiles;
__le32 numDirs;
__le16 minReadRevision;
__le16 minWriteRevision;
__le16 maxWriteRevision;
__le16 reserved;
uint8_t impUse[0];
__le32 vatEntry[0];
} __attribute__ ((packed));
#define ICBTAG_FILE_TYPE_VAT20 0xF8U
/* Sparing Table (UDF 2.50 2.2.12) */
struct sparingEntry {
__le32 origLocation;
__le32 mappedLocation;
__le32 origLocation;
__le32 mappedLocation;
} __attribute__ ((packed));
struct sparingTable {
tag descTag;
regid sparingIdent;
__le16 reallocationTableLen;
__le16 reserved;
__le32 sequenceNum;
tag descTag;
regid sparingIdent;
__le16 reallocationTableLen;
__le16 reserved;
__le32 sequenceNum;
struct sparingEntry
mapEntry[0];
mapEntry[0];
} __attribute__ ((packed));
/* Metadata File (and Metadata Mirror File) (UDF 2.50 2.2.13.1) */
@ -208,8 +208,8 @@ struct sparingTable {
/* struct long_ad ICB - ADImpUse (UDF 2.50 2.2.4.3) */
struct allocDescImpUse {
__le16 flags;
uint8_t impUse[4];
__le16 flags;
uint8_t impUse[4];
} __attribute__ ((packed));
#define AD_IU_EXT_ERASED 0x0001
@ -220,23 +220,23 @@ struct allocDescImpUse {
/* Implementation Use Extended Attribute (UDF 2.50 3.3.4.5) */
/* FreeEASpace (UDF 2.50 3.3.4.5.1.1) */
struct freeEaSpace {
__le16 headerChecksum;
uint8_t freeEASpace[0];
__le16 headerChecksum;
uint8_t freeEASpace[0];
} __attribute__ ((packed));
/* DVD Copyright Management Information (UDF 2.50 3.3.4.5.1.2) */
struct DVDCopyrightImpUse {
__le16 headerChecksum;
uint8_t CGMSInfo;
uint8_t dataType;
uint8_t protectionSystemInfo[4];
__le16 headerChecksum;
uint8_t CGMSInfo;
uint8_t dataType;
uint8_t protectionSystemInfo[4];
} __attribute__ ((packed));
/* Application Use Extended Attribute (UDF 2.50 3.3.4.6) */
/* FreeAppEASpace (UDF 2.50 3.3.4.6.1) */
struct freeAppEASpace {
__le16 headerChecksum;
uint8_t freeEASpace[0];
__le16 headerChecksum;
uint8_t freeEASpace[0];
} __attribute__ ((packed));
/* UDF Defined System Stream (UDF 2.50 3.3.7) */
@ -276,4 +276,4 @@ struct freeAppEASpace {
#define UDF_OS_ID_BEOS 0x00U
#define UDF_OS_ID_WINCE 0x00U
#endif /* _OSTA_UDF_H */
#endif /* _OSTA_UDF_H */

212
fs/udf/partition.c
View File

@ -14,7 +14,7 @@
*
* HISTORY
*
* 12/06/98 blf Created file.
* 12/06/98 blf Created file.
*
*/
@ -32,19 +32,17 @@ inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
uint16_t partition, uint32_t offset)
{
if (partition >= UDF_SB_NUMPARTS(sb)) {
udf_debug
("block=%d, partition=%d, offset=%d: invalid partition\n",
block, partition, offset);
udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
block, partition, offset);
return 0xFFFFFFFF;
}
if (UDF_SB_PARTFUNC(sb, partition))
return UDF_SB_PARTFUNC(sb, partition) (sb, block, partition,
offset);
return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);
else
return UDF_SB_PARTROOT(sb, partition) + block + offset;
}
uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
uint16_t partition, uint32_t offset)
{
struct buffer_head *bh = NULL;
@ -52,14 +50,11 @@ uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
uint32_t index;
uint32_t loc;
index =
(sb->s_blocksize -
UDF_SB_TYPEVIRT(sb, partition).s_start_offset) / sizeof(uint32_t);
index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);
if (block > UDF_SB_TYPEVIRT(sb, partition).s_num_entries) {
udf_debug
("Trying to access block beyond end of VAT (%d max %d)\n",
block, UDF_SB_TYPEVIRT(sb, partition).s_num_entries);
if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {
udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);
return 0xFFFFFFFF;
}
@ -69,10 +64,7 @@ uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
index = block % (sb->s_blocksize / sizeof(uint32_t));
} else {
newblock = 0;
index =
UDF_SB_TYPEVIRT(sb,
partition).s_start_offset /
sizeof(uint32_t) + block;
index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
}
loc = udf_block_map(UDF_SB_VAT(sb), newblock);
@ -83,7 +75,7 @@ uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
return 0xFFFFFFFF;
}
loc = le32_to_cpu(((__le32 *) bh->b_data)[index]);
loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);
brelse(bh);
@ -93,8 +85,8 @@ uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
}
return udf_get_pblock(sb, loc,
UDF_I_LOCATION(UDF_SB_VAT(sb)).
partitionReferenceNum, offset);
UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum,
offset);
}
inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
@ -108,40 +100,29 @@ uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
{
int i;
struct sparingTable *st = NULL;
uint32_t packet =
(block + offset) & ~(UDF_SB_TYPESPAR(sb, partition).s_packet_len -
1);
uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);
for (i = 0; i < 4; i++) {
if (UDF_SB_TYPESPAR(sb, partition).s_spar_map[i] != NULL) {
st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,
partition).
s_spar_map[i]->b_data;
if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {
st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
break;
}
}
if (st) {
for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) {
if (le32_to_cpu(st->mapEntry[i].origLocation) >=
0xFFFFFFF0)
if (le32_to_cpu(st->mapEntry[i].origLocation) >= 0xFFFFFFF0) {
break;
else if (le32_to_cpu(st->mapEntry[i].origLocation) ==
packet) {
return le32_to_cpu(st->mapEntry[i].
mappedLocation) + ((block +
offset) &
(UDF_SB_TYPESPAR
(sb,
partition).
s_packet_len
- 1));
} else if (le32_to_cpu(st->mapEntry[i].origLocation) >
packet)
} else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {
return le32_to_cpu(st->mapEntry[i].mappedLocation) +
((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
} else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
break;
}
}
}
return UDF_SB_PARTROOT(sb, partition) + block + offset;
return UDF_SB_PARTROOT(sb,partition) + block + offset;
}
int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
@ -153,20 +134,14 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
int i, j, k, l;
for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
if (old_block > UDF_SB_PARTROOT(sb, i) &&
old_block < UDF_SB_PARTROOT(sb, i) + UDF_SB_PARTLEN(sb, i))
{
sdata = &UDF_SB_TYPESPAR(sb, i);
packet =
(old_block -
UDF_SB_PARTROOT(sb,
i)) & ~(sdata->s_packet_len - 1);
if (old_block > UDF_SB_PARTROOT(sb,i) &&
old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
sdata = &UDF_SB_TYPESPAR(sb,i);
packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);
for (j = 0; j < 4; j++) {
if (UDF_SB_TYPESPAR(sb, i).s_spar_map[j] !=
NULL) {
st = (struct sparingTable *)sdata->
s_spar_map[j]->b_data;
if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
break;
}
}
@ -174,122 +149,51 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
if (!st)
return 1;
for (k = 0; k < le16_to_cpu(st->reallocationTableLen);
k++) {
if (le32_to_cpu(st->mapEntry[k].origLocation) ==
0xFFFFFFFF) {
for (k = 0; k < le16_to_cpu(st->reallocationTableLen); k++) {
if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF) {
for (; j < 4; j++) {
if (sdata->s_spar_map[j]) {
st = (struct
sparingTable *)
sdata->
s_spar_map[j]->
b_data;
st->mapEntry[k].
origLocation =
cpu_to_le32(packet);
udf_update_tag((char *)
st,
sizeof
(struct
sparingTable)
+
le16_to_cpu
(st->
reallocationTableLen)
*
sizeof
(struct
sparingEntry));
mark_buffer_dirty
(sdata->
s_spar_map[j]);
st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
st->mapEntry[k].origLocation = cpu_to_le32(packet);
udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
mark_buffer_dirty(sdata->s_spar_map[j]);
}
}
*new_block =
le32_to_cpu(st->mapEntry[k].
mappedLocation) +
((old_block -
UDF_SB_PARTROOT(sb,
i)) & (sdata->
s_packet_len
- 1));
*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
return 0;
} else
if (le32_to_cpu
(st->mapEntry[k].origLocation) ==
packet) {
*new_block =
le32_to_cpu(st->mapEntry[k].
mappedLocation) +
((old_block -
UDF_SB_PARTROOT(sb,
i)) & (sdata->
s_packet_len
- 1));
} else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
return 0;
} else
if (le32_to_cpu
(st->mapEntry[k].origLocation) > packet)
} else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
break;
}
}
for (l = k; l < le16_to_cpu(st->reallocationTableLen);
l++) {
if (le32_to_cpu(st->mapEntry[l].origLocation) ==
0xFFFFFFFF) {
for (l = k; l < le16_to_cpu(st->reallocationTableLen); l++) {
if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF) {
for (; j < 4; j++) {
if (sdata->s_spar_map[j]) {
st = (struct
sparingTable *)
sdata->
s_spar_map[j]->
b_data;
mapEntry =
st->mapEntry[l];
mapEntry.origLocation =
cpu_to_le32(packet);
memmove(&st->
mapEntry[k + 1],
&st->
mapEntry[k],
(l -
k) *
sizeof(struct
sparingEntry));
st->mapEntry[k] =
mapEntry;
udf_update_tag((char *)
st,
sizeof
(struct
sparingTable)
+
le16_to_cpu
(st->
reallocationTableLen)
*
sizeof
(struct
sparingEntry));
mark_buffer_dirty
(sdata->
s_spar_map[j]);
st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
mapEntry = st->mapEntry[l];
mapEntry.origLocation = cpu_to_le32(packet);
memmove(&st->mapEntry[k + 1], &st->mapEntry[k], (l - k) * sizeof(struct sparingEntry));
st->mapEntry[k] = mapEntry;
udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
mark_buffer_dirty(sdata->s_spar_map[j]);
}
}
*new_block =
le32_to_cpu(st->mapEntry[k].
mappedLocation) +
((old_block -
UDF_SB_PARTROOT(sb,
i)) & (sdata->
s_packet_len
- 1));
*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
return 0;
}
}
return 1;
}
} /* if old_block */
}
if (i == UDF_SB_NUMPARTS(sb)) {
/* outside of partitions */
/* for now, fail =) */

1033
fs/udf/super.c
View File

File diff suppressed because it is too large Load Diff

14
fs/udf/symlink.c
View File

@ -11,7 +11,7 @@
* Each contributing author retains all rights to their own work.
*
* (C) 1998-2001 Ben Fennema
* (C) 1999 Stelias Computing Inc
* (C) 1999 Stelias Computing Inc
*
* HISTORY
*
@ -33,8 +33,7 @@
#include <linux/buffer_head.h>
#include "udf_i.h"
static void udf_pc_to_char(struct super_block *sb, char *from, int fromlen,
char *to)
static void udf_pc_to_char(struct super_block *sb, char *from, int fromlen, char *to)
{
struct pathComponent *pc;
int elen = 0;
@ -81,9 +80,9 @@ static int udf_symlink_filler(struct file *file, struct page *page)
char *p = kmap(page);
lock_kernel();
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
symlink = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
else {
} else {
bh = sb_bread(inode->i_sb, udf_block_map(inode, 0));
if (!bh)
@ -100,7 +99,8 @@ static int udf_symlink_filler(struct file *file, struct page *page)
kunmap(page);
unlock_page(page);
return 0;
out:
out:
unlock_kernel();
SetPageError(page);
kunmap(page);
@ -112,5 +112,5 @@ static int udf_symlink_filler(struct file *file, struct page *page)
* symlinks can't do much...
*/
const struct address_space_operations udf_symlink_aops = {
.readpage = udf_symlink_filler,
.readpage = udf_symlink_filler,
};

113
fs/udf/truncate.c
View File

@ -32,13 +32,11 @@ static void extent_trunc(struct inode *inode, struct extent_position *epos,
kernel_lb_addr eloc, int8_t etype, uint32_t elen,
uint32_t nelen)
{
kernel_lb_addr neloc = { 0, 0 };
int last_block =
(elen + inode->i_sb->s_blocksize -
1) >> inode->i_sb->s_blocksize_bits;
int first_block =
(nelen + inode->i_sb->s_blocksize -
1) >> inode->i_sb->s_blocksize_bits;
kernel_lb_addr neloc = {};
int last_block = (elen + inode->i_sb->s_blocksize - 1) >>
inode->i_sb->s_blocksize_bits;
int first_block = (nelen + inode->i_sb->s_blocksize - 1) >>
inode->i_sb->s_blocksize_bits;
if (nelen) {
if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
@ -70,7 +68,7 @@ static void extent_trunc(struct inode *inode, struct extent_position *epos,
*/
void udf_truncate_tail_extent(struct inode *inode)
{
struct extent_position epos = { NULL, 0, {0, 0} };
struct extent_position epos = {};
kernel_lb_addr eloc;
uint32_t elen, nelen;
uint64_t lbcount = 0;
@ -156,16 +154,16 @@ void udf_discard_prealloc(struct inode *inode)
extent_trunc(inode, &epos, eloc, etype, elen, 0);
if (!epos.bh) {
UDF_I_LENALLOC(inode) =
epos.offset - udf_file_entry_alloc_offset(inode);
epos.offset - udf_file_entry_alloc_offset(inode);
mark_inode_dirty(inode);
} else {
struct allocExtDesc *aed =
(struct allocExtDesc *)(epos.bh->b_data);
(struct allocExtDesc *)(epos.bh->b_data);
aed->lengthAllocDescs =
cpu_to_le32(epos.offset -
sizeof(struct allocExtDesc));
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
|| UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
cpu_to_le32(epos.offset -
sizeof(struct allocExtDesc));
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
udf_update_tag(epos.bh->b_data, epos.offset);
else
udf_update_tag(epos.bh->b_data,
@ -182,7 +180,7 @@ void udf_discard_prealloc(struct inode *inode)
void udf_truncate_extents(struct inode *inode)
{
struct extent_position epos;
kernel_lb_addr eloc, neloc = { 0, 0 };
kernel_lb_addr eloc, neloc = {};
uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc;
int8_t etype;
struct super_block *sb = inode->i_sb;
@ -198,9 +196,8 @@ void udf_truncate_extents(struct inode *inode)
BUG();
etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
byte_offset =
(offset << sb->s_blocksize_bits) +
(inode->i_size & (sb->s_blocksize - 1));
byte_offset = (offset << sb->s_blocksize_bits) +
(inode->i_size & (sb->s_blocksize - 1));
if (etype != -1) {
epos.offset -= adsize;
extent_trunc(inode, &epos, eloc, etype, elen, byte_offset);
@ -215,9 +212,7 @@ void udf_truncate_extents(struct inode *inode)
else
lenalloc -= sizeof(struct allocExtDesc);
while ((etype =
udf_current_aext(inode, &epos, &eloc, &elen,
0)) != -1) {
while ((etype = udf_current_aext(inode, &epos, &eloc, &elen, 0)) != -1) {
if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
udf_write_aext(inode, &epos, neloc, nelen, 0);
if (indirect_ext_len) {
@ -229,52 +224,35 @@ void udf_truncate_extents(struct inode *inode)
0, indirect_ext_len);
} else {
if (!epos.bh) {
UDF_I_LENALLOC(inode) =
lenalloc;
UDF_I_LENALLOC(inode) = lenalloc;
mark_inode_dirty(inode);
} else {
struct allocExtDesc *aed =
(struct allocExtDesc
*)(epos.bh->b_data);
(struct allocExtDesc *)(epos.bh->b_data);
aed->lengthAllocDescs =
cpu_to_le32(lenalloc);
if (!UDF_QUERY_FLAG
(sb, UDF_FLAG_STRICT)
|| UDF_SB_UDFREV(sb) >=
0x0201)
udf_update_tag(epos.bh->
b_data,
lenalloc
+
sizeof
(struct
allocExtDesc));
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
UDF_SB_UDFREV(sb) >= 0x0201)
udf_update_tag(epos.bh->b_data,
lenalloc +
sizeof(struct allocExtDesc));
else
udf_update_tag(epos.bh->
b_data,
sizeof
(struct
allocExtDesc));
mark_buffer_dirty_inode(epos.bh,
inode);
udf_update_tag(epos.bh->b_data,
sizeof(struct allocExtDesc));
mark_buffer_dirty_inode(epos.bh, inode);
}
}
brelse(epos.bh);
epos.offset = sizeof(struct allocExtDesc);
epos.block = eloc;
epos.bh =
udf_tread(sb,
udf_get_lb_pblock(sb, eloc, 0));
epos.bh = udf_tread(sb, udf_get_lb_pblock(sb, eloc, 0));
if (elen)
indirect_ext_len = (elen +
sb->s_blocksize -
1) >> sb->
s_blocksize_bits;
indirect_ext_len = (elen + sb->s_blocksize -1) >>
sb->s_blocksize_bits;
else
indirect_ext_len = 1;
} else {
extent_trunc(inode, &epos, eloc, etype, elen,
0);
extent_trunc(inode, &epos, eloc, etype, elen, 0);
epos.offset += adsize;
}
}
@ -292,16 +270,13 @@ void udf_truncate_extents(struct inode *inode)
struct allocExtDesc *aed =
(struct allocExtDesc *)(epos.bh->b_data);
aed->lengthAllocDescs = cpu_to_le32(lenalloc);
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT)
|| UDF_SB_UDFREV(sb) >= 0x0201)
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
UDF_SB_UDFREV(sb) >= 0x0201)
udf_update_tag(epos.bh->b_data,
lenalloc +
sizeof(struct
allocExtDesc));
lenalloc + sizeof(struct allocExtDesc));
else
udf_update_tag(epos.bh->b_data,
sizeof(struct
allocExtDesc));
sizeof(struct allocExtDesc));
mark_buffer_dirty_inode(epos.bh, inode);
}
}
@ -314,21 +289,14 @@ void udf_truncate_extents(struct inode *inode)
* no extent above inode->i_size => truncate is
* extending the file by 'offset' blocks.
*/
if ((!epos.bh
&& epos.offset ==
udf_file_entry_alloc_offset(inode)) || (epos.bh
&& epos.
offset ==
sizeof
(struct
allocExtDesc)))
{
if ((!epos.bh &&
epos.offset == udf_file_entry_alloc_offset(inode)) ||
(epos.bh && epos.offset == sizeof(struct allocExtDesc))) {
/* File has no extents at all or has empty last
* indirect extent! Create a fake extent... */
extent.extLocation.logicalBlockNum = 0;
extent.extLocation.partitionReferenceNum = 0;
extent.extLength =
EXT_NOT_RECORDED_NOT_ALLOCATED;
extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
} else {
epos.offset -= adsize;
etype = udf_next_aext(inode, &epos,
@ -337,10 +305,7 @@ void udf_truncate_extents(struct inode *inode)
extent.extLength |= etype << 30;
}
udf_extend_file(inode, &epos, &extent,
offset +
((inode->
i_size & (sb->s_blocksize - 1)) !=
0));
offset + ((inode->i_size & (sb->s_blocksize - 1)) != 0));
}
}
UDF_I_LENEXTENTS(inode) = inode->i_size;

2
fs/udf/udf_i.h
View File

@ -23,4 +23,4 @@ static inline struct udf_inode_info *UDF_I(struct inode *inode)
#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) */

26
fs/udf/udf_sb.h
View File

@ -20,8 +20,8 @@
#define UDF_FLAG_VARCONV 8
#define UDF_FLAG_NLS_MAP 9
#define UDF_FLAG_UTF8 10
#define UDF_FLAG_UID_FORGET 11 /* save -1 for uid to disk */
#define UDF_FLAG_UID_IGNORE 12 /* use sb uid instead of on disk uid */
#define UDF_FLAG_UID_FORGET 11 /* save -1 for uid to disk */
#define UDF_FLAG_UID_IGNORE 12 /* use sb uid instead of on disk uid */
#define UDF_FLAG_GID_FORGET 13
#define UDF_FLAG_GID_IGNORE 14
@ -41,8 +41,7 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
#define UDF_SB_FREE(X)\
{\
if (UDF_SB(X))\
{\
if (UDF_SB(X)) {\
kfree(UDF_SB_PARTMAPS(X));\
UDF_SB_PARTMAPS(X) = NULL;\
}\
@ -51,13 +50,10 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
#define UDF_SB_ALLOC_PARTMAPS(X,Y)\
{\
UDF_SB_PARTMAPS(X) = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
if (UDF_SB_PARTMAPS(X) != NULL)\
{\
if (UDF_SB_PARTMAPS(X) != NULL) {\
UDF_SB_NUMPARTS(X) = Y;\
memset(UDF_SB_PARTMAPS(X), 0x00, sizeof(struct udf_part_map) * Y);\
}\
else\
{\
} else {\
UDF_SB_NUMPARTS(X) = 0;\
udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\
}\
@ -72,15 +68,12 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
else\
UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = vmalloc(size);\
if (UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap != NULL)\
{\
if (UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap != NULL) {\
memset(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap, 0x00, size);\
UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap =\
(struct buffer_head **)(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap + 1);\
UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
}\
else\
{\
} else {\
udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\
}\
}
@ -90,8 +83,7 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
int i;\
int nr_groups = UDF_SB_BITMAP_NR_GROUPS(X,Y,Z);\
int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
for (i=0; i<nr_groups; i++)\
{\
for (i = 0; i < nr_groups; i++) {\
if (UDF_SB_BITMAP(X,Y,Z,i))\
brelse(UDF_SB_BITMAP(X,Y,Z,i));\
}\
@ -139,4 +131,4 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
#define UDF_SB_FLAGS(X) ( UDF_SB(X)->s_flags )
#define UDF_SB_VAT(X) ( UDF_SB(X)->s_vat )
#endif /* __LINUX_UDF_SB_H */
#endif /* __LINUX_UDF_SB_H */

4
fs/udf/udfdecl.h
View File

@ -63,8 +63,8 @@ struct udf_vds_record {
};
struct generic_desc {
tag descTag;
__le32 volDescSeqNum;
tag descTag;
__le32 volDescSeqNum;
};
struct ustr {

20
fs/udf/udfend.h
View File

@ -7,75 +7,93 @@
static inline kernel_lb_addr lelb_to_cpu(lb_addr in)
{
kernel_lb_addr out;
out.logicalBlockNum = le32_to_cpu(in.logicalBlockNum);
out.partitionReferenceNum = le16_to_cpu(in.partitionReferenceNum);
return out;
}
static inline lb_addr cpu_to_lelb(kernel_lb_addr in)
{
lb_addr out;
out.logicalBlockNum = cpu_to_le32(in.logicalBlockNum);
out.partitionReferenceNum = cpu_to_le16(in.partitionReferenceNum);
return out;
}
static inline kernel_timestamp lets_to_cpu(timestamp in)
{
kernel_timestamp out;
memcpy(&out, &in, sizeof(timestamp));
out.typeAndTimezone = le16_to_cpu(in.typeAndTimezone);
out.year = le16_to_cpu(in.year);
return out;
}
static inline short_ad lesa_to_cpu(short_ad in)
{
short_ad out;
out.extLength = le32_to_cpu(in.extLength);
out.extPosition = le32_to_cpu(in.extPosition);
return out;
}
static inline short_ad cpu_to_lesa(short_ad in)
{
short_ad out;
out.extLength = cpu_to_le32(in.extLength);
out.extPosition = cpu_to_le32(in.extPosition);
return out;
}
static inline kernel_long_ad lela_to_cpu(long_ad in)
{
kernel_long_ad out;
out.extLength = le32_to_cpu(in.extLength);
out.extLocation = lelb_to_cpu(in.extLocation);
return out;
}
static inline long_ad cpu_to_lela(kernel_long_ad in)
{
long_ad out;
out.extLength = cpu_to_le32(in.extLength);
out.extLocation = cpu_to_lelb(in.extLocation);
return out;
}
static inline kernel_extent_ad leea_to_cpu(extent_ad in)
{
kernel_extent_ad out;
out.extLength = le32_to_cpu(in.extLength);
out.extLocation = le32_to_cpu(in.extLocation);
return out;
}
static inline timestamp cpu_to_lets(kernel_timestamp in)
{
timestamp out;
memcpy(&out, &in, sizeof(timestamp));
out.typeAndTimezone = cpu_to_le16(in.typeAndTimezone);
out.year = cpu_to_le16(in.year);
return out;
}
#endif /* __UDF_ENDIAN_H */
#endif /* __UDF_ENDIAN_H */

80
fs/udf/udftime.c
View File

@ -18,18 +18,18 @@
Boston, MA 02111-1307, USA. */
/*
* dgb 10/02/98: ripped this from glibc source to help convert timestamps to unix time
* dgb 10/02/98: ripped this from glibc source to help convert timestamps to unix time
* 10/04/98: added new table-based lookup after seeing how ugly the gnu code is
* blf 09/27/99: ripped out all the old code and inserted new table from
* John Brockmeyer (without leap second corrections)
* rewrote udf_stamp_to_time and fixed timezone accounting in
udf_time_to_stamp.
* John Brockmeyer (without leap second corrections)
* rewrote udf_stamp_to_time and fixed timezone accounting in
* udf_time_to_stamp.
*/
/*
* We don't take into account leap seconds. This may be correct or incorrect.
* For more NIST information (especially dealing with leap seconds), see:
* http://www.boulder.nist.gov/timefreq/pubs/bulletin/leapsecond.htm
* http://www.boulder.nist.gov/timefreq/pubs/bulletin/leapsecond.htm
*/
#include <linux/types.h>
@ -54,28 +54,28 @@ static const unsigned short int __mon_yday[2][13] = {
};
#define MAX_YEAR_SECONDS 69
#define SPD 0x15180 /*3600*24 */
#define SPY(y,l,s) (SPD * (365*y+l)+s)
#define SPD 0x15180 /*3600*24 */
#define SPY(y,l,s) (SPD * (365*y+l)+s)
static time_t year_seconds[MAX_YEAR_SECONDS] = {
/*1970*/ SPY(0, 0, 0), SPY(1, 0, 0), SPY(2, 0, 0), SPY(3, 1, 0),
/*1974*/ SPY(4, 1, 0), SPY(5, 1, 0), SPY(6, 1, 0), SPY(7, 2, 0),
/*1978*/ SPY(8, 2, 0), SPY(9, 2, 0), SPY(10, 2, 0), SPY(11, 3, 0),
/*1982*/ SPY(12, 3, 0), SPY(13, 3, 0), SPY(14, 3, 0), SPY(15, 4, 0),
/*1986*/ SPY(16, 4, 0), SPY(17, 4, 0), SPY(18, 4, 0), SPY(19, 5, 0),
/*1990*/ SPY(20, 5, 0), SPY(21, 5, 0), SPY(22, 5, 0), SPY(23, 6, 0),
/*1994*/ SPY(24, 6, 0), SPY(25, 6, 0), SPY(26, 6, 0), SPY(27, 7, 0),
/*1998*/ SPY(28, 7, 0), SPY(29, 7, 0), SPY(30, 7, 0), SPY(31, 8, 0),
/*2002*/ SPY(32, 8, 0), SPY(33, 8, 0), SPY(34, 8, 0), SPY(35, 9, 0),
/*2006*/ SPY(36, 9, 0), SPY(37, 9, 0), SPY(38, 9, 0), SPY(39, 10, 0),
/*2010*/ SPY(40, 10, 0), SPY(41, 10, 0), SPY(42, 10, 0), SPY(43, 11, 0),
/*2014*/ SPY(44, 11, 0), SPY(45, 11, 0), SPY(46, 11, 0), SPY(47, 12, 0),
/*2018*/ SPY(48, 12, 0), SPY(49, 12, 0), SPY(50, 12, 0), SPY(51, 13, 0),
/*2022*/ SPY(52, 13, 0), SPY(53, 13, 0), SPY(54, 13, 0), SPY(55, 14, 0),
/*2026*/ SPY(56, 14, 0), SPY(57, 14, 0), SPY(58, 14, 0), SPY(59, 15, 0),
/*2030*/ SPY(60, 15, 0), SPY(61, 15, 0), SPY(62, 15, 0), SPY(63, 16, 0),
/*2034*/ SPY(64, 16, 0), SPY(65, 16, 0), SPY(66, 16, 0), SPY(67, 17, 0),
/*2038*/ SPY(68, 17, 0)
static time_t year_seconds[MAX_YEAR_SECONDS]= {
/*1970*/ SPY( 0, 0,0), SPY( 1, 0,0), SPY( 2, 0,0), SPY( 3, 1,0),
/*1974*/ SPY( 4, 1,0), SPY( 5, 1,0), SPY( 6, 1,0), SPY( 7, 2,0),
/*1978*/ SPY( 8, 2,0), SPY( 9, 2,0), SPY(10, 2,0), SPY(11, 3,0),
/*1982*/ SPY(12, 3,0), SPY(13, 3,0), SPY(14, 3,0), SPY(15, 4,0),
/*1986*/ SPY(16, 4,0), SPY(17, 4,0), SPY(18, 4,0), SPY(19, 5,0),
/*1990*/ SPY(20, 5,0), SPY(21, 5,0), SPY(22, 5,0), SPY(23, 6,0),
/*1994*/ SPY(24, 6,0), SPY(25, 6,0), SPY(26, 6,0), SPY(27, 7,0),
/*1998*/ SPY(28, 7,0), SPY(29, 7,0), SPY(30, 7,0), SPY(31, 8,0),
/*2002*/ SPY(32, 8,0), SPY(33, 8,0), SPY(34, 8,0), SPY(35, 9,0),
/*2006*/ SPY(36, 9,0), SPY(37, 9,0), SPY(38, 9,0), SPY(39,10,0),
/*2010*/ SPY(40,10,0), SPY(41,10,0), SPY(42,10,0), SPY(43,11,0),
/*2014*/ SPY(44,11,0), SPY(45,11,0), SPY(46,11,0), SPY(47,12,0),
/*2018*/ SPY(48,12,0), SPY(49,12,0), SPY(50,12,0), SPY(51,13,0),
/*2022*/ SPY(52,13,0), SPY(53,13,0), SPY(54,13,0), SPY(55,14,0),
/*2026*/ SPY(56,14,0), SPY(57,14,0), SPY(58,14,0), SPY(59,15,0),
/*2030*/ SPY(60,15,0), SPY(61,15,0), SPY(62,15,0), SPY(63,16,0),
/*2034*/ SPY(64,16,0), SPY(65,16,0), SPY(66,16,0), SPY(67,17,0),
/*2038*/ SPY(68,17,0)
};
extern struct timezone sys_tz;
@ -83,7 +83,7 @@ extern struct timezone sys_tz;
#define SECS_PER_HOUR (60 * 60)
#define SECS_PER_DAY (SECS_PER_HOUR * 24)
time_t *udf_stamp_to_time(time_t * dest, long *dest_usec, kernel_timestamp src)
time_t *udf_stamp_to_time(time_t *dest, long *dest_usec, kernel_timestamp src)
{
int yday;
uint8_t type = src.typeAndTimezone >> 12;
@ -93,10 +93,11 @@ time_t *udf_stamp_to_time(time_t * dest, long *dest_usec, kernel_timestamp src)
offset = src.typeAndTimezone << 4;
/* sign extent offset */
offset = (offset >> 4);
if (offset == -2047) /* unspecified offset */
if (offset == -2047) /* unspecified offset */
offset = 0;
} else
} else {
offset = 0;
}
if ((src.year < EPOCH_YEAR) ||
(src.year >= EPOCH_YEAR + MAX_YEAR_SECONDS)) {
@ -107,12 +108,10 @@ time_t *udf_stamp_to_time(time_t * dest, long *dest_usec, kernel_timestamp src)
*dest = year_seconds[src.year - EPOCH_YEAR];
*dest -= offset * 60;
yday = ((__mon_yday[__isleap(src.year)]
yday = ((__mon_yday[__isleap (src.year)]
[src.month - 1]) + (src.day - 1));
*dest += (((yday * 24) + src.hour) * 60 + src.minute) * 60 + src.second;
*dest_usec =
src.centiseconds * 10000 + src.hundredsOfMicroseconds * 100 +
src.microseconds;
*dest += ( ( (yday * 24) + src.hour ) * 60 + src.minute ) * 60 + src.second;
*dest_usec = src.centiseconds * 10000 + src.hundredsOfMicroseconds * 100 + src.microseconds;
return dest;
}
@ -145,8 +144,9 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
long int yg = y + days / 365 - (days % 365 < 0);
/* Adjust DAYS and Y to match the guessed year. */
days -= ((yg - y) * 365 + LEAPS_THRU_END_OF(yg - 1)
- LEAPS_THRU_END_OF(y - 1));
days -= ((yg - y) * 365
+ LEAPS_THRU_END_OF (yg - 1)
- LEAPS_THRU_END_OF (y - 1));
y = yg;
}
dest->year = y;
@ -158,11 +158,9 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
dest->day = days + 1;
dest->centiseconds = ts.tv_nsec / 10000000;
dest->hundredsOfMicroseconds =
(ts.tv_nsec / 1000 - dest->centiseconds * 10000) / 100;
dest->microseconds =
(ts.tv_nsec / 1000 - dest->centiseconds * 10000 -
dest->hundredsOfMicroseconds * 100);
dest->hundredsOfMicroseconds = (ts.tv_nsec / 1000 - dest->centiseconds * 10000) / 100;
dest->microseconds = (ts.tv_nsec / 1000 - dest->centiseconds * 10000 -
dest->hundredsOfMicroseconds * 100);
return dest;
}

155
fs/udf/unicode.c
View File

@ -29,21 +29,23 @@
static int udf_translate_to_linux(uint8_t *, uint8_t *, int, uint8_t *, int);
static int udf_char_to_ustr(struct ustr *dest, const uint8_t * src, int strlen)
static int udf_char_to_ustr(struct ustr *dest, const uint8_t *src, int strlen)
{
if ((!dest) || (!src) || (!strlen) || (strlen > UDF_NAME_LEN - 2))
return 0;
memset(dest, 0, sizeof(struct ustr));
memcpy(dest->u_name, src, strlen);
dest->u_cmpID = 0x08;
dest->u_len = strlen;
return strlen;
}
/*
* udf_build_ustr
*/
int udf_build_ustr(struct ustr *dest, dstring * ptr, int size)
int udf_build_ustr(struct ustr *dest, dstring *ptr, int size)
{
int usesize;
@ -55,13 +57,14 @@ int udf_build_ustr(struct ustr *dest, dstring * ptr, int size)
dest->u_cmpID = ptr[0];
dest->u_len = ptr[size - 1];
memcpy(dest->u_name, ptr + 1, usesize - 1);
return 0;
}
/*
* udf_build_ustr_exact
*/
static int udf_build_ustr_exact(struct ustr *dest, dstring * ptr, int exactsize)
static int udf_build_ustr_exact(struct ustr *dest, dstring *ptr, int exactsize)
{
if ((!dest) || (!ptr) || (!exactsize))
return -1;
@ -70,6 +73,7 @@ static int udf_build_ustr_exact(struct ustr *dest, dstring * ptr, int exactsize)
dest->u_cmpID = ptr[0];
dest->u_len = exactsize - 1;
memcpy(dest->u_name, ptr + 1, exactsize - 1);
return 0;
}
@ -129,20 +133,15 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
c = (c << 8) | ocu[i++];
/* Compress Unicode to UTF-8 */
if (c < 0x80U)
utf_o->u_name[utf_o->u_len++] = (uint8_t) c;
else if (c < 0x800U) {
utf_o->u_name[utf_o->u_len++] =
(uint8_t) (0xc0 | (c >> 6));
utf_o->u_name[utf_o->u_len++] =
(uint8_t) (0x80 | (c & 0x3f));
if (c < 0x80U) {
utf_o->u_name[utf_o->u_len++] = (uint8_t)c;
} else if (c < 0x800U) {
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xc0 | (c >> 6));
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f));
} else {
utf_o->u_name[utf_o->u_len++] =
(uint8_t) (0xe0 | (c >> 12));
utf_o->u_name[utf_o->u_len++] =
(uint8_t) (0x80 | ((c >> 6) & 0x3f));
utf_o->u_name[utf_o->u_len++] =
(uint8_t) (0x80 | (c & 0x3f));
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xe0 | (c >> 12));
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | ((c >> 6) & 0x3f));
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f));
}
}
utf_o->u_cmpID = 8;
@ -173,7 +172,7 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
* November 12, 1997 - Andrew E. Mileski
* Written, tested, and released.
*/
static int udf_UTF8toCS0(dstring * ocu, struct ustr *utf, int length)
static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length)
{
unsigned c, i, max_val, utf_char;
int utf_cnt, u_len;
@ -182,12 +181,12 @@ static int udf_UTF8toCS0(dstring * ocu, struct ustr *utf, int length)
ocu[0] = 8;
max_val = 0xffU;
try_again:
try_again:
u_len = 0U;
utf_char = 0U;
utf_cnt = 0U;
for (i = 0U; i < utf->u_len; i++) {
c = (uint8_t) utf->u_name[i];
c = (uint8_t)utf->u_name[i];
/* Complete a multi-byte UTF-8 character */
if (utf_cnt) {
@ -213,37 +212,40 @@ static int udf_UTF8toCS0(dstring * ocu, struct ustr *utf, int length)
} else if ((c & 0xfeU) == 0xfcU) {
utf_char = c & 0x01U;
utf_cnt = 5;
} else
} else {
goto error_out;
}
continue;
} else
} else {
/* Single byte UTF-8 character (most common) */
utf_char = c;
}
}
/* Choose no compression if necessary */
if (utf_char > max_val) {
if (0xffU == max_val) {
if (max_val == 0xffU) {
max_val = 0xffffU;
ocu[0] = (uint8_t) 0x10U;
ocu[0] = (uint8_t)0x10U;
goto try_again;
}
goto error_out;
}
if (max_val == 0xffffU) {
ocu[++u_len] = (uint8_t) (utf_char >> 8);
ocu[++u_len] = (uint8_t)(utf_char >> 8);
}
ocu[++u_len] = (uint8_t) (utf_char & 0xffU);
ocu[++u_len] = (uint8_t)(utf_char & 0xffU);
}
if (utf_cnt) {
error_out:
error_out:
ocu[++u_len] = '?';
printk(KERN_DEBUG "udf: bad UTF-8 character\n");
}
ocu[length - 1] = (uint8_t) u_len + 1;
ocu[length - 1] = (uint8_t)u_len + 1;
return u_len + 1;
}
@ -288,7 +290,7 @@ static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o,
return utf_o->u_len;
}
static int udf_NLStoCS0(struct nls_table *nls, dstring * ocu, struct ustr *uni,
static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni,
int length)
{
unsigned len, i, max_val;
@ -299,7 +301,7 @@ static int udf_NLStoCS0(struct nls_table *nls, dstring * ocu, struct ustr *uni,
ocu[0] = 8;
max_val = 0xffU;
try_again:
try_again:
u_len = 0U;
for (i = 0U; i < uni->u_len; i++) {
len = nls->char2uni(&uni->u_name[i], uni->u_len - i, &uni_char);
@ -308,21 +310,21 @@ static int udf_NLStoCS0(struct nls_table *nls, dstring * ocu, struct ustr *uni,
if (uni_char > max_val) {
max_val = 0xffffU;
ocu[0] = (uint8_t) 0x10U;
ocu[0] = (uint8_t)0x10U;
goto try_again;
}
if (max_val == 0xffffU)
ocu[++u_len] = (uint8_t) (uni_char >> 8);
ocu[++u_len] = (uint8_t) (uni_char & 0xffU);
ocu[++u_len] = (uint8_t)(uni_char >> 8);
ocu[++u_len] = (uint8_t)(uni_char & 0xffU);
i += len - 1;
}
ocu[length - 1] = (uint8_t) u_len + 1;
ocu[length - 1] = (uint8_t)u_len + 1;
return u_len + 1;
}
int udf_get_filename(struct super_block *sb, uint8_t * sname, uint8_t * dname,
int udf_get_filename(struct super_block *sb, uint8_t *sname, uint8_t *dname,
int flen)
{
struct ustr filename, unifilename;
@ -334,30 +336,29 @@ int udf_get_filename(struct super_block *sb, uint8_t * sname, uint8_t * dname,
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
if (!udf_CS0toUTF8(&filename, &unifilename)) {
udf_debug("Failed in udf_get_filename: sname = %s\n",
sname);
udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
return 0;
}
} else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
if (!udf_CS0toNLS
(UDF_SB(sb)->s_nls_map, &filename, &unifilename)) {
udf_debug("Failed in udf_get_filename: sname = %s\n",
sname);
if (!udf_CS0toNLS(UDF_SB(sb)->s_nls_map, &filename, &unifilename)) {
udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
return 0;
}
} else
} else {
return 0;
}
if ((len =
udf_translate_to_linux(dname, filename.u_name, filename.u_len,
unifilename.u_name, unifilename.u_len))) {
len = udf_translate_to_linux(dname, filename.u_name, filename.u_len,
unifilename.u_name, unifilename.u_len);
if (len) {
return len;
}
return 0;
}
int udf_put_filename(struct super_block *sb, const uint8_t * sname,
uint8_t * dname, int flen)
int udf_put_filename(struct super_block *sb, const uint8_t *sname,
uint8_t *dname, int flen)
{
struct ustr unifilename;
int namelen;
@ -367,31 +368,29 @@ int udf_put_filename(struct super_block *sb, const uint8_t * sname,
}
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
if (!
(namelen =
udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN))) {
namelen = udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN);
if (!namelen) {
return 0;
}
} else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
if (!
(namelen =
udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename,
UDF_NAME_LEN))) {
namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename, UDF_NAME_LEN);
if (!namelen) {
return 0;
}
} else
} else {
return 0;
}
return namelen;
}
#define ILLEGAL_CHAR_MARK '_'
#define EXT_MARK '.'
#define CRC_MARK '#'
#define EXT_SIZE 5
#define EXT_MARK '.'
#define CRC_MARK '#'
#define EXT_SIZE 5
static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
int udfLen, uint8_t * fidName, int fidNameLen)
static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen,
uint8_t *fidName, int fidNameLen)
{
int index, newIndex = 0, needsCRC = 0;
int extIndex = 0, newExtIndex = 0, hasExt = 0;
@ -399,8 +398,8 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
uint8_t curr;
const uint8_t hexChar[] = "0123456789ABCDEF";
if (udfName[0] == '.' && (udfLen == 1 ||
(udfLen == 2 && udfName[1] == '.'))) {
if (udfName[0] == '.' &&
(udfLen == 1 || (udfLen == 2 && udfName[1] == '.'))) {
needsCRC = 1;
newIndex = udfLen;
memcpy(newName, udfName, udfLen);
@ -410,16 +409,13 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
if (curr == '/' || curr == 0) {
needsCRC = 1;
curr = ILLEGAL_CHAR_MARK;
while (index + 1 < udfLen
&& (udfName[index + 1] == '/'
|| udfName[index + 1] == 0))
while (index + 1 < udfLen && (udfName[index + 1] == '/' ||
udfName[index + 1] == 0))
index++;
}
if (curr == EXT_MARK
&& (udfLen - index - 1) <= EXT_SIZE) {
if (udfLen == index + 1)
} if (curr == EXT_MARK && (udfLen - index - 1) <= EXT_SIZE) {
if (udfLen == index + 1) {
hasExt = 0;
else {
} else {
hasExt = 1;
extIndex = index;
newExtIndex = newIndex;
@ -437,23 +433,16 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
if (hasExt) {
int maxFilenameLen;
for (index = 0;
index < EXT_SIZE && extIndex + index + 1 < udfLen;
index++) {
for(index = 0; index < EXT_SIZE && extIndex + index + 1 < udfLen; index++) {
curr = udfName[extIndex + index + 1];
if (curr == '/' || curr == 0) {
needsCRC = 1;
curr = ILLEGAL_CHAR_MARK;
while (extIndex + index + 2 < udfLen
&& (index + 1 < EXT_SIZE
&&
(udfName
[extIndex + index + 2] ==
'/'
|| udfName[extIndex +
index + 2] ==
0)))
while(extIndex + index + 2 < udfLen &&
(index + 1 < EXT_SIZE
&& (udfName[extIndex + index + 2] == '/' ||
udfName[extIndex + index + 2] == 0)))
index++;
}
ext[localExtIndex++] = curr;
@ -463,8 +452,9 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
newIndex = maxFilenameLen;
else
newIndex = newExtIndex;
} else if (newIndex > 250)
} else if (newIndex > 250) {
newIndex = 250;
}
newName[newIndex++] = CRC_MARK;
valueCRC = udf_crc(fidName, fidNameLen, 0);
newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12];
@ -478,5 +468,6 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
newName[newIndex++] = ext[index];
}
}
return newIndex;
}