Skip to content

L
linux
Commit cb00ea35 authored by Cyrill Gorcunov's avatar Cyrill Gorcunov Committed by Linus Torvalds
Browse files
Options

UDF: coding style conversion - lindent 

This patch converts UDF coding style to kernel coding style using Lindent.
Signed-off-by: default avatarCyrill Gorcunov <gorcunov@gmail.com>
Cc: Jan Kara <jack@ucw.cz>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 95a631e2
Show whitespace changes
Inline Side-by-side
Showing with 3801 additions and 3649 deletions
fs/udf/balloc.c
View file @ cb00ea35
...@@ -41,18 +41,17 @@ ...@@ -41,18 +41,17 @@
#define uint(x) xuint(x) #define uint(x) xuint(x)
#define xuint(x) __le ## x #define xuint(x) __le ## x
static inline int find_next_one_bit (void * addr, int size, int offset) static inline int find_next_one_bit(void *addr, int size, int offset)
{ {
uintBPL_t * p = ((uintBPL_t *) addr) + (offset / BITS_PER_LONG); uintBPL_t *p = ((uintBPL_t *) addr) + (offset / BITS_PER_LONG);
int result = offset & ~(BITS_PER_LONG-1); int result = offset & ~(BITS_PER_LONG - 1);
unsigned long tmp; unsigned long tmp;
if (offset >= size) if (offset >= size)
return size; return size;
size -= result; size -= result;
offset &= (BITS_PER_LONG-1); offset &= (BITS_PER_LONG - 1);
if (offset) if (offset) {
{
tmp = leBPL_to_cpup(p++); tmp = leBPL_to_cpup(p++);
tmp &= ~0UL << offset; tmp &= ~0UL << offset;
if (size < BITS_PER_LONG) if (size < BITS_PER_LONG)
...@@ -62,8 +61,7 @@ static inline int find_next_one_bit (void * addr, int size, int offset) ...@@ -62,8 +61,7 @@ static inline int find_next_one_bit (void * addr, int size, int offset)
size -= BITS_PER_LONG; size -= BITS_PER_LONG;
result += BITS_PER_LONG; result += BITS_PER_LONG;
} }
while (size & ~(BITS_PER_LONG-1)) while (size & ~(BITS_PER_LONG - 1)) {
{
if ((tmp = leBPL_to_cpup(p++))) if ((tmp = leBPL_to_cpup(p++)))
goto found_middle; goto found_middle;
result += BITS_PER_LONG; result += BITS_PER_LONG;
...@@ -72,17 +70,18 @@ static inline int find_next_one_bit (void * addr, int size, int offset) ...@@ -72,17 +70,18 @@ static inline int find_next_one_bit (void * addr, int size, int offset)
if (!size) if (!size)
return result; return result;
tmp = leBPL_to_cpup(p); tmp = leBPL_to_cpup(p);
found_first: found_first:
tmp &= ~0UL >> (BITS_PER_LONG-size); tmp &= ~0UL >> (BITS_PER_LONG - size);
found_middle: found_middle:
return result + ffz(~tmp); return result + ffz(~tmp);
} }
#define find_first_one_bit(addr, size)\ #define find_first_one_bit(addr, size)\
find_next_one_bit((addr), (size), 0) find_next_one_bit((addr), (size), 0)
static int read_block_bitmap(struct super_block * sb, static int read_block_bitmap(struct super_block *sb,
struct udf_bitmap *bitmap, unsigned int block, unsigned long bitmap_nr) struct udf_bitmap *bitmap, unsigned int block,
unsigned long bitmap_nr)
{ {
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
int retval = 0; int retval = 0;
...@@ -92,38 +91,39 @@ static int read_block_bitmap(struct super_block * sb, ...@@ -92,38 +91,39 @@ static int read_block_bitmap(struct super_block * sb,
loc.partitionReferenceNum = UDF_SB_PARTITION(sb); loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
bh = udf_tread(sb, udf_get_lb_pblock(sb, loc, block)); bh = udf_tread(sb, udf_get_lb_pblock(sb, loc, block));
if (!bh) if (!bh) {
{
retval = -EIO; retval = -EIO;
} }
bitmap->s_block_bitmap[bitmap_nr] = bh; bitmap->s_block_bitmap[bitmap_nr] = bh;
return retval; return retval;
} }
static int __load_block_bitmap(struct super_block * sb, static int __load_block_bitmap(struct super_block *sb,
struct udf_bitmap *bitmap, unsigned int block_group) struct udf_bitmap *bitmap,
unsigned int block_group)
{ {
int retval = 0; int retval = 0;
int nr_groups = bitmap->s_nr_groups; int nr_groups = bitmap->s_nr_groups;
if (block_group >= nr_groups) if (block_group >= nr_groups) {
{ udf_debug("block_group (%d) > nr_groups (%d)\n", block_group,
udf_debug("block_group (%d) > nr_groups (%d)\n", block_group, nr_groups); nr_groups);
} }
if (bitmap->s_block_bitmap[block_group]) if (bitmap->s_block_bitmap[block_group])
return block_group; return block_group;
else else {
{ retval =
retval = read_block_bitmap(sb, bitmap, block_group, block_group); read_block_bitmap(sb, bitmap, block_group, block_group);
if (retval < 0) if (retval < 0)
return retval; return retval;
return block_group; return block_group;
} }
} }
static inline int load_block_bitmap(struct super_block * sb, static inline int load_block_bitmap(struct super_block *sb,
struct udf_bitmap *bitmap, unsigned int block_group) struct udf_bitmap *bitmap,
unsigned int block_group)
{ {
int slot; int slot;
...@@ -138,13 +138,14 @@ static inline int load_block_bitmap(struct super_block * sb, ...@@ -138,13 +138,14 @@ static inline int load_block_bitmap(struct super_block * sb,
return slot; return slot;
} }
static void udf_bitmap_free_blocks(struct super_block * sb, static void udf_bitmap_free_blocks(struct super_block *sb,
struct inode * inode, struct inode *inode,
struct udf_bitmap *bitmap, struct udf_bitmap *bitmap,
kernel_lb_addr bloc, uint32_t offset, uint32_t count) kernel_lb_addr bloc, uint32_t offset,
uint32_t count)
{ {
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
struct buffer_head * bh = NULL; struct buffer_head *bh = NULL;
unsigned long block; unsigned long block;
unsigned long block_group; unsigned long block_group;
unsigned long bit; unsigned long bit;
...@@ -154,17 +155,22 @@ static void udf_bitmap_free_blocks(struct super_block * sb, ...@@ -154,17 +155,22 @@ static void udf_bitmap_free_blocks(struct super_block * sb,
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
if (bloc.logicalBlockNum < 0 || if (bloc.logicalBlockNum < 0 ||
(bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb,
{ bloc.
udf_debug("%d < %d || %d + %d > %d\n", partitionReferenceNum))
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));
goto error_return; 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; overflow = 0;
block_group = block >> (sb->s_blocksize_bits + 3); block_group = block >> (sb->s_blocksize_bits + 3);
bit = block % (sb->s_blocksize << 3); bit = block % (sb->s_blocksize << 3);
...@@ -172,8 +178,7 @@ static void udf_bitmap_free_blocks(struct super_block * sb, ...@@ -172,8 +178,7 @@ static void udf_bitmap_free_blocks(struct super_block * sb,
/* /*
* Check to see if we are freeing blocks across a group boundary. * Check to see if we are freeing blocks across a group boundary.
*/ */
if (bit + count > (sb->s_blocksize << 3)) if (bit + count > (sb->s_blocksize << 3)) {
{
overflow = bit + count - (sb->s_blocksize << 3); overflow = bit + count - (sb->s_blocksize << 3);
count -= overflow; count -= overflow;
} }
...@@ -182,32 +187,31 @@ static void udf_bitmap_free_blocks(struct super_block * sb, ...@@ -182,32 +187,31 @@ static void udf_bitmap_free_blocks(struct super_block * sb,
goto error_return; goto error_return;
bh = bitmap->s_block_bitmap[bitmap_nr]; bh = bitmap->s_block_bitmap[bitmap_nr];
for (i=0; i < count; i++) for (i = 0; i < count; i++) {
{ if (udf_set_bit(bit + i, bh->b_data)) {
if (udf_set_bit(bit + i, bh->b_data))
{
udf_debug("bit %ld already set\n", bit + i); 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 } else {
{
if (inode) if (inode)
DQUOT_FREE_BLOCK(inode, 1); DQUOT_FREE_BLOCK(inode, 1);
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb)) {
{ UDF_SB_LVID(sb)->
UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] = freeSpaceTable[UDF_SB_PARTITION(sb)] =
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)])+1); cpu_to_le32(le32_to_cpu
(UDF_SB_LVID(sb)->
freeSpaceTable[UDF_SB_PARTITION
(sb)]) + 1);
} }
} }
} }
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
if (overflow) if (overflow) {
{
block += count; block += count;
count = overflow; count = overflow;
goto do_more; goto do_more;
} }
error_return: error_return:
sb->s_dirt = 1; sb->s_dirt = 1;
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb))
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); mark_buffer_dirty(UDF_SB_LVIDBH(sb));
...@@ -215,9 +219,10 @@ static void udf_bitmap_free_blocks(struct super_block * sb, ...@@ -215,9 +219,10 @@ static void udf_bitmap_free_blocks(struct super_block * sb,
return; return;
} }
static int udf_bitmap_prealloc_blocks(struct super_block * sb, static int udf_bitmap_prealloc_blocks(struct super_block *sb,
struct inode * inode, struct inode *inode,
struct udf_bitmap *bitmap, uint16_t partition, uint32_t first_block, struct udf_bitmap *bitmap,
uint16_t partition, uint32_t first_block,
uint32_t block_count) uint32_t block_count)
{ {
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
...@@ -233,9 +238,10 @@ static int udf_bitmap_prealloc_blocks(struct super_block * sb, ...@@ -233,9 +238,10 @@ static int udf_bitmap_prealloc_blocks(struct super_block * sb,
if (first_block + block_count > UDF_SB_PARTLEN(sb, partition)) if (first_block + block_count > UDF_SB_PARTLEN(sb, partition))
block_count = UDF_SB_PARTLEN(sb, partition) - first_block; block_count = UDF_SB_PARTLEN(sb, partition) - first_block;
repeat: repeat:
nr_groups = (UDF_SB_PARTLEN(sb, partition) + nr_groups = (UDF_SB_PARTLEN(sb, partition) +
(sizeof(struct spaceBitmapDesc) << 3) + (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8); (sizeof(struct spaceBitmapDesc) << 3) +
(sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
block = first_block + (sizeof(struct spaceBitmapDesc) << 3); block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
block_group = block >> (sb->s_blocksize_bits + 3); block_group = block >> (sb->s_blocksize_bits + 3);
group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc); group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
...@@ -247,31 +253,30 @@ static int udf_bitmap_prealloc_blocks(struct super_block * sb, ...@@ -247,31 +253,30 @@ static int udf_bitmap_prealloc_blocks(struct super_block * sb,
bit = block % (sb->s_blocksize << 3); bit = block % (sb->s_blocksize << 3);
while (bit < (sb->s_blocksize << 3) && block_count > 0) 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; goto out;
else if (DQUOT_PREALLOC_BLOCK(inode, 1)) else if (DQUOT_PREALLOC_BLOCK(inode, 1))
goto out; 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); udf_debug("bit already cleared for block %d\n", bit);
DQUOT_FREE_BLOCK(inode, 1); DQUOT_FREE_BLOCK(inode, 1);
goto out; goto out;
} }
block_count --; block_count--;
alloc_count ++; alloc_count++;
bit ++; bit++;
block ++; block++;
} }
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
if (block_count > 0) if (block_count > 0)
goto repeat; goto repeat;
out: out:
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb)) {
{
UDF_SB_LVID(sb)->freeSpaceTable[partition] = 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)); mark_buffer_dirty(UDF_SB_LVIDBH(sb));
} }
sb->s_dirt = 1; sb->s_dirt = 1;
...@@ -279,12 +284,13 @@ static int udf_bitmap_prealloc_blocks(struct super_block * sb, ...@@ -279,12 +284,13 @@ static int udf_bitmap_prealloc_blocks(struct super_block * sb,
return alloc_count; return alloc_count;
} }
static int udf_bitmap_new_block(struct super_block * sb, static int udf_bitmap_new_block(struct super_block *sb,
struct inode * inode, struct inode *inode,
struct udf_bitmap *bitmap, uint16_t partition, uint32_t goal, int *err) struct udf_bitmap *bitmap, uint16_t partition,
uint32_t goal, int *err)
{ {
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
int newbit, bit=0, block, block_group, group_start; int newbit, bit = 0, block, block_group, group_start;
int end_goal, nr_groups, bitmap_nr, i; int end_goal, nr_groups, bitmap_nr, i;
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
char *ptr; char *ptr;
...@@ -293,7 +299,7 @@ static int udf_bitmap_new_block(struct super_block * sb, ...@@ -293,7 +299,7 @@ static int udf_bitmap_new_block(struct super_block * sb,
*err = -ENOSPC; *err = -ENOSPC;
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
repeat: repeat:
if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition)) if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
goal = 0; goal = 0;
...@@ -306,38 +312,39 @@ static int udf_bitmap_new_block(struct super_block * sb, ...@@ -306,38 +312,39 @@ static int udf_bitmap_new_block(struct super_block * sb,
if (bitmap_nr < 0) if (bitmap_nr < 0)
goto error_return; goto error_return;
bh = bitmap->s_block_bitmap[bitmap_nr]; 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) if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
{
bit = block % (sb->s_blocksize << 3); 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; goto got_block;
} }
end_goal = (bit + 63) & ~63; end_goal = (bit + 63) & ~63;
bit = udf_find_next_one_bit(bh->b_data, end_goal, bit); bit = udf_find_next_one_bit(bh->b_data, end_goal, bit);
if (bit < end_goal) if (bit < end_goal)
goto got_block; 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; newbit = (ptr - ((char *)bh->b_data)) << 3;
if (newbit < sb->s_blocksize << 3) if (newbit < sb->s_blocksize << 3) {
{
bit = newbit; bit = newbit;
goto search_back; goto search_back;
} }
newbit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, bit); newbit =
if (newbit < sb->s_blocksize << 3) udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
{ bit);
if (newbit < sb->s_blocksize << 3) {
bit = newbit; bit = newbit;
goto got_block; goto got_block;
} }
} }
for (i=0; i<(nr_groups*2); i++) for (i = 0; i < (nr_groups * 2); i++) {
{ block_group++;
block_group ++;
if (block_group >= nr_groups) if (block_group >= nr_groups)
block_group = 0; block_group = 0;
group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc); group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
...@@ -346,47 +353,49 @@ static int udf_bitmap_new_block(struct super_block * sb, ...@@ -346,47 +353,49 @@ static int udf_bitmap_new_block(struct super_block * sb,
if (bitmap_nr < 0) if (bitmap_nr < 0)
goto error_return; goto error_return;
bh = bitmap->s_block_bitmap[bitmap_nr]; bh = bitmap->s_block_bitmap[bitmap_nr];
if (i < nr_groups) if (i < nr_groups) {
{ ptr =
ptr = memscan((char *)bh->b_data + group_start, 0xFF, sb->s_blocksize - group_start); memscan((char *)bh->b_data + group_start, 0xFF,
if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) sb->s_blocksize - group_start);
{ if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
bit = (ptr - ((char *)bh->b_data)) << 3; bit = (ptr - ((char *)bh->b_data)) << 3;
break; break;
} }
} } else {
else bit =
{ udf_find_next_one_bit((char *)bh->b_data,
bit = udf_find_next_one_bit((char *)bh->b_data, sb->s_blocksize << 3, group_start << 3); sb->s_blocksize << 3,
group_start << 3);
if (bit < sb->s_blocksize << 3) if (bit < sb->s_blocksize << 3)
break; break;
} }
} }
if (i >= (nr_groups*2)) if (i >= (nr_groups * 2)) {
{
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
return newblock; return newblock;
} }
if (bit < sb->s_blocksize << 3) if (bit < sb->s_blocksize << 3)
goto search_back; goto search_back;
else else
bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, group_start << 3); bit =
if (bit >= sb->s_blocksize << 3) 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); mutex_unlock(&sbi->s_alloc_mutex);
return 0; return 0;
} }
search_back: search_back:
for (i=0; i<7 && bit > (group_start << 3) && udf_test_bit(bit - 1, bh->b_data); i++, bit--); for (i = 0;
i < 7 && bit > (group_start << 3)
&& udf_test_bit(bit - 1, bh->b_data); i++, bit--) ;
got_block: got_block:
/* /*
* Check quota for allocation of this block. * Check quota for allocation of this block.
*/ */
if (inode && DQUOT_ALLOC_BLOCK(inode, 1)) if (inode && DQUOT_ALLOC_BLOCK(inode, 1)) {
{
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
*err = -EDQUOT; *err = -EDQUOT;
return 0; return 0;
...@@ -395,18 +404,18 @@ static int udf_bitmap_new_block(struct super_block * sb, ...@@ -395,18 +404,18 @@ static int udf_bitmap_new_block(struct super_block * sb,
newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) - 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)) if (!udf_clear_bit(bit, bh->b_data)) {
{
udf_debug("bit already cleared for block %d\n", bit); udf_debug("bit already cleared for block %d\n", bit);
goto repeat; goto repeat;
} }
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb)) {
{
UDF_SB_LVID(sb)->freeSpaceTable[partition] = 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)); mark_buffer_dirty(UDF_SB_LVIDBH(sb));
} }
sb->s_dirt = 1; sb->s_dirt = 1;
...@@ -414,16 +423,17 @@ static int udf_bitmap_new_block(struct super_block * sb, ...@@ -414,16 +423,17 @@ static int udf_bitmap_new_block(struct super_block * sb,
*err = 0; *err = 0;
return newblock; return newblock;
error_return: error_return:
*err = -EIO; *err = -EIO;
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
return 0; return 0;
} }
static void udf_table_free_blocks(struct super_block * sb, static void udf_table_free_blocks(struct super_block *sb,
struct inode * inode, struct inode *inode,
struct inode * table, struct inode *table,
kernel_lb_addr bloc, uint32_t offset, uint32_t count) kernel_lb_addr bloc, uint32_t offset,
uint32_t count)
{ {
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
uint32_t start, end; uint32_t start, end;
...@@ -435,11 +445,14 @@ static void udf_table_free_blocks(struct super_block * sb, ...@@ -435,11 +445,14 @@ static void udf_table_free_blocks(struct super_block * sb,
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
if (bloc.logicalBlockNum < 0 || if (bloc.logicalBlockNum < 0 ||
(bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb,
{ bloc.
udf_debug("%d < %d || %d + %d > %d\n", partitionReferenceNum))
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));
goto error_return; goto error_return;
} }
...@@ -447,10 +460,11 @@ static void udf_table_free_blocks(struct super_block * sb, ...@@ -447,10 +460,11 @@ static void udf_table_free_blocks(struct super_block * sb,
but.. oh well */ but.. oh well */
if (inode) if (inode)
DQUOT_FREE_BLOCK(inode, count); DQUOT_FREE_BLOCK(inode, count);
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb)) {
{
UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(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)); mark_buffer_dirty(UDF_SB_LVIDBH(sb));
} }
...@@ -463,38 +477,43 @@ static void udf_table_free_blocks(struct super_block * sb, ...@@ -463,38 +477,43 @@ static void udf_table_free_blocks(struct super_block * sb,
epos.bh = oepos.bh = NULL; epos.bh = oepos.bh = NULL;
while (count && (etype = while (count && (etype =
udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
{
if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) == if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==
start)) start)) {
{ if ((0x3FFFFFFF - elen) <
if ((0x3FFFFFFF - elen) < (count << sb->s_blocksize_bits)) (count << sb->s_blocksize_bits)) {
{ count -=
count -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits); ((0x3FFFFFFF -
start += ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits); elen) >> sb->s_blocksize_bits);
elen = (etype << 30) | (0x40000000 - sb->s_blocksize); start +=
} ((0x3FFFFFFF -
else elen) >> sb->s_blocksize_bits);
{ elen =
(etype << 30) | (0x40000000 -
sb->s_blocksize);
} else {
elen = (etype << 30) | elen = (etype << 30) |
(elen + (count << sb->s_blocksize_bits)); (elen + (count << sb->s_blocksize_bits));
start += count; start += count;
count = 0; count = 0;
} }
udf_write_aext(table, &oepos, eloc, elen, 1); udf_write_aext(table, &oepos, eloc, elen, 1);
} } else if (eloc.logicalBlockNum == (end + 1)) {
else if (eloc.logicalBlockNum == (end + 1)) if ((0x3FFFFFFF - elen) <
{ (count << sb->s_blocksize_bits)) {
if ((0x3FFFFFFF - elen) < (count << sb->s_blocksize_bits)) count -=
{ ((0x3FFFFFFF -
count -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits); elen) >> sb->s_blocksize_bits);
end -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits); end -=
((0x3FFFFFFF -
elen) >> sb->s_blocksize_bits);
eloc.logicalBlockNum -= eloc.logicalBlockNum -=
((0x3FFFFFFF - elen) >> sb->s_blocksize_bits); ((0x3FFFFFFF -
elen = (etype << 30) | (0x40000000 - sb->s_blocksize); elen) >> sb->s_blocksize_bits);
} elen =
else (etype << 30) | (0x40000000 -
{ sb->s_blocksize);
} else {
eloc.logicalBlockNum = start; eloc.logicalBlockNum = start;
elen = (etype << 30) | elen = (etype << 30) |
(elen + (count << sb->s_blocksize_bits)); (elen + (count << sb->s_blocksize_bits));
...@@ -504,21 +523,18 @@ static void udf_table_free_blocks(struct super_block * sb, ...@@ -504,21 +523,18 @@ static void udf_table_free_blocks(struct super_block * sb,
udf_write_aext(table, &oepos, eloc, elen, 1); udf_write_aext(table, &oepos, eloc, elen, 1);
} }
if (epos.bh != oepos.bh) if (epos.bh != oepos.bh) {
{
i = -1; i = -1;
oepos.block = epos.block; oepos.block = epos.block;
brelse(oepos.bh); brelse(oepos.bh);
get_bh(epos.bh); get_bh(epos.bh);
oepos.bh = epos.bh; oepos.bh = epos.bh;
oepos.offset = 0; oepos.offset = 0;
} } else
else
oepos.offset = epos.offset; oepos.offset = epos.offset;
} }
if (count) if (count) {
{
/* NOTE: we CANNOT use udf_add_aext here, as it can try to allocate /* 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 a new block, and since we hold the super block lock already
very bad things would happen :) very bad things would happen :)
...@@ -537,22 +553,19 @@ static void udf_table_free_blocks(struct super_block * sb, ...@@ -537,22 +553,19 @@ static void udf_table_free_blocks(struct super_block * sb,
struct allocExtDesc *aed; struct allocExtDesc *aed;
eloc.logicalBlockNum = start; eloc.logicalBlockNum = start;
elen = EXT_RECORDED_ALLOCATED | elen = EXT_RECORDED_ALLOCATED | (count << sb->s_blocksize_bits);
(count << sb->s_blocksize_bits);
if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT) if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG) else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)
adsize = sizeof(long_ad); adsize = sizeof(long_ad);
else else {
{
brelse(oepos.bh); brelse(oepos.bh);
brelse(epos.bh); brelse(epos.bh);
goto error_return; goto error_return;
} }
if (epos.offset + (2 * adsize) > sb->s_blocksize) if (epos.offset + (2 * adsize) > sb->s_blocksize) {
{
char *sptr, *dptr; char *sptr, *dptr;
int loffset; int loffset;
...@@ -561,97 +574,103 @@ static void udf_table_free_blocks(struct super_block * sb, ...@@ -561,97 +574,103 @@ static void udf_table_free_blocks(struct super_block * sb,
/* Steal a block from the extent being free'd */ /* Steal a block from the extent being free'd */
epos.block.logicalBlockNum = eloc.logicalBlockNum; epos.block.logicalBlockNum = eloc.logicalBlockNum;
eloc.logicalBlockNum ++; eloc.logicalBlockNum++;
elen -= sb->s_blocksize; elen -= sb->s_blocksize;
if (!(epos.bh = udf_tread(sb, if (!(epos.bh = udf_tread(sb,
udf_get_lb_pblock(sb, epos.block, 0)))) udf_get_lb_pblock(sb,
{ epos.block,
0)))) {
brelse(oepos.bh); brelse(oepos.bh);
goto error_return; goto error_return;
} }
aed = (struct allocExtDesc *)(epos.bh->b_data); aed = (struct allocExtDesc *)(epos.bh->b_data);
aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum); aed->previousAllocExtLocation =
if (epos.offset + adsize > sb->s_blocksize) cpu_to_le32(oepos.block.logicalBlockNum);
{ if (epos.offset + adsize > sb->s_blocksize) {
loffset = epos.offset; loffset = epos.offset;
aed->lengthAllocDescs = cpu_to_le32(adsize); aed->lengthAllocDescs = cpu_to_le32(adsize);
sptr = UDF_I_DATA(inode) + epos.offset - sptr = UDF_I_DATA(inode) + epos.offset -
udf_file_entry_alloc_offset(inode) + udf_file_entry_alloc_offset(inode) +
UDF_I_LENEATTR(inode) - adsize; UDF_I_LENEATTR(inode) - adsize;
dptr = epos.bh->b_data + sizeof(struct allocExtDesc); dptr =
epos.bh->b_data +
sizeof(struct allocExtDesc);
memcpy(dptr, sptr, adsize); memcpy(dptr, sptr, adsize);
epos.offset = sizeof(struct allocExtDesc) + adsize; epos.offset =
} sizeof(struct allocExtDesc) + adsize;
else } else {
{
loffset = epos.offset + adsize; loffset = epos.offset + adsize;
aed->lengthAllocDescs = cpu_to_le32(0); aed->lengthAllocDescs = cpu_to_le32(0);
sptr = oepos.bh->b_data + epos.offset; sptr = oepos.bh->b_data + epos.offset;
epos.offset = sizeof(struct allocExtDesc); epos.offset = sizeof(struct allocExtDesc);
if (oepos.bh) if (oepos.bh) {
{ aed =
aed = (struct allocExtDesc *)oepos.bh->b_data; (struct allocExtDesc *)oepos.bh->
b_data;
aed->lengthAllocDescs = aed->lengthAllocDescs =
cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize); cpu_to_le32(le32_to_cpu
} (aed->
else lengthAllocDescs) +
{ adsize);
} else {
UDF_I_LENALLOC(table) += adsize; UDF_I_LENALLOC(table) += adsize;
mark_inode_dirty(table); mark_inode_dirty(table);
} }
} }
if (UDF_SB_UDFREV(sb) >= 0x0200) if (UDF_SB_UDFREV(sb) >= 0x0200)
udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1, udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3,
epos.block.logicalBlockNum, sizeof(tag)); 1, epos.block.logicalBlockNum,
sizeof(tag));
else else
udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1, udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2,
epos.block.logicalBlockNum, sizeof(tag)); 1, epos.block.logicalBlockNum,
switch (UDF_I_ALLOCTYPE(table)) sizeof(tag));
{ switch (UDF_I_ALLOCTYPE(table)) {
case ICBTAG_FLAG_AD_SHORT: case ICBTAG_FLAG_AD_SHORT:
{ {
sad = (short_ad *)sptr; sad = (short_ad *) sptr;
sad->extLength = cpu_to_le32( sad->extLength =
EXT_NEXT_EXTENT_ALLOCDECS | cpu_to_le32
sb->s_blocksize); (EXT_NEXT_EXTENT_ALLOCDECS | sb->
sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum); s_blocksize);
sad->extPosition =
cpu_to_le32(epos.block.
logicalBlockNum);
break; break;
} }
case ICBTAG_FLAG_AD_LONG: case ICBTAG_FLAG_AD_LONG:
{ {
lad = (long_ad *)sptr; lad = (long_ad *) sptr;
lad->extLength = cpu_to_le32( lad->extLength =
EXT_NEXT_EXTENT_ALLOCDECS | cpu_to_le32
sb->s_blocksize); (EXT_NEXT_EXTENT_ALLOCDECS | sb->
lad->extLocation = cpu_to_lelb(epos.block); s_blocksize);
lad->extLocation =
cpu_to_lelb(epos.block);
break; break;
} }
} }
if (oepos.bh) if (oepos.bh) {
{
udf_update_tag(oepos.bh->b_data, loffset); udf_update_tag(oepos.bh->b_data, loffset);
mark_buffer_dirty(oepos.bh); mark_buffer_dirty(oepos.bh);
} } else
else
mark_inode_dirty(table); 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); udf_write_aext(table, &epos, eloc, elen, 1);
if (!epos.bh) if (!epos.bh) {
{
UDF_I_LENALLOC(table) += adsize; UDF_I_LENALLOC(table) += adsize;
mark_inode_dirty(table); mark_inode_dirty(table);
} } else {
else
{
aed = (struct allocExtDesc *)epos.bh->b_data; aed = (struct allocExtDesc *)epos.bh->b_data;
aed->lengthAllocDescs = 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); udf_update_tag(epos.bh->b_data, epos.offset);
mark_buffer_dirty(epos.bh); mark_buffer_dirty(epos.bh);
} }
...@@ -661,16 +680,16 @@ static void udf_table_free_blocks(struct super_block * sb, ...@@ -661,16 +680,16 @@ static void udf_table_free_blocks(struct super_block * sb,
brelse(epos.bh); brelse(epos.bh);
brelse(oepos.bh); brelse(oepos.bh);
error_return: error_return:
sb->s_dirt = 1; sb->s_dirt = 1;
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
return; return;
} }
static int udf_table_prealloc_blocks(struct super_block * sb, static int udf_table_prealloc_blocks(struct super_block *sb,
struct inode * inode, struct inode *inode,
struct inode *table, uint16_t partition, uint32_t first_block, struct inode *table, uint16_t partition,
uint32_t block_count) uint32_t first_block, uint32_t block_count)
{ {
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
int alloc_count = 0; int alloc_count = 0;
...@@ -696,39 +715,46 @@ static int udf_table_prealloc_blocks(struct super_block * sb, ...@@ -696,39 +715,46 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
eloc.logicalBlockNum = 0xFFFFFFFF; eloc.logicalBlockNum = 0xFFFFFFFF;
while (first_block != eloc.logicalBlockNum && (etype = while (first_block != eloc.logicalBlockNum && (etype =
udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) udf_next_aext(table,
{ &epos,
&eloc,
&elen,
1)) !=
-1) {
udf_debug("eloc=%d, elen=%d, first_block=%d\n", udf_debug("eloc=%d, elen=%d, first_block=%d\n",
eloc.logicalBlockNum, elen, first_block); eloc.logicalBlockNum, elen, first_block);
; /* empty loop body */ ; /* empty loop body */
} }
if (first_block == eloc.logicalBlockNum) if (first_block == eloc.logicalBlockNum) {
{
epos.offset -= adsize; epos.offset -= adsize;
alloc_count = (elen >> sb->s_blocksize_bits); 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; alloc_count = 0;
else if (alloc_count > block_count) else if (alloc_count > block_count) {
{
alloc_count = block_count; alloc_count = block_count;
eloc.logicalBlockNum += alloc_count; eloc.logicalBlockNum += alloc_count;
elen -= (alloc_count << sb->s_blocksize_bits); elen -= (alloc_count << sb->s_blocksize_bits);
udf_write_aext(table, &epos, eloc, (etype << 30) | elen, 1); udf_write_aext(table, &epos, eloc, (etype << 30) | elen,
} 1);
else } else
udf_delete_aext(table, epos, eloc, (etype << 30) | elen); udf_delete_aext(table, epos, eloc,
} (etype << 30) | elen);
else } else
alloc_count = 0; alloc_count = 0;
brelse(epos.bh); brelse(epos.bh);
if (alloc_count && UDF_SB_LVIDBH(sb)) if (alloc_count && UDF_SB_LVIDBH(sb)) {
{
UDF_SB_LVID(sb)->freeSpaceTable[partition] = 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)); mark_buffer_dirty(UDF_SB_LVIDBH(sb));
sb->s_dirt = 1; sb->s_dirt = 1;
} }
...@@ -736,9 +762,10 @@ static int udf_table_prealloc_blocks(struct super_block * sb, ...@@ -736,9 +762,10 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
return alloc_count; return alloc_count;
} }
static int udf_table_new_block(struct super_block * sb, static int udf_table_new_block(struct super_block *sb,
struct inode * inode, struct inode *inode,
struct inode *table, uint16_t partition, uint32_t goal, int *err) struct inode *table, uint16_t partition,
uint32_t goal, int *err)
{ {
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF; uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
...@@ -771,24 +798,21 @@ static int udf_table_new_block(struct super_block * sb, ...@@ -771,24 +798,21 @@ static int udf_table_new_block(struct super_block * sb,
epos.bh = goal_epos.bh = NULL; epos.bh = goal_epos.bh = NULL;
while (spread && (etype = while (spread && (etype =
udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
{ if (goal >= eloc.logicalBlockNum) {
if (goal >= eloc.logicalBlockNum) if (goal <
{ eloc.logicalBlockNum +
if (goal < eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) (elen >> sb->s_blocksize_bits))
nspread = 0; nspread = 0;
else else
nspread = goal - eloc.logicalBlockNum - nspread = goal - eloc.logicalBlockNum -
(elen >> sb->s_blocksize_bits); (elen >> sb->s_blocksize_bits);
} } else
else
nspread = eloc.logicalBlockNum - goal; nspread = eloc.logicalBlockNum - goal;
if (nspread < spread) if (nspread < spread) {
{
spread = nspread; spread = nspread;
if (goal_epos.bh != epos.bh) if (goal_epos.bh != epos.bh) {
{
brelse(goal_epos.bh); brelse(goal_epos.bh);
goal_epos.bh = epos.bh; goal_epos.bh = epos.bh;
get_bh(goal_epos.bh); get_bh(goal_epos.bh);
...@@ -802,8 +826,7 @@ static int udf_table_new_block(struct super_block * sb, ...@@ -802,8 +826,7 @@ static int udf_table_new_block(struct super_block * sb,
brelse(epos.bh); brelse(epos.bh);
if (spread == 0xFFFFFFFF) if (spread == 0xFFFFFFFF) {
{
brelse(goal_epos.bh); brelse(goal_epos.bh);
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
return 0; return 0;
...@@ -815,11 +838,10 @@ static int udf_table_new_block(struct super_block * sb, ...@@ -815,11 +838,10 @@ static int udf_table_new_block(struct super_block * sb,
/* This works, but very poorly.... */ /* This works, but very poorly.... */
newblock = goal_eloc.logicalBlockNum; newblock = goal_eloc.logicalBlockNum;
goal_eloc.logicalBlockNum ++; goal_eloc.logicalBlockNum++;
goal_elen -= sb->s_blocksize; goal_elen -= sb->s_blocksize;
if (inode && DQUOT_ALLOC_BLOCK(inode, 1)) if (inode && DQUOT_ALLOC_BLOCK(inode, 1)) {
{
brelse(goal_epos.bh); brelse(goal_epos.bh);
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
*err = -EDQUOT; *err = -EDQUOT;
...@@ -832,10 +854,11 @@ static int udf_table_new_block(struct super_block * sb, ...@@ -832,10 +854,11 @@ static int udf_table_new_block(struct super_block * sb,
udf_delete_aext(table, goal_epos, goal_eloc, goal_elen); udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
brelse(goal_epos.bh); brelse(goal_epos.bh);
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb)) {
{
UDF_SB_LVID(sb)->freeSpaceTable[partition] = 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)); mark_buffer_dirty(UDF_SB_LVIDBH(sb));
} }
...@@ -845,105 +868,99 @@ static int udf_table_new_block(struct super_block * sb, ...@@ -845,105 +868,99 @@ static int udf_table_new_block(struct super_block * sb,
return newblock; return newblock;
} }
inline void udf_free_blocks(struct super_block * sb, inline void udf_free_blocks(struct super_block *sb,
struct inode * inode, struct inode *inode,
kernel_lb_addr bloc, uint32_t offset, uint32_t count) kernel_lb_addr bloc, uint32_t offset,
uint32_t count)
{ {
uint16_t partition = bloc.partitionReferenceNum; uint16_t partition = bloc.partitionReferenceNum;
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
{
return udf_bitmap_free_blocks(sb, inode, return udf_bitmap_free_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap, UDF_SB_PARTMAPS(sb)[partition].
bloc, offset, count); s_uspace.s_bitmap, bloc, offset,
} count);
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_free_blocks(sb, inode, return udf_table_free_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table, UDF_SB_PARTMAPS(sb)[partition].
bloc, offset, count); s_uspace.s_table, bloc, offset,
} count);
else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
{
return udf_bitmap_free_blocks(sb, inode, return udf_bitmap_free_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap, UDF_SB_PARTMAPS(sb)[partition].
bloc, offset, count); s_fspace.s_bitmap, bloc, offset,
} count);
else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
{
return udf_table_free_blocks(sb, inode, return udf_table_free_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table, UDF_SB_PARTMAPS(sb)[partition].
bloc, offset, count); s_fspace.s_table, bloc, offset,
} count);
else } else
return; return;
} }
inline int udf_prealloc_blocks(struct super_block * sb, inline int udf_prealloc_blocks(struct super_block *sb,
struct inode * inode, struct inode *inode,
uint16_t partition, uint32_t first_block, uint32_t block_count) uint16_t partition, uint32_t first_block,
uint32_t block_count)
{ {
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
{
return udf_bitmap_prealloc_blocks(sb, inode, return udf_bitmap_prealloc_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap, UDF_SB_PARTMAPS(sb)
partition, first_block, block_count); [partition].s_uspace.s_bitmap,
} partition, first_block,
else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) block_count);
{ } else if (UDF_SB_PARTFLAGS(sb, partition) &
UDF_PART_FLAG_UNALLOC_TABLE) {
return udf_table_prealloc_blocks(sb, inode, return udf_table_prealloc_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table, UDF_SB_PARTMAPS(sb)[partition].
partition, first_block, block_count); s_uspace.s_table, partition,
} first_block, block_count);
else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
{
return udf_bitmap_prealloc_blocks(sb, inode, return udf_bitmap_prealloc_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap, UDF_SB_PARTMAPS(sb)
partition, first_block, block_count); [partition].s_fspace.s_bitmap,
} partition, first_block,
else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) block_count);
{ } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
return udf_table_prealloc_blocks(sb, inode, return udf_table_prealloc_blocks(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table, UDF_SB_PARTMAPS(sb)[partition].
partition, first_block, block_count); s_fspace.s_table, partition,
} first_block, block_count);
else } else
return 0; return 0;
} }
inline int udf_new_block(struct super_block * sb, inline int udf_new_block(struct super_block *sb,
struct inode * inode, struct inode *inode,
uint16_t partition, uint32_t goal, int *err) uint16_t partition, uint32_t goal, int *err)
{ {
int ret; int ret;
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
{
ret = udf_bitmap_new_block(sb, inode, ret = udf_bitmap_new_block(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap, UDF_SB_PARTMAPS(sb)[partition].
partition, goal, err); s_uspace.s_bitmap, partition, goal,
err);
return ret; return ret;
} } else if (UDF_SB_PARTFLAGS(sb, partition) &
else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) UDF_PART_FLAG_UNALLOC_TABLE) {
{
return udf_table_new_block(sb, inode, return udf_table_new_block(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table, UDF_SB_PARTMAPS(sb)[partition].
partition, goal, err); s_uspace.s_table, partition, goal,
} err);
else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
{
return udf_bitmap_new_block(sb, inode, return udf_bitmap_new_block(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap, UDF_SB_PARTMAPS(sb)[partition].
partition, goal, err); s_fspace.s_bitmap, partition, goal,
} err);
else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
{
return udf_table_new_block(sb, inode, return udf_table_new_block(sb, inode,
UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table, UDF_SB_PARTMAPS(sb)[partition].
partition, goal, err); s_fspace.s_table, partition, goal,
} err);
else } else {
{
*err = -EIO; *err = -EIO;
return 0; return 0;
} }
......
fs/udf/crc.c
View file @ cb00ea35
...@@ -79,8 +79,7 @@ static uint16_t crc_table[256] = { ...@@ -79,8 +79,7 @@ static uint16_t crc_table[256] = {
* July 21, 1997 - Andrew E. Mileski * July 21, 1997 - Andrew E. Mileski
* Adapted from OSTA-UDF(tm) 1.50 standard. * Adapted from OSTA-UDF(tm) 1.50 standard.
*/ */
uint16_t uint16_t udf_crc(uint8_t * data, uint32_t size, uint16_t crc)
udf_crc(uint8_t *data, uint32_t size, uint16_t crc)
{ {
while (size--) while (size--)
crc = crc_table[(crc >> 8 ^ *(data++)) & 0xffU] ^ (crc << 8); crc = crc_table[(crc >> 8 ^ *(data++)) & 0xffU] ^ (crc << 8);
...@@ -138,7 +137,7 @@ int main(int argc, char **argv) ...@@ -138,7 +137,7 @@ int main(int argc, char **argv)
/* Get the polynomial */ /* Get the polynomial */
sscanf(argv[1], "%lo", &poly); sscanf(argv[1], "%lo", &poly);
if (poly & 0xffff0000U){ if (poly & 0xffff0000U) {
fprintf(stderr, "polynomial is too large\en"); fprintf(stderr, "polynomial is too large\en");
exit(1); exit(1);
} }
...@@ -147,12 +146,12 @@ int main(int argc, char **argv) ...@@ -147,12 +146,12 @@ int main(int argc, char **argv)
/* Create a table */ /* Create a table */
printf("static unsigned short crc_table[256] = {\n"); printf("static unsigned short crc_table[256] = {\n");
for (n = 0; n < 256; n++){ for (n = 0; n < 256; n++) {
if (n % 8 == 0) if (n % 8 == 0)
printf("\t"); printf("\t");
crc = n << 8; crc = n << 8;
for (i = 0; i < 8; i++){ for (i = 0; i < 8; i++) {
if(crc & 0x8000U) if (crc & 0x8000U)
crc = (crc << 1) ^ poly; crc = (crc << 1) ^ poly;
else else
crc <<= 1; crc <<= 1;
...@@ -162,7 +161,7 @@ int main(int argc, char **argv) ...@@ -162,7 +161,7 @@ int main(int argc, char **argv)
printf("0x%04xU ", crc); printf("0x%04xU ", crc);
else else
printf("0x%04xU, ", crc); printf("0x%04xU, ", crc);
if(n % 8 == 7) if (n % 8 == 7)
printf("\n"); printf("\n");
} }
printf("};\n"); printf("};\n");
......
fs/udf/dir.c
View file @ cb00ea35
...@@ -82,14 +82,13 @@ int udf_readdir(struct file *filp, void *dirent, filldir_t filldir) ...@@ -82,14 +82,13 @@ int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
lock_kernel(); lock_kernel();
if ( filp->f_pos == 0 ) if (filp->f_pos == 0) {
{ if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) <
if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) < 0) 0) {
{
unlock_kernel(); unlock_kernel();
return 0; return 0;
} }
filp->f_pos ++; filp->f_pos++;
} }
result = do_udf_readdir(dir, filp, filldir, dirent); result = do_udf_readdir(dir, filp, filldir, dirent);
...@@ -98,10 +97,11 @@ int udf_readdir(struct file *filp, void *dirent, filldir_t filldir) ...@@ -98,10 +97,11 @@ int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
} }
static int static int
do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *dirent) do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
void *dirent)
{ {
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct fileIdentDesc *fi=NULL; struct fileIdentDesc *fi = NULL;
struct fileIdentDesc cfi; struct fileIdentDesc cfi;
int block, iblock; int block, iblock;
loff_t nf_pos = filp->f_pos - 1; loff_t nf_pos = filp->f_pos - 1;
...@@ -117,7 +117,7 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d ...@@ -117,7 +117,7 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
sector_t offset; sector_t offset;
int i, num; int i, num;
unsigned int dt_type; unsigned int dt_type;
struct extent_position epos = { NULL, 0, {0, 0}}; struct extent_position epos = { NULL, 0, {0, 0} };
if (nf_pos >= size) if (nf_pos >= size)
return 0; return 0;
...@@ -125,65 +125,61 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d ...@@ -125,65 +125,61 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
if (nf_pos == 0) if (nf_pos == 0)
nf_pos = (udf_ext0_offset(dir) >> 2); nf_pos = (udf_ext0_offset(dir) >> 2);
fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; fibh.soffset = fibh.eoffset =
(nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
fibh.sbh = fibh.ebh = NULL; fibh.sbh = fibh.ebh = NULL;
else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2), else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) &epos, &eloc, &elen,
{ &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset); block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
{
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad); epos.offset -= sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad); epos.offset -= sizeof(long_ad);
} } else
else
offset = 0; offset = 0;
if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) {
{
brelse(epos.bh); brelse(epos.bh);
return -EIO; return -EIO;
} }
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); i = 16 >> (dir->i_sb->s_blocksize_bits - 9);
if (i+offset > (elen >> dir->i_sb->s_blocksize_bits)) 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) -
for (num=0; i>0; i--) 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); 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; bha[num++] = tmp;
else else
brelse(tmp); brelse(tmp);
} }
if (num) if (num) {
{
ll_rw_block(READA, num, bha); ll_rw_block(READA, num, bha);
for (i=0; i<num; i++) for (i = 0; i < num; i++)
brelse(bha[i]); brelse(bha[i]);
} }
} }
} } else {
else
{
brelse(epos.bh); brelse(epos.bh);
return -ENOENT; return -ENOENT;
} }
while ( nf_pos < size ) while (nf_pos < size) {
{
filp->f_pos = nf_pos + 1; filp->f_pos = nf_pos + 1;
fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset); fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc,
&elen, &offset);
if (!fi) if (!fi) {
{
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
brelse(fibh.sbh); brelse(fibh.sbh);
...@@ -196,43 +192,41 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d ...@@ -196,43 +192,41 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
if (fibh.sbh == fibh.ebh) if (fibh.sbh == fibh.ebh)
nameptr = fi->fileIdent + liu; nameptr = fi->fileIdent + liu;
else else {
{
int poffset; /* Unpaded ending offset */ int poffset; /* Unpaded ending offset */
poffset = fibh.soffset + sizeof(struct fileIdentDesc) + liu + lfi; poffset =
fibh.soffset + sizeof(struct fileIdentDesc) + liu +
lfi;
if (poffset >= lfi) if (poffset >= lfi)
nameptr = (char *)(fibh.ebh->b_data + poffset - lfi); nameptr =
else (char *)(fibh.ebh->b_data + poffset - lfi);
{ else {
nameptr = fname; nameptr = fname;
memcpy(nameptr, fi->fileIdent + liu, lfi - poffset); memcpy(nameptr, fi->fileIdent + liu,
memcpy(nameptr + lfi - poffset, fibh.ebh->b_data, poffset); lfi - poffset);
memcpy(nameptr + lfi - poffset,
fibh.ebh->b_data, poffset);
} }
} }
if ( (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 ) if ((cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
{ if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE))
if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE) )
continue; continue;
} }
if ( (cfi.fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0 ) if ((cfi.fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0) {
{ if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE))
if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE) )
continue; continue;
} }
if ( cfi.fileCharacteristics & FID_FILE_CHAR_PARENT ) if (cfi.fileCharacteristics & FID_FILE_CHAR_PARENT) {
{
iblock = parent_ino(filp->f_path.dentry); iblock = parent_ino(filp->f_path.dentry);
flen = 2; flen = 2;
memcpy(fname, "..", flen); memcpy(fname, "..", flen);
dt_type = DT_DIR; dt_type = DT_DIR;
} } else {
else
{
kernel_lb_addr tloc = lelb_to_cpu(cfi.icb.extLocation); kernel_lb_addr tloc = lelb_to_cpu(cfi.icb.extLocation);
iblock = udf_get_lb_pblock(dir->i_sb, tloc, 0); iblock = udf_get_lb_pblock(dir->i_sb, tloc, 0);
...@@ -240,10 +234,10 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d ...@@ -240,10 +234,10 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
dt_type = DT_UNKNOWN; dt_type = DT_UNKNOWN;
} }
if (flen) if (flen) {
{ if (filldir
if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0) (dirent, fname, flen, filp->f_pos, iblock,
{ dt_type) < 0) {
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
brelse(fibh.sbh); brelse(fibh.sbh);
......
fs/udf/directory.c
View file @ cb00ea35
...@@ -19,10 +19,10 @@ ...@@ -19,10 +19,10 @@
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#if 0 #if 0
static uint8_t * static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
udf_filead_read(struct inode *dir, uint8_t *tmpad, uint8_t ad_size, uint8_t ad_size, kernel_lb_addr fe_loc,
kernel_lb_addr fe_loc, int *pos, int *offset, int *pos, int *offset, struct buffer_head **bh,
struct buffer_head **bh, int *error) int *error)
{ {
int loffset = *offset; int loffset = *offset;
int block; int block;
...@@ -31,31 +31,27 @@ udf_filead_read(struct inode *dir, uint8_t *tmpad, uint8_t ad_size, ...@@ -31,31 +31,27 @@ udf_filead_read(struct inode *dir, uint8_t *tmpad, uint8_t ad_size,
*error = 0; *error = 0;
ad = (uint8_t *)(*bh)->b_data + *offset; ad = (uint8_t *) (*bh)->b_data + *offset;
*offset += ad_size; *offset += ad_size;
if (!ad) if (!ad) {
{
brelse(*bh); brelse(*bh);
*error = 1; *error = 1;
return NULL; return NULL;
} }
if (*offset == dir->i_sb->s_blocksize) if (*offset == dir->i_sb->s_blocksize) {
{
brelse(*bh); brelse(*bh);
block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos); block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
if (!block) if (!block)
return NULL; return NULL;
if (!(*bh = udf_tread(dir->i_sb, block))) if (!(*bh = udf_tread(dir->i_sb, block)))
return NULL; return NULL;
} } else if (*offset > dir->i_sb->s_blocksize) {
else if (*offset > dir->i_sb->s_blocksize)
{
ad = tmpad; ad = tmpad;
remainder = dir->i_sb->s_blocksize - loffset; 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); brelse(*bh);
block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos); block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
...@@ -64,47 +60,47 @@ udf_filead_read(struct inode *dir, uint8_t *tmpad, uint8_t ad_size, ...@@ -64,47 +60,47 @@ udf_filead_read(struct inode *dir, uint8_t *tmpad, uint8_t ad_size,
if (!((*bh) = udf_tread(dir->i_sb, block))) if (!((*bh) = udf_tread(dir->i_sb, block)))
return NULL; 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; *offset = ad_size - remainder;
} }
return ad; return ad;
} }
#endif #endif
struct fileIdentDesc * struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
udf_fileident_read(struct inode *dir, loff_t *nf_pos,
struct udf_fileident_bh *fibh, struct udf_fileident_bh *fibh,
struct fileIdentDesc *cfi, struct fileIdentDesc *cfi,
struct extent_position *epos, struct extent_position *epos,
kernel_lb_addr *eloc, uint32_t *elen, kernel_lb_addr * eloc, uint32_t * elen,
sector_t *offset) sector_t * offset)
{ {
struct fileIdentDesc *fi; struct fileIdentDesc *fi;
int i, num, block; int i, num, block;
struct buffer_head * tmp, * bha[16]; struct buffer_head *tmp, *bha[16];
fibh->soffset = fibh->eoffset; fibh->soffset = fibh->eoffset;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
{
fi = udf_get_fileident(UDF_I_DATA(dir) - fi = udf_get_fileident(UDF_I_DATA(dir) -
(UDF_I_EFE(dir) ? (UDF_I_EFE(dir) ?
sizeof(struct extendedFileEntry) : sizeof(struct extendedFileEntry) :
sizeof(struct fileEntry)), sizeof(struct fileEntry)),
dir->i_sb->s_blocksize, &(fibh->eoffset)); dir->i_sb->s_blocksize,
&(fibh->eoffset));
if (!fi) if (!fi)
return NULL; return NULL;
*nf_pos += ((fibh->eoffset - fibh->soffset) >> 2); *nf_pos += ((fibh->eoffset - fibh->soffset) >> 2);
memcpy((uint8_t *)cfi, (uint8_t *)fi, sizeof(struct fileIdentDesc)); memcpy((uint8_t *) cfi, (uint8_t *) fi,
sizeof(struct fileIdentDesc));
return fi; return fi;
} }
if (fibh->eoffset == dir->i_sb->s_blocksize) if (fibh->eoffset == dir->i_sb->s_blocksize) {
{
int lextoffset = epos->offset; int lextoffset = epos->offset;
if (udf_next_aext(dir, epos, eloc, elen, 1) != if (udf_next_aext(dir, epos, eloc, elen, 1) !=
...@@ -113,7 +109,7 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, ...@@ -113,7 +109,7 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset); block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset);
(*offset) ++; (*offset)++;
if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen) if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)
*offset = 0; *offset = 0;
...@@ -125,30 +121,32 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, ...@@ -125,30 +121,32 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
return NULL; return NULL;
fibh->soffset = fibh->eoffset = 0; 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); i = 16 >> (dir->i_sb->s_blocksize_bits - 9);
if (i+*offset > (*elen >> dir->i_sb->s_blocksize_bits)) if (i + *offset >
i = (*elen >> dir->i_sb->s_blocksize_bits)-*offset; (*elen >> dir->i_sb->s_blocksize_bits))
for (num=0; i>0; i--) i = (*elen >> dir->i_sb->s_blocksize_bits) -
{ *offset;
block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset+i); for (num = 0; i > 0; i--) {
block =
udf_get_lb_pblock(dir->i_sb, *eloc,
*offset + i);
tmp = udf_tgetblk(dir->i_sb, block); 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; bha[num++] = tmp;
else else
brelse(tmp); brelse(tmp);
} }
if (num) if (num) {
{
ll_rw_block(READA, num, bha); ll_rw_block(READA, num, bha);
for (i=0; i<num; i++) for (i = 0; i < num; i++)
brelse(bha[i]); brelse(bha[i]);
} }
} }
} } else if (fibh->sbh != fibh->ebh) {
else if (fibh->sbh != fibh->ebh)
{
brelse(fibh->sbh); brelse(fibh->sbh);
fibh->sbh = fibh->ebh; fibh->sbh = fibh->ebh;
} }
...@@ -161,12 +159,10 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, ...@@ -161,12 +159,10 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
*nf_pos += ((fibh->eoffset - fibh->soffset) >> 2); *nf_pos += ((fibh->eoffset - fibh->soffset) >> 2);
if (fibh->eoffset <= dir->i_sb->s_blocksize) 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)); sizeof(struct fileIdentDesc));
} } else if (fibh->eoffset > dir->i_sb->s_blocksize) {
else if (fibh->eoffset > dir->i_sb->s_blocksize)
{
int lextoffset = epos->offset; int lextoffset = epos->offset;
if (udf_next_aext(dir, epos, eloc, elen, 1) != if (udf_next_aext(dir, epos, eloc, elen, 1) !=
...@@ -175,7 +171,7 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, ...@@ -175,7 +171,7 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset); block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset);
(*offset) ++; (*offset)++;
if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen) if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)
*offset = 0; *offset = 0;
...@@ -188,60 +184,60 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos, ...@@ -188,60 +184,60 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
if (!(fibh->ebh = udf_tread(dir->i_sb, block))) if (!(fibh->ebh = udf_tread(dir->i_sb, block)))
return NULL; return NULL;
if (sizeof(struct fileIdentDesc) > - fibh->soffset) if (sizeof(struct fileIdentDesc) > -fibh->soffset) {
{
int fi_len; int fi_len;
memcpy((uint8_t *)cfi, (uint8_t *)fi, - fibh->soffset); memcpy((uint8_t *) cfi, (uint8_t *) fi, -fibh->soffset);
memcpy((uint8_t *)cfi - fibh->soffset, fibh->ebh->b_data, memcpy((uint8_t *) cfi - fibh->soffset,
fibh->ebh->b_data,
sizeof(struct fileIdentDesc) + fibh->soffset); sizeof(struct fileIdentDesc) + fibh->soffset);
fi_len = (sizeof(struct fileIdentDesc) + cfi->lengthFileIdent + fi_len =
(sizeof(struct fileIdentDesc) +
cfi->lengthFileIdent +
le16_to_cpu(cfi->lengthOfImpUse) + 3) & ~3; 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; fibh->eoffset = fibh->soffset + fi_len;
} } else {
else memcpy((uint8_t *) cfi, (uint8_t *) fi,
{ sizeof(struct fileIdentDesc));
memcpy((uint8_t *)cfi, (uint8_t *)fi, sizeof(struct fileIdentDesc));
} }
} }
return fi; return fi;
} }
struct fileIdentDesc * struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, int *offset)
udf_get_fileident(void * buffer, int bufsize, int * offset)
{ {
struct fileIdentDesc *fi; struct fileIdentDesc *fi;
int lengthThisIdent; int lengthThisIdent;
uint8_t * ptr; uint8_t *ptr;
int padlen; int padlen;
if ( (!buffer) || (!offset) ) { if ((!buffer) || (!offset)) {
udf_debug("invalidparms\n, buffer=%p, offset=%p\n", buffer, offset); udf_debug("invalidparms\n, buffer=%p, offset=%p\n", buffer,
offset);
return NULL; return NULL;
} }
ptr = buffer; ptr = buffer;
if ( (*offset > 0) && (*offset < bufsize) ) { if ((*offset > 0) && (*offset < bufsize)) {
ptr += *offset; ptr += *offset;
} }
fi=(struct fileIdentDesc *)ptr; fi = (struct fileIdentDesc *)ptr;
if (le16_to_cpu(fi->descTag.tagIdent) != TAG_IDENT_FID) if (le16_to_cpu(fi->descTag.tagIdent) != TAG_IDENT_FID) {
{
udf_debug("0x%x != TAG_IDENT_FID\n", udf_debug("0x%x != TAG_IDENT_FID\n",
le16_to_cpu(fi->descTag.tagIdent)); le16_to_cpu(fi->descTag.tagIdent));
udf_debug("offset: %u sizeof: %lu bufsize: %u\n", udf_debug("offset: %u sizeof: %lu bufsize: %u\n",
*offset, (unsigned long)sizeof(struct fileIdentDesc), bufsize); *offset, (unsigned long)sizeof(struct fileIdentDesc),
bufsize);
return NULL; return NULL;
} }
if ( (*offset + sizeof(struct fileIdentDesc)) > bufsize ) if ((*offset + sizeof(struct fileIdentDesc)) > bufsize) {
{
lengthThisIdent = sizeof(struct fileIdentDesc); lengthThisIdent = sizeof(struct fileIdentDesc);
} } else
else
lengthThisIdent = sizeof(struct fileIdentDesc) + lengthThisIdent = sizeof(struct fileIdentDesc) +
fi->lengthFileIdent + le16_to_cpu(fi->lengthOfImpUse); fi->lengthFileIdent + le16_to_cpu(fi->lengthOfImpUse);
...@@ -255,56 +251,53 @@ udf_get_fileident(void * buffer, int bufsize, int * offset) ...@@ -255,56 +251,53 @@ udf_get_fileident(void * buffer, int bufsize, int * offset)
} }
#if 0 #if 0
static extent_ad * static extent_ad *udf_get_fileextent(void *buffer, int bufsize, int *offset)
udf_get_fileextent(void * buffer, int bufsize, int * offset)
{ {
extent_ad * ext; extent_ad *ext;
struct fileEntry *fe; struct fileEntry *fe;
uint8_t * ptr; uint8_t *ptr;
if ( (!buffer) || (!offset) ) if ((!buffer) || (!offset)) {
{
printk(KERN_ERR "udf: udf_get_fileextent() invalidparms\n"); printk(KERN_ERR "udf: udf_get_fileextent() invalidparms\n");
return NULL; return NULL;
} }
fe = (struct fileEntry *)buffer; fe = (struct fileEntry *)buffer;
if ( le16_to_cpu(fe->descTag.tagIdent) != TAG_IDENT_FE ) if (le16_to_cpu(fe->descTag.tagIdent) != TAG_IDENT_FE) {
{
udf_debug("0x%x != TAG_IDENT_FE\n", udf_debug("0x%x != TAG_IDENT_FE\n",
le16_to_cpu(fe->descTag.tagIdent)); le16_to_cpu(fe->descTag.tagIdent));
return NULL; 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)) ) if ((*offset > 0) && (*offset < le32_to_cpu(fe->lengthAllocDescs))) {
{
ptr += *offset; ptr += *offset;
} }
ext = (extent_ad *)ptr; ext = (extent_ad *) ptr;
*offset = *offset + sizeof(extent_ad); *offset = *offset + sizeof(extent_ad);
return ext; return ext;
} }
#endif #endif
short_ad * short_ad *udf_get_fileshortad(uint8_t * ptr, int maxoffset, int *offset,
udf_get_fileshortad(uint8_t *ptr, int maxoffset, int *offset, int inc) int inc)
{ {
short_ad *sa; short_ad *sa;
if ( (!ptr) || (!offset) ) if ((!ptr) || (!offset)) {
{
printk(KERN_ERR "udf: udf_get_fileshortad() invalidparms\n"); printk(KERN_ERR "udf: udf_get_fileshortad() invalidparms\n");
return NULL; return NULL;
} }
if ( (*offset < 0) || ((*offset + sizeof(short_ad)) > maxoffset) ) if ((*offset < 0) || ((*offset + sizeof(short_ad)) > maxoffset))
return NULL; return NULL;
else if ((sa = (short_ad *)ptr)->extLength == 0) else if ((sa = (short_ad *) ptr)->extLength == 0)
return NULL; return NULL;
if (inc) if (inc)
...@@ -312,20 +305,18 @@ udf_get_fileshortad(uint8_t *ptr, int maxoffset, int *offset, int inc) ...@@ -312,20 +305,18 @@ udf_get_fileshortad(uint8_t *ptr, int maxoffset, int *offset, int inc)
return sa; return sa;
} }
long_ad * long_ad *udf_get_filelongad(uint8_t * ptr, int maxoffset, int *offset, int inc)
udf_get_filelongad(uint8_t *ptr, int maxoffset, int * offset, int inc)
{ {
long_ad *la; long_ad *la;
if ( (!ptr) || (!offset) ) if ((!ptr) || (!offset)) {
{
printk(KERN_ERR "udf: udf_get_filelongad() invalidparms\n"); printk(KERN_ERR "udf: udf_get_filelongad() invalidparms\n");
return NULL; return NULL;
} }
if ( (*offset < 0) || ((*offset + sizeof(long_ad)) > maxoffset) ) if ((*offset < 0) || ((*offset + sizeof(long_ad)) > maxoffset))
return NULL; return NULL;
else if ((la = (long_ad *)ptr)->extLength == 0) else if ((la = (long_ad *) ptr)->extLength == 0)
return NULL; return NULL;
if (inc) if (inc)
......
fs/udf/ecma_167.h
View file @ cb00ea35
...@@ -38,8 +38,7 @@ ...@@ -38,8 +38,7 @@
#define _ECMA_167_H 1 #define _ECMA_167_H 1
/* Character set specification (ECMA 167r3 1/7.2.1) */ /* Character set specification (ECMA 167r3 1/7.2.1) */
typedef struct typedef struct {
{
uint8_t charSetType; uint8_t charSetType;
uint8_t charSetInfo[63]; uint8_t charSetInfo[63];
} __attribute__ ((packed)) charspec; } __attribute__ ((packed)) charspec;
...@@ -58,8 +57,7 @@ typedef struct ...@@ -58,8 +57,7 @@ typedef struct
typedef uint8_t dstring; typedef uint8_t dstring;
/* Timestamp (ECMA 167r3 1/7.3) */ /* Timestamp (ECMA 167r3 1/7.3) */
typedef struct typedef struct {
{
__le16 typeAndTimezone; __le16 typeAndTimezone;
__le16 year; __le16 year;
uint8_t month; uint8_t month;
...@@ -72,8 +70,7 @@ typedef struct ...@@ -72,8 +70,7 @@ typedef struct
uint8_t microseconds; uint8_t microseconds;
} __attribute__ ((packed)) timestamp; } __attribute__ ((packed)) timestamp;
typedef struct typedef struct {
{
uint16_t typeAndTimezone; uint16_t typeAndTimezone;
int16_t year; int16_t year;
uint8_t month; uint8_t month;
...@@ -94,8 +91,7 @@ typedef struct ...@@ -94,8 +91,7 @@ typedef struct
#define TIMESTAMP_TIMEZONE_MASK 0x0FFF #define TIMESTAMP_TIMEZONE_MASK 0x0FFF
/* Entity identifier (ECMA 167r3 1/7.4) */ /* Entity identifier (ECMA 167r3 1/7.4) */
typedef struct typedef struct {
{
uint8_t flags; uint8_t flags;
uint8_t ident[23]; uint8_t ident[23];
uint8_t identSuffix[8]; uint8_t identSuffix[8];
...@@ -107,8 +103,7 @@ typedef struct ...@@ -107,8 +103,7 @@ typedef struct
/* Volume Structure Descriptor (ECMA 167r3 2/9.1) */ /* Volume Structure Descriptor (ECMA 167r3 2/9.1) */
#define VSD_STD_ID_LEN 5 #define VSD_STD_ID_LEN 5
struct volStructDesc struct volStructDesc {
{
uint8_t structType; uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN]; uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion; uint8_t structVersion;
...@@ -127,8 +122,7 @@ struct volStructDesc ...@@ -127,8 +122,7 @@ struct volStructDesc
#define VSD_STD_ID_TEA01 "TEA01" /* (2/9.3) */ #define VSD_STD_ID_TEA01 "TEA01" /* (2/9.3) */
/* Beginning Extended Area Descriptor (ECMA 167r3 2/9.2) */ /* Beginning Extended Area Descriptor (ECMA 167r3 2/9.2) */
struct beginningExtendedAreaDesc struct beginningExtendedAreaDesc {
{
uint8_t structType; uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN]; uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion; uint8_t structVersion;
...@@ -136,8 +130,7 @@ struct beginningExtendedAreaDesc ...@@ -136,8 +130,7 @@ struct beginningExtendedAreaDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Terminating Extended Area Descriptor (ECMA 167r3 2/9.3) */ /* Terminating Extended Area Descriptor (ECMA 167r3 2/9.3) */
struct terminatingExtendedAreaDesc struct terminatingExtendedAreaDesc {
{
uint8_t structType; uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN]; uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion; uint8_t structVersion;
...@@ -145,8 +138,7 @@ struct terminatingExtendedAreaDesc ...@@ -145,8 +138,7 @@ struct terminatingExtendedAreaDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Boot Descriptor (ECMA 167r3 2/9.4) */ /* Boot Descriptor (ECMA 167r3 2/9.4) */
struct bootDesc struct bootDesc {
{
uint8_t structType; uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN]; uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion; uint8_t structVersion;
...@@ -167,21 +159,18 @@ struct bootDesc ...@@ -167,21 +159,18 @@ struct bootDesc
#define BOOT_FLAGS_ERASE 0x01 #define BOOT_FLAGS_ERASE 0x01
/* Extent Descriptor (ECMA 167r3 3/7.1) */ /* Extent Descriptor (ECMA 167r3 3/7.1) */
typedef struct typedef struct {
{
__le32 extLength; __le32 extLength;
__le32 extLocation; __le32 extLocation;
} __attribute__ ((packed)) extent_ad; } __attribute__ ((packed)) extent_ad;
typedef struct typedef struct {
{
uint32_t extLength; uint32_t extLength;
uint32_t extLocation; uint32_t extLocation;
} kernel_extent_ad; } kernel_extent_ad;
/* Descriptor Tag (ECMA 167r3 3/7.2) */ /* Descriptor Tag (ECMA 167r3 3/7.2) */
typedef struct typedef struct {
{
__le16 tagIdent; __le16 tagIdent;
__le16 descVersion; __le16 descVersion;
uint8_t tagChecksum; uint8_t tagChecksum;
...@@ -204,8 +193,7 @@ typedef struct ...@@ -204,8 +193,7 @@ typedef struct
#define TAG_IDENT_LVID 0x0009 #define TAG_IDENT_LVID 0x0009
/* NSR Descriptor (ECMA 167r3 3/9.1) */ /* NSR Descriptor (ECMA 167r3 3/9.1) */
struct NSRDesc struct NSRDesc {
{
uint8_t structType; uint8_t structType;
uint8_t stdIdent[VSD_STD_ID_LEN]; uint8_t stdIdent[VSD_STD_ID_LEN];
uint8_t structVersion; uint8_t structVersion;
...@@ -214,8 +202,7 @@ struct NSRDesc ...@@ -214,8 +202,7 @@ struct NSRDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Primary Volume Descriptor (ECMA 167r3 3/10.1) */ /* Primary Volume Descriptor (ECMA 167r3 3/10.1) */
struct primaryVolDesc struct primaryVolDesc {
{
tag descTag; tag descTag;
__le32 volDescSeqNum; __le32 volDescSeqNum;
__le32 primaryVolDescNum; __le32 primaryVolDescNum;
...@@ -244,8 +231,7 @@ struct primaryVolDesc ...@@ -244,8 +231,7 @@ struct primaryVolDesc
#define PVD_FLAGS_VSID_COMMON 0x0001 #define PVD_FLAGS_VSID_COMMON 0x0001
/* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) */ /* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) */
struct anchorVolDescPtr struct anchorVolDescPtr {
{
tag descTag; tag descTag;
extent_ad mainVolDescSeqExt; extent_ad mainVolDescSeqExt;
extent_ad reserveVolDescSeqExt; extent_ad reserveVolDescSeqExt;
...@@ -253,8 +239,7 @@ struct anchorVolDescPtr ...@@ -253,8 +239,7 @@ struct anchorVolDescPtr
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Volume Descriptor Pointer (ECMA 167r3 3/10.3) */ /* Volume Descriptor Pointer (ECMA 167r3 3/10.3) */
struct volDescPtr struct volDescPtr {
{
tag descTag; tag descTag;
__le32 volDescSeqNum; __le32 volDescSeqNum;
extent_ad nextVolDescSeqExt; extent_ad nextVolDescSeqExt;
...@@ -262,8 +247,7 @@ struct volDescPtr ...@@ -262,8 +247,7 @@ struct volDescPtr
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) */ /* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) */
struct impUseVolDesc struct impUseVolDesc {
{
tag descTag; tag descTag;
__le32 volDescSeqNum; __le32 volDescSeqNum;
regid impIdent; regid impIdent;
...@@ -271,8 +255,7 @@ struct impUseVolDesc ...@@ -271,8 +255,7 @@ struct impUseVolDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Partition Descriptor (ECMA 167r3 3/10.5) */ /* Partition Descriptor (ECMA 167r3 3/10.5) */
struct partitionDesc struct partitionDesc {
{
tag descTag; tag descTag;
__le32 volDescSeqNum; __le32 volDescSeqNum;
__le16 partitionFlags; __le16 partitionFlags;
...@@ -307,8 +290,7 @@ struct partitionDesc ...@@ -307,8 +290,7 @@ struct partitionDesc
#define PD_ACCESS_TYPE_OVERWRITABLE 0x00000004 #define PD_ACCESS_TYPE_OVERWRITABLE 0x00000004
/* Logical Volume Descriptor (ECMA 167r3 3/10.6) */ /* Logical Volume Descriptor (ECMA 167r3 3/10.6) */
struct logicalVolDesc struct logicalVolDesc {
{
tag descTag; tag descTag;
__le32 volDescSeqNum; __le32 volDescSeqNum;
charspec descCharSet; charspec descCharSet;
...@@ -325,8 +307,7 @@ struct logicalVolDesc ...@@ -325,8 +307,7 @@ struct logicalVolDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Generic Partition Map (ECMA 167r3 3/10.7.1) */ /* Generic Partition Map (ECMA 167r3 3/10.7.1) */
struct genericPartitionMap struct genericPartitionMap {
{
uint8_t partitionMapType; uint8_t partitionMapType;
uint8_t partitionMapLength; uint8_t partitionMapLength;
uint8_t partitionMapping[0]; uint8_t partitionMapping[0];
...@@ -338,8 +319,7 @@ struct genericPartitionMap ...@@ -338,8 +319,7 @@ struct genericPartitionMap
#define GP_PARTITION_MAP_TYPE_2 0x02 #define GP_PARTITION_MAP_TYPE_2 0x02
/* Type 1 Partition Map (ECMA 167r3 3/10.7.2) */ /* Type 1 Partition Map (ECMA 167r3 3/10.7.2) */
struct genericPartitionMap1 struct genericPartitionMap1 {
{
uint8_t partitionMapType; uint8_t partitionMapType;
uint8_t partitionMapLength; uint8_t partitionMapLength;
__le16 volSeqNum; __le16 volSeqNum;
...@@ -347,16 +327,14 @@ struct genericPartitionMap1 ...@@ -347,16 +327,14 @@ struct genericPartitionMap1
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Type 2 Partition Map (ECMA 167r3 3/10.7.3) */ /* Type 2 Partition Map (ECMA 167r3 3/10.7.3) */
struct genericPartitionMap2 struct genericPartitionMap2 {
{
uint8_t partitionMapType; uint8_t partitionMapType;
uint8_t partitionMapLength; uint8_t partitionMapLength;
uint8_t partitionIdent[62]; uint8_t partitionIdent[62];
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Unallocated Space Descriptor (ECMA 167r3 3/10.8) */ /* Unallocated Space Descriptor (ECMA 167r3 3/10.8) */
struct unallocSpaceDesc struct unallocSpaceDesc {
{
tag descTag; tag descTag;
__le32 volDescSeqNum; __le32 volDescSeqNum;
__le32 numAllocDescs; __le32 numAllocDescs;
...@@ -364,15 +342,13 @@ struct unallocSpaceDesc ...@@ -364,15 +342,13 @@ struct unallocSpaceDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Terminating Descriptor (ECMA 167r3 3/10.9) */ /* Terminating Descriptor (ECMA 167r3 3/10.9) */
struct terminatingDesc struct terminatingDesc {
{
tag descTag; tag descTag;
uint8_t reserved[496]; uint8_t reserved[496];
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) */ /* Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) */
struct logicalVolIntegrityDesc struct logicalVolIntegrityDesc {
{
tag descTag; tag descTag;
timestamp recordingDateAndTime; timestamp recordingDateAndTime;
__le32 integrityType; __le32 integrityType;
...@@ -390,52 +366,45 @@ struct logicalVolIntegrityDesc ...@@ -390,52 +366,45 @@ struct logicalVolIntegrityDesc
#define LVID_INTEGRITY_TYPE_CLOSE 0x00000001 #define LVID_INTEGRITY_TYPE_CLOSE 0x00000001
/* Recorded Address (ECMA 167r3 4/7.1) */ /* Recorded Address (ECMA 167r3 4/7.1) */
typedef struct typedef struct {
{
__le32 logicalBlockNum; __le32 logicalBlockNum;
__le16 partitionReferenceNum; __le16 partitionReferenceNum;
} __attribute__ ((packed)) lb_addr; } __attribute__ ((packed)) lb_addr;
/* ... and its in-core analog */ /* ... and its in-core analog */
typedef struct typedef struct {
{
uint32_t logicalBlockNum; uint32_t logicalBlockNum;
uint16_t partitionReferenceNum; uint16_t partitionReferenceNum;
} kernel_lb_addr; } kernel_lb_addr;
/* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */ /* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */
typedef struct typedef struct {
{
__le32 extLength; __le32 extLength;
__le32 extPosition; __le32 extPosition;
} __attribute__ ((packed)) short_ad; } __attribute__ ((packed)) short_ad;
/* Long Allocation Descriptor (ECMA 167r3 4/14.14.2) */ /* Long Allocation Descriptor (ECMA 167r3 4/14.14.2) */
typedef struct typedef struct {
{
__le32 extLength; __le32 extLength;
lb_addr extLocation; lb_addr extLocation;
uint8_t impUse[6]; uint8_t impUse[6];
} __attribute__ ((packed)) long_ad; } __attribute__ ((packed)) long_ad;
typedef struct typedef struct {
{
uint32_t extLength; uint32_t extLength;
kernel_lb_addr extLocation; kernel_lb_addr extLocation;
uint8_t impUse[6]; uint8_t impUse[6];
} kernel_long_ad; } kernel_long_ad;
/* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */ /* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */
typedef struct typedef struct {
{
__le32 extLength; __le32 extLength;
__le32 recordedLength; __le32 recordedLength;
__le32 informationLength; __le32 informationLength;
lb_addr extLocation; lb_addr extLocation;
} __attribute__ ((packed)) ext_ad; } __attribute__ ((packed)) ext_ad;
typedef struct typedef struct {
{
uint32_t extLength; uint32_t extLength;
uint32_t recordedLength; uint32_t recordedLength;
uint32_t informationLength; uint32_t informationLength;
...@@ -458,8 +427,7 @@ typedef struct ...@@ -458,8 +427,7 @@ typedef struct
#define TAG_IDENT_EFE 0x010A #define TAG_IDENT_EFE 0x010A
/* File Set Descriptor (ECMA 167r3 4/14.1) */ /* File Set Descriptor (ECMA 167r3 4/14.1) */
struct fileSetDesc struct fileSetDesc {
{
tag descTag; tag descTag;
timestamp recordingDateAndTime; timestamp recordingDateAndTime;
__le16 interchangeLvl; __le16 interchangeLvl;
...@@ -482,8 +450,7 @@ struct fileSetDesc ...@@ -482,8 +450,7 @@ struct fileSetDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Partition Header Descriptor (ECMA 167r3 4/14.3) */ /* Partition Header Descriptor (ECMA 167r3 4/14.3) */
struct partitionHeaderDesc struct partitionHeaderDesc {
{
short_ad unallocSpaceTable; short_ad unallocSpaceTable;
short_ad unallocSpaceBitmap; short_ad unallocSpaceBitmap;
short_ad partitionIntegrityTable; short_ad partitionIntegrityTable;
...@@ -493,8 +460,7 @@ struct partitionHeaderDesc ...@@ -493,8 +460,7 @@ struct partitionHeaderDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* File Identifier Descriptor (ECMA 167r3 4/14.4) */ /* File Identifier Descriptor (ECMA 167r3 4/14.4) */
struct fileIdentDesc struct fileIdentDesc {
{
tag descTag; tag descTag;
__le16 fileVersionNum; __le16 fileVersionNum;
uint8_t fileCharacteristics; uint8_t fileCharacteristics;
...@@ -514,16 +480,14 @@ struct fileIdentDesc ...@@ -514,16 +480,14 @@ struct fileIdentDesc
#define FID_FILE_CHAR_METADATA 0x10 #define FID_FILE_CHAR_METADATA 0x10
/* Allocation Ext Descriptor (ECMA 167r3 4/14.5) */ /* Allocation Ext Descriptor (ECMA 167r3 4/14.5) */
struct allocExtDesc struct allocExtDesc {
{
tag descTag; tag descTag;
__le32 previousAllocExtLocation; __le32 previousAllocExtLocation;
__le32 lengthAllocDescs; __le32 lengthAllocDescs;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* ICB Tag (ECMA 167r3 4/14.6) */ /* ICB Tag (ECMA 167r3 4/14.6) */
typedef struct typedef struct {
{
__le32 priorRecordedNumDirectEntries; __le32 priorRecordedNumDirectEntries;
__le16 strategyType; __le16 strategyType;
__le16 strategyParameter; __le16 strategyParameter;
...@@ -576,23 +540,20 @@ typedef struct ...@@ -576,23 +540,20 @@ typedef struct
#define ICBTAG_FLAG_STREAM 0x2000 #define ICBTAG_FLAG_STREAM 0x2000
/* Indirect Entry (ECMA 167r3 4/14.7) */ /* Indirect Entry (ECMA 167r3 4/14.7) */
struct indirectEntry struct indirectEntry {
{
tag descTag; tag descTag;
icbtag icbTag; icbtag icbTag;
long_ad indirectICB; long_ad indirectICB;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Terminal Entry (ECMA 167r3 4/14.8) */ /* Terminal Entry (ECMA 167r3 4/14.8) */
struct terminalEntry struct terminalEntry {
{
tag descTag; tag descTag;
icbtag icbTag; icbtag icbTag;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* File Entry (ECMA 167r3 4/14.9) */ /* File Entry (ECMA 167r3 4/14.9) */
struct fileEntry struct fileEntry {
{
tag descTag; tag descTag;
icbtag icbTag; icbtag icbTag;
__le32 uid; __le32 uid;
...@@ -655,16 +616,14 @@ struct fileEntry ...@@ -655,16 +616,14 @@ struct fileEntry
#define FE_RECORD_DISPLAY_ATTR_3 0x03 #define FE_RECORD_DISPLAY_ATTR_3 0x03
/* Extended Attribute Header Descriptor (ECMA 167r3 4/14.10.1) */ /* Extended Attribute Header Descriptor (ECMA 167r3 4/14.10.1) */
struct extendedAttrHeaderDesc struct extendedAttrHeaderDesc {
{
tag descTag; tag descTag;
__le32 impAttrLocation; __le32 impAttrLocation;
__le32 appAttrLocation; __le32 appAttrLocation;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Generic Format (ECMA 167r3 4/14.10.2) */ /* Generic Format (ECMA 167r3 4/14.10.2) */
struct genericFormat struct genericFormat {
{
__le32 attrType; __le32 attrType;
uint8_t attrSubtype; uint8_t attrSubtype;
uint8_t reserved[3]; uint8_t reserved[3];
...@@ -673,8 +632,7 @@ struct genericFormat ...@@ -673,8 +632,7 @@ struct genericFormat
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Character Set Information (ECMA 167r3 4/14.10.3) */ /* Character Set Information (ECMA 167r3 4/14.10.3) */
struct charSetInfo struct charSetInfo {
{
__le32 attrType; __le32 attrType;
uint8_t attrSubtype; uint8_t attrSubtype;
uint8_t reserved[3]; uint8_t reserved[3];
...@@ -685,8 +643,7 @@ struct charSetInfo ...@@ -685,8 +643,7 @@ struct charSetInfo
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Alternate Permissions (ECMA 167r3 4/14.10.4) */ /* Alternate Permissions (ECMA 167r3 4/14.10.4) */
struct altPerms struct altPerms {
{
__le32 attrType; __le32 attrType;
uint8_t attrSubtype; uint8_t attrSubtype;
uint8_t reserved[3]; uint8_t reserved[3];
...@@ -697,8 +654,7 @@ struct altPerms ...@@ -697,8 +654,7 @@ struct altPerms
} __attribute__ ((packed)); } __attribute__ ((packed));
/* File Times Extended Attribute (ECMA 167r3 4/14.10.5) */ /* File Times Extended Attribute (ECMA 167r3 4/14.10.5) */
struct fileTimesExtAttr struct fileTimesExtAttr {
{
__le32 attrType; __le32 attrType;
uint8_t attrSubtype; uint8_t attrSubtype;
uint8_t reserved[3]; uint8_t reserved[3];
...@@ -715,8 +671,7 @@ struct fileTimesExtAttr ...@@ -715,8 +671,7 @@ struct fileTimesExtAttr
#define FTE_BACKUP 0x00000002 #define FTE_BACKUP 0x00000002
/* Information Times Extended Attribute (ECMA 167r3 4/14.10.6) */ /* Information Times Extended Attribute (ECMA 167r3 4/14.10.6) */
struct infoTimesExtAttr struct infoTimesExtAttr {
{
__le32 attrType; __le32 attrType;
uint8_t attrSubtype; uint8_t attrSubtype;
uint8_t reserved[3]; uint8_t reserved[3];
...@@ -727,8 +682,7 @@ struct infoTimesExtAttr ...@@ -727,8 +682,7 @@ struct infoTimesExtAttr
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Device Specification (ECMA 167r3 4/14.10.7) */ /* Device Specification (ECMA 167r3 4/14.10.7) */
struct deviceSpec struct deviceSpec {
{
__le32 attrType; __le32 attrType;
uint8_t attrSubtype; uint8_t attrSubtype;
uint8_t reserved[3]; uint8_t reserved[3];
...@@ -740,8 +694,7 @@ struct deviceSpec ...@@ -740,8 +694,7 @@ struct deviceSpec
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Implementation Use Extended Attr (ECMA 167r3 4/14.10.8) */ /* Implementation Use Extended Attr (ECMA 167r3 4/14.10.8) */
struct impUseExtAttr struct impUseExtAttr {
{
__le32 attrType; __le32 attrType;
uint8_t attrSubtype; uint8_t attrSubtype;
uint8_t reserved[3]; uint8_t reserved[3];
...@@ -752,8 +705,7 @@ struct impUseExtAttr ...@@ -752,8 +705,7 @@ struct impUseExtAttr
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Application Use Extended Attribute (ECMA 167r3 4/14.10.9) */ /* Application Use Extended Attribute (ECMA 167r3 4/14.10.9) */
struct appUseExtAttr struct appUseExtAttr {
{
__le32 attrType; __le32 attrType;
uint8_t attrSubtype; uint8_t attrSubtype;
uint8_t reserved[3]; uint8_t reserved[3];
...@@ -771,10 +723,8 @@ struct appUseExtAttr ...@@ -771,10 +723,8 @@ struct appUseExtAttr
#define EXTATTR_IMP_USE 2048 #define EXTATTR_IMP_USE 2048
#define EXTATTR_APP_USE 65536 #define EXTATTR_APP_USE 65536
/* Unallocated Space Entry (ECMA 167r3 4/14.11) */ /* Unallocated Space Entry (ECMA 167r3 4/14.11) */
struct unallocSpaceEntry struct unallocSpaceEntry {
{
tag descTag; tag descTag;
icbtag icbTag; icbtag icbTag;
__le32 lengthAllocDescs; __le32 lengthAllocDescs;
...@@ -782,8 +732,7 @@ struct unallocSpaceEntry ...@@ -782,8 +732,7 @@ struct unallocSpaceEntry
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Space Bitmap Descriptor (ECMA 167r3 4/14.12) */ /* Space Bitmap Descriptor (ECMA 167r3 4/14.12) */
struct spaceBitmapDesc struct spaceBitmapDesc {
{
tag descTag; tag descTag;
__le32 numOfBits; __le32 numOfBits;
__le32 numOfBytes; __le32 numOfBytes;
...@@ -791,8 +740,7 @@ struct spaceBitmapDesc ...@@ -791,8 +740,7 @@ struct spaceBitmapDesc
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Partition Integrity Entry (ECMA 167r3 4/14.13) */ /* Partition Integrity Entry (ECMA 167r3 4/14.13) */
struct partitionIntegrityEntry struct partitionIntegrityEntry {
{
tag descTag; tag descTag;
icbtag icbTag; icbtag icbTag;
timestamp recordingDateAndTime; timestamp recordingDateAndTime;
...@@ -815,15 +763,13 @@ struct partitionIntegrityEntry ...@@ -815,15 +763,13 @@ struct partitionIntegrityEntry
/* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */ /* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */
/* Logical Volume Header Descriptor (ECMA 167r3 4/14.15) */ /* Logical Volume Header Descriptor (ECMA 167r3 4/14.15) */
struct logicalVolHeaderDesc struct logicalVolHeaderDesc {
{
__le64 uniqueID; __le64 uniqueID;
uint8_t reserved[24]; uint8_t reserved[24];
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Path Component (ECMA 167r3 4/14.16.1) */ /* Path Component (ECMA 167r3 4/14.16.1) */
struct pathComponent struct pathComponent {
{
uint8_t componentType; uint8_t componentType;
uint8_t lengthComponentIdent; uint8_t lengthComponentIdent;
__le16 componentFileVersionNum; __le16 componentFileVersionNum;
...@@ -831,8 +777,7 @@ struct pathComponent ...@@ -831,8 +777,7 @@ struct pathComponent
} __attribute__ ((packed)); } __attribute__ ((packed));
/* File Entry (ECMA 167r3 4/14.17) */ /* File Entry (ECMA 167r3 4/14.17) */
struct extendedFileEntry struct extendedFileEntry {
{
tag descTag; tag descTag;
icbtag icbTag; icbtag icbTag;
__le32 uid; __le32 uid;
......
fs/udf/file.c
View file @ cb00ea35
...@@ -41,7 +41,7 @@ ...@@ -41,7 +41,7 @@
#include "udf_i.h" #include "udf_i.h"
#include "udf_sb.h" #include "udf_sb.h"
static int udf_adinicb_readpage(struct file *file, struct page * page) static int udf_adinicb_readpage(struct file *file, struct page *page)
{ {
struct inode *inode = page->mapping->host; struct inode *inode = page->mapping->host;
char *kaddr; char *kaddr;
...@@ -58,7 +58,8 @@ static int udf_adinicb_readpage(struct file *file, struct page * page) ...@@ -58,7 +58,8 @@ static int udf_adinicb_readpage(struct file *file, struct page * page)
return 0; 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; struct inode *inode = page->mapping->host;
char *kaddr; char *kaddr;
...@@ -74,13 +75,15 @@ static int udf_adinicb_writepage(struct page *page, struct writeback_control *wb ...@@ -74,13 +75,15 @@ static int udf_adinicb_writepage(struct page *page, struct writeback_control *wb
return 0; return 0;
} }
static int udf_adinicb_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to) static int udf_adinicb_prepare_write(struct file *file, struct page *page,
unsigned offset, unsigned to)
{ {
kmap(page); kmap(page);
return 0; return 0;
} }
static int udf_adinicb_commit_write(struct file *file, struct page *page, unsigned offset, unsigned to) static int udf_adinicb_commit_write(struct file *file, struct page *page,
unsigned offset, unsigned to)
{ {
struct inode *inode = page->mapping->host; struct inode *inode = page->mapping->host;
char *kaddr = page_address(page); char *kaddr = page_address(page);
...@@ -113,25 +116,20 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov, ...@@ -113,25 +116,20 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
int err, pos; int err, pos;
size_t count = iocb->ki_left; size_t count = iocb->ki_left;
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
{
if (file->f_flags & O_APPEND) if (file->f_flags & O_APPEND)
pos = inode->i_size; pos = inode->i_size;
else else
pos = ppos; pos = ppos;
if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) + if (inode->i_sb->s_blocksize <
pos + count)) (udf_file_entry_alloc_offset(inode) + pos + count)) {
{
udf_expand_file_adinicb(inode, pos + count, &err); udf_expand_file_adinicb(inode, pos + count, &err);
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
{
udf_debug("udf_expand_adinicb: err=%d\n", err); udf_debug("udf_expand_adinicb: err=%d\n", err);
return err; return err;
} }
} } else {
else
{
if (pos + count > inode->i_size) if (pos + count > inode->i_size)
UDF_I_LENALLOC(inode) = pos + count; UDF_I_LENALLOC(inode) = pos + count;
else else
...@@ -185,30 +183,29 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, ...@@ -185,30 +183,29 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
{ {
int result = -EINVAL; int result = -EINVAL;
if ( file_permission(filp, MAY_READ) != 0 ) 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; return -EPERM;
} }
if ( !arg ) if (!arg) {
{
udf_debug("invalid argument to udf_ioctl\n"); udf_debug("invalid argument to udf_ioctl\n");
return -EINVAL; return -EINVAL;
} }
switch (cmd) switch (cmd) {
{
case UDF_GETVOLIDENT: case UDF_GETVOLIDENT:
return copy_to_user((char __user *)arg, 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: case UDF_RELOCATE_BLOCKS:
{ {
long old, new; long old, new;
if (!capable(CAP_SYS_ADMIN)) return -EACCES; if (!capable(CAP_SYS_ADMIN))
if (get_user(old, (long __user *)arg)) return -EFAULT; return -EACCES;
if (get_user(old, (long __user *)arg))
return -EFAULT;
if ((result = udf_relocate_blocks(inode->i_sb, if ((result = udf_relocate_blocks(inode->i_sb,
old, &new)) == 0) old, &new)) == 0)
result = put_user(new, (long __user *)arg); result = put_user(new, (long __user *)arg);
...@@ -240,10 +237,9 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, ...@@ -240,10 +237,9 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
* HISTORY * HISTORY
* *
*/ */
static int udf_release_file(struct inode * inode, struct file * filp) static int udf_release_file(struct inode *inode, struct file *filp)
{ {
if (filp->f_mode & FMODE_WRITE) if (filp->f_mode & FMODE_WRITE) {
{
lock_kernel(); lock_kernel();
udf_discard_prealloc(inode); udf_discard_prealloc(inode);
unlock_kernel(); unlock_kernel();
......
fs/udf/fsync.c
View file @ cb00ea35
...@@ -29,7 +29,7 @@ static int udf_fsync_inode(struct inode *, int); ...@@ -29,7 +29,7 @@ static int udf_fsync_inode(struct inode *, int);
* even pass file to fsync ? * even pass file to fsync ?
*/ */
int udf_fsync_file(struct file * file, struct dentry *dentry, int datasync) int udf_fsync_file(struct file *file, struct dentry *dentry, int datasync)
{ {
struct inode *inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
return udf_fsync_inode(inode, datasync); return udf_fsync_inode(inode, datasync);
...@@ -45,6 +45,6 @@ static int udf_fsync_inode(struct inode *inode, int datasync) ...@@ -45,6 +45,6 @@ static int udf_fsync_inode(struct inode *inode, int datasync)
if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
return err; return err;
err |= udf_sync_inode (inode); err |= udf_sync_inode(inode);
return err ? -EIO : 0; return err ? -EIO : 0;
} }
fs/udf/ialloc.c
View file @ cb00ea35
...@@ -28,7 +28,7 @@ ...@@ -28,7 +28,7 @@
#include "udf_i.h" #include "udf_i.h"
#include "udf_sb.h" #include "udf_sb.h"
void udf_free_inode(struct inode * inode) void udf_free_inode(struct inode *inode)
{ {
struct super_block *sb = inode->i_sb; struct super_block *sb = inode->i_sb;
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
...@@ -46,10 +46,12 @@ void udf_free_inode(struct inode * inode) ...@@ -46,10 +46,12 @@ void udf_free_inode(struct inode * inode)
if (sbi->s_lvidbh) { if (sbi->s_lvidbh) {
if (S_ISDIR(inode->i_mode)) if (S_ISDIR(inode->i_mode))
UDF_SB_LVIDIU(sb)->numDirs = 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 else
UDF_SB_LVIDIU(sb)->numFiles = 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); mark_buffer_dirty(sbi->s_lvidbh);
} }
...@@ -58,18 +60,17 @@ void udf_free_inode(struct inode * inode) ...@@ -58,18 +60,17 @@ void udf_free_inode(struct inode * inode)
udf_free_blocks(sb, NULL, UDF_I_LOCATION(inode), 0, 1); udf_free_blocks(sb, NULL, UDF_I_LOCATION(inode), 0, 1);
} }
struct inode * udf_new_inode (struct inode *dir, int mode, int * err) struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
{ {
struct super_block *sb = dir->i_sb; struct super_block *sb = dir->i_sb;
struct udf_sb_info *sbi = UDF_SB(sb); struct udf_sb_info *sbi = UDF_SB(sb);
struct inode * inode; struct inode *inode;
int block; int block;
uint32_t start = UDF_I_LOCATION(dir).logicalBlockNum; uint32_t start = UDF_I_LOCATION(dir).logicalBlockNum;
inode = new_inode(sb); inode = new_inode(sb);
if (!inode) if (!inode) {
{
*err = -ENOMEM; *err = -ENOMEM;
return NULL; return NULL;
} }
...@@ -81,26 +82,30 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err) ...@@ -81,26 +82,30 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err)
UDF_I_NEXT_ALLOC_GOAL(inode) = 0; UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
UDF_I_STRAT4096(inode) = 0; UDF_I_STRAT4096(inode) = 0;
block = udf_new_block(dir->i_sb, NULL, UDF_I_LOCATION(dir).partitionReferenceNum, block =
start, err); udf_new_block(dir->i_sb, NULL,
if (*err) UDF_I_LOCATION(dir).partitionReferenceNum, start,
{ err);
if (*err) {
iput(inode); iput(inode);
return NULL; return NULL;
} }
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb)) {
{
struct logicalVolHeaderDesc *lvhd; struct logicalVolHeaderDesc *lvhd;
uint64_t uniqueID; uint64_t uniqueID;
lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->logicalVolContentsUse); lvhd =
(struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->
logicalVolContentsUse);
if (S_ISDIR(mode)) if (S_ISDIR(mode))
UDF_SB_LVIDIU(sb)->numDirs = 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 else
UDF_SB_LVIDIU(sb)->numFiles = 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); UDF_I_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);
if (!(++uniqueID & 0x00000000FFFFFFFFUL)) if (!(++uniqueID & 0x00000000FFFFFFFFUL))
uniqueID += 16; uniqueID += 16;
...@@ -109,35 +114,34 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err) ...@@ -109,35 +114,34 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err)
} }
inode->i_mode = mode; inode->i_mode = mode;
inode->i_uid = current->fsuid; inode->i_uid = current->fsuid;
if (dir->i_mode & S_ISGID) if (dir->i_mode & S_ISGID) {
{
inode->i_gid = dir->i_gid; inode->i_gid = dir->i_gid;
if (S_ISDIR(mode)) if (S_ISDIR(mode))
mode |= S_ISGID; mode |= S_ISGID;
} } else
else
inode->i_gid = current->fsgid; inode->i_gid = current->fsgid;
UDF_I_LOCATION(inode).logicalBlockNum = block; 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_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);
inode->i_blocks = 0; inode->i_blocks = 0;
UDF_I_LENEATTR(inode) = 0; UDF_I_LENEATTR(inode) = 0;
UDF_I_LENALLOC(inode) = 0; UDF_I_LENALLOC(inode) = 0;
UDF_I_USE(inode) = 0; UDF_I_USE(inode) = 0;
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
{
UDF_I_EFE(inode) = 1; UDF_I_EFE(inode) = 1;
UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE); 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 -
else sizeof(struct extendedFileEntry), GFP_KERNEL);
{ } else {
UDF_I_EFE(inode) = 0; 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)) if (!UDF_I_DATA(inode)) {
{
iput(inode); iput(inode);
*err = -ENOMEM; *err = -ENOMEM;
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
...@@ -155,8 +159,7 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err) ...@@ -155,8 +159,7 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err)
mark_inode_dirty(inode); mark_inode_dirty(inode);
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
if (DQUOT_ALLOC_INODE(inode)) if (DQUOT_ALLOC_INODE(inode)) {
{
DQUOT_DROP(inode); DQUOT_DROP(inode);
inode->i_flags |= S_NOQUOTA; inode->i_flags |= S_NOQUOTA;
inode->i_nlink = 0; inode->i_nlink = 0;
......
fs/udf/inode.c
View file @ cb00ea35
...@@ -55,13 +55,13 @@ static struct buffer_head *inode_getblk(struct inode *, sector_t, int *, ...@@ -55,13 +55,13 @@ static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
static int8_t udf_insert_aext(struct inode *, struct extent_position, static int8_t udf_insert_aext(struct inode *, struct extent_position,
kernel_lb_addr, uint32_t); kernel_lb_addr, uint32_t);
static void udf_split_extents(struct inode *, int *, int, int, static void udf_split_extents(struct inode *, int *, int, int,
kernel_long_ad [EXTENT_MERGE_SIZE], int *); kernel_long_ad[EXTENT_MERGE_SIZE], int *);
static void udf_prealloc_extents(struct inode *, int, int, static void udf_prealloc_extents(struct inode *, int, int,
kernel_long_ad [EXTENT_MERGE_SIZE], int *); kernel_long_ad[EXTENT_MERGE_SIZE], int *);
static void udf_merge_extents(struct inode *, static void udf_merge_extents(struct inode *,
kernel_long_ad [EXTENT_MERGE_SIZE], int *); kernel_long_ad[EXTENT_MERGE_SIZE], int *);
static void udf_update_extents(struct inode *, static void udf_update_extents(struct inode *,
kernel_long_ad [EXTENT_MERGE_SIZE], int, int, kernel_long_ad[EXTENT_MERGE_SIZE], int, int,
struct extent_position *); struct extent_position *);
static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int); static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
...@@ -81,7 +81,7 @@ static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int); ...@@ -81,7 +81,7 @@ static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
* *
* Called at the last iput() if i_nlink is zero. * Called at the last iput() if i_nlink is zero.
*/ */
void udf_delete_inode(struct inode * inode) void udf_delete_inode(struct inode *inode)
{ {
truncate_inode_pages(&inode->i_data, 0); truncate_inode_pages(&inode->i_data, 0);
...@@ -97,7 +97,7 @@ void udf_delete_inode(struct inode * inode) ...@@ -97,7 +97,7 @@ void udf_delete_inode(struct inode * inode)
unlock_kernel(); unlock_kernel();
return; return;
no_delete: no_delete:
clear_inode(inode); clear_inode(inode);
} }
...@@ -132,14 +132,15 @@ static int udf_readpage(struct file *file, struct page *page) ...@@ -132,14 +132,15 @@ static int udf_readpage(struct file *file, struct page *page)
return block_read_full_page(page, udf_get_block); return block_read_full_page(page, udf_get_block);
} }
static int udf_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to) static int udf_prepare_write(struct file *file, struct page *page,
unsigned from, unsigned to)
{ {
return block_prepare_write(page, from, to, udf_get_block); return block_prepare_write(page, from, to, udf_get_block);
} }
static sector_t udf_bmap(struct address_space *mapping, sector_t block) static sector_t udf_bmap(struct address_space *mapping, sector_t block)
{ {
return generic_block_bmap(mapping,block,udf_get_block); return generic_block_bmap(mapping, block, udf_get_block);
} }
const struct address_space_operations udf_aops = { const struct address_space_operations udf_aops = {
...@@ -151,7 +152,7 @@ const struct address_space_operations udf_aops = { ...@@ -151,7 +152,7 @@ const struct address_space_operations udf_aops = {
.bmap = udf_bmap, .bmap = udf_bmap,
}; };
void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err) void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
{ {
struct page *page; struct page *page;
char *kaddr; char *kaddr;
...@@ -163,8 +164,7 @@ void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err) ...@@ -163,8 +164,7 @@ void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err)
/* from now on we have normal address_space methods */ /* from now on we have normal address_space methods */
inode->i_data.a_ops = &udf_aops; inode->i_data.a_ops = &udf_aops;
if (!UDF_I_LENALLOC(inode)) if (!UDF_I_LENALLOC(inode)) {
{
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT; UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
else else
...@@ -176,8 +176,7 @@ void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err) ...@@ -176,8 +176,7 @@ void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err)
page = grab_cache_page(inode->i_mapping, 0); page = grab_cache_page(inode->i_mapping, 0);
BUG_ON(!PageLocked(page)); BUG_ON(!PageLocked(page));
if (!PageUptodate(page)) if (!PageUptodate(page)) {
{
kaddr = kmap(page); kaddr = kmap(page);
memset(kaddr + UDF_I_LENALLOC(inode), 0x00, memset(kaddr + UDF_I_LENALLOC(inode), 0x00,
PAGE_CACHE_SIZE - UDF_I_LENALLOC(inode)); PAGE_CACHE_SIZE - UDF_I_LENALLOC(inode));
...@@ -201,7 +200,8 @@ void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err) ...@@ -201,7 +200,8 @@ void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err)
mark_inode_dirty(inode); mark_inode_dirty(inode);
} }
struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int *err) struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
int *err)
{ {
int newblock; int newblock;
struct buffer_head *dbh = NULL; struct buffer_head *dbh = NULL;
...@@ -220,8 +220,7 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int ...@@ -220,8 +220,7 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
else else
alloctype = ICBTAG_FLAG_AD_LONG; alloctype = ICBTAG_FLAG_AD_LONG;
if (!inode->i_size) if (!inode->i_size) {
{
UDF_I_ALLOCTYPE(inode) = alloctype; UDF_I_ALLOCTYPE(inode) = alloctype;
mark_inode_dirty(inode); mark_inode_dirty(inode);
return NULL; return NULL;
...@@ -235,7 +234,8 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int ...@@ -235,7 +234,8 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
if (!(*block)) if (!(*block))
return NULL; return NULL;
newblock = udf_get_pblock(inode->i_sb, *block, newblock = udf_get_pblock(inode->i_sb, *block,
UDF_I_LOCATION(inode).partitionReferenceNum, 0); UDF_I_LOCATION(inode).partitionReferenceNum,
0);
if (!newblock) if (!newblock)
return NULL; return NULL;
dbh = udf_tgetblk(inode->i_sb, newblock); dbh = udf_tgetblk(inode->i_sb, newblock);
...@@ -247,16 +247,17 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int ...@@ -247,16 +247,17 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
unlock_buffer(dbh); unlock_buffer(dbh);
mark_buffer_dirty_inode(dbh, inode); mark_buffer_dirty_inode(dbh, inode);
sfibh.soffset = sfibh.eoffset = (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2; sfibh.soffset = sfibh.eoffset =
(f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
sfibh.sbh = sfibh.ebh = NULL; sfibh.sbh = sfibh.ebh = NULL;
dfibh.soffset = dfibh.eoffset = 0; dfibh.soffset = dfibh.eoffset = 0;
dfibh.sbh = dfibh.ebh = dbh; dfibh.sbh = dfibh.ebh = dbh;
while ( (f_pos < size) ) while ((f_pos < size)) {
{
UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB; UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL, NULL, NULL); sfi =
if (!sfi) udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL,
{ NULL, NULL);
if (!sfi) {
brelse(dbh); brelse(dbh);
return NULL; return NULL;
} }
...@@ -266,8 +267,8 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int ...@@ -266,8 +267,8 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
dfibh.eoffset += (sfibh.eoffset - sfibh.soffset); dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset); dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse, if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
sfi->fileIdent + le16_to_cpu(sfi->lengthOfImpUse))) sfi->fileIdent +
{ le16_to_cpu(sfi->lengthOfImpUse))) {
UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB; UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
brelse(dbh); brelse(dbh);
return NULL; return NULL;
...@@ -275,10 +276,12 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int ...@@ -275,10 +276,12 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
} }
mark_buffer_dirty_inode(dbh, inode); mark_buffer_dirty_inode(dbh, inode);
memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0, UDF_I_LENALLOC(inode)); memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0,
UDF_I_LENALLOC(inode));
UDF_I_LENALLOC(inode) = 0; UDF_I_LENALLOC(inode) = 0;
eloc.logicalBlockNum = *block; eloc.logicalBlockNum = *block;
eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum; eloc.partitionReferenceNum =
UDF_I_LOCATION(inode).partitionReferenceNum;
elen = inode->i_size; elen = inode->i_size;
UDF_I_LENEXTENTS(inode) = elen; UDF_I_LENEXTENTS(inode) = elen;
epos.bh = NULL; epos.bh = NULL;
...@@ -292,14 +295,14 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int ...@@ -292,14 +295,14 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
return dbh; return dbh;
} }
static int udf_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_result, int create) static int udf_get_block(struct inode *inode, sector_t block,
struct buffer_head *bh_result, int create)
{ {
int err, new; int err, new;
struct buffer_head *bh; struct buffer_head *bh;
unsigned long phys; unsigned long phys;
if (!create) if (!create) {
{
phys = udf_block_map(inode, block); phys = udf_block_map(inode, block);
if (phys) if (phys)
map_bh(bh_result, inode->i_sb, phys); map_bh(bh_result, inode->i_sb, phys);
...@@ -315,10 +318,9 @@ static int udf_get_block(struct inode *inode, sector_t block, struct buffer_head ...@@ -315,10 +318,9 @@ static int udf_get_block(struct inode *inode, sector_t block, struct buffer_head
if (block < 0) if (block < 0)
goto abort_negative; goto abort_negative;
if (block == UDF_I_NEXT_ALLOC_BLOCK(inode) + 1) if (block == UDF_I_NEXT_ALLOC_BLOCK(inode) + 1) {
{ UDF_I_NEXT_ALLOC_BLOCK(inode)++;
UDF_I_NEXT_ALLOC_BLOCK(inode) ++; UDF_I_NEXT_ALLOC_GOAL(inode)++;
UDF_I_NEXT_ALLOC_GOAL(inode) ++;
} }
err = 0; err = 0;
...@@ -332,29 +334,27 @@ static int udf_get_block(struct inode *inode, sector_t block, struct buffer_head ...@@ -332,29 +334,27 @@ static int udf_get_block(struct inode *inode, sector_t block, struct buffer_head
if (new) if (new)
set_buffer_new(bh_result); set_buffer_new(bh_result);
map_bh(bh_result, inode->i_sb, phys); map_bh(bh_result, inode->i_sb, phys);
abort: abort:
unlock_kernel(); unlock_kernel();
return err; return err;
abort_negative: abort_negative:
udf_warning(inode->i_sb, "udf_get_block", "block < 0"); udf_warning(inode->i_sb, "udf_get_block", "block < 0");
goto abort; goto abort;
} }
static struct buffer_head * static struct buffer_head *udf_getblk(struct inode *inode, long block,
udf_getblk(struct inode *inode, long block, int create, int *err) int create, int *err)
{ {
struct buffer_head dummy; struct buffer_head dummy;
dummy.b_state = 0; dummy.b_state = 0;
dummy.b_blocknr = -1000; dummy.b_blocknr = -1000;
*err = udf_get_block(inode, block, &dummy, create); *err = udf_get_block(inode, block, &dummy, create);
if (!*err && buffer_mapped(&dummy)) if (!*err && buffer_mapped(&dummy)) {
{
struct buffer_head *bh; struct buffer_head *bh;
bh = sb_getblk(inode->i_sb, dummy.b_blocknr); bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
if (buffer_new(&dummy)) if (buffer_new(&dummy)) {
{
lock_buffer(bh); lock_buffer(bh);
memset(bh->b_data, 0x00, inode->i_sb->s_blocksize); memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
set_buffer_uptodate(bh); set_buffer_uptodate(bh);
...@@ -368,12 +368,12 @@ udf_getblk(struct inode *inode, long block, int create, int *err) ...@@ -368,12 +368,12 @@ udf_getblk(struct inode *inode, long block, int create, int *err)
/* Extend the file by 'blocks' blocks, return the number of extents added */ /* Extend the file by 'blocks' blocks, return the number of extents added */
int udf_extend_file(struct inode *inode, struct extent_position *last_pos, int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
kernel_long_ad *last_ext, sector_t blocks) kernel_long_ad * last_ext, sector_t blocks)
{ {
sector_t add; sector_t add;
int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK); int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
struct super_block *sb = inode->i_sb; struct super_block *sb = inode->i_sb;
kernel_lb_addr prealloc_loc = {0, 0}; kernel_lb_addr prealloc_loc = { 0, 0 };
int prealloc_len = 0; int prealloc_len = 0;
/* The previous extent is fake and we should not extend by anything /* The previous extent is fake and we should not extend by anything
...@@ -391,7 +391,8 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, ...@@ -391,7 +391,8 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
~(sb->s_blocksize - 1); ~(sb->s_blocksize - 1);
} }
/* Last extent are just preallocated blocks? */ /* Last extent are just preallocated blocks? */
if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_ALLOCATED) { if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
EXT_NOT_RECORDED_ALLOCATED) {
/* Save the extent so that we can reattach it to the end */ /* Save the extent so that we can reattach it to the end */
prealloc_loc = last_ext->extLocation; prealloc_loc = last_ext->extLocation;
prealloc_len = last_ext->extLength; prealloc_len = last_ext->extLength;
...@@ -402,9 +403,12 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, ...@@ -402,9 +403,12 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
last_ext->extLocation.partitionReferenceNum = 0; last_ext->extLocation.partitionReferenceNum = 0;
} }
/* Can we merge with the previous extent? */ /* Can we merge with the previous extent? */
if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_NOT_ALLOCATED) { if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
add = ((1<<30) - sb->s_blocksize - (last_ext->extLength & EXT_NOT_RECORDED_NOT_ALLOCATED) {
UDF_EXTENT_LENGTH_MASK)) >> sb->s_blocksize_bits; add =
((1 << 30) - sb->s_blocksize -
(last_ext->extLength & UDF_EXTENT_LENGTH_MASK)) >> sb->
s_blocksize_bits;
if (add > blocks) if (add > blocks)
add = blocks; add = blocks;
blocks -= add; blocks -= add;
...@@ -415,9 +419,9 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, ...@@ -415,9 +419,9 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
udf_add_aext(inode, last_pos, last_ext->extLocation, udf_add_aext(inode, last_pos, last_ext->extLocation,
last_ext->extLength, 1); last_ext->extLength, 1);
count++; count++;
} } else
else udf_write_aext(inode, last_pos, last_ext->extLocation,
udf_write_aext(inode, last_pos, last_ext->extLocation, last_ext->extLength, 1); last_ext->extLength, 1);
/* Managed to do everything necessary? */ /* Managed to do everything necessary? */
if (!blocks) if (!blocks)
goto out; goto out;
...@@ -425,8 +429,9 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, ...@@ -425,8 +429,9 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
/* All further extents will be NOT_RECORDED_NOT_ALLOCATED */ /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
last_ext->extLocation.logicalBlockNum = 0; last_ext->extLocation.logicalBlockNum = 0;
last_ext->extLocation.partitionReferenceNum = 0; last_ext->extLocation.partitionReferenceNum = 0;
add = (1 << (30-sb->s_blocksize_bits)) - 1; add = (1 << (30 - sb->s_blocksize_bits)) - 1;
last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | (add << sb->s_blocksize_bits); last_ext->extLength =
EXT_NOT_RECORDED_NOT_ALLOCATED | (add << sb->s_blocksize_bits);
/* Create enough extents to cover the whole hole */ /* Create enough extents to cover the whole hole */
while (blocks > add) { while (blocks > add) {
blocks -= add; blocks -= add;
...@@ -443,10 +448,11 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, ...@@ -443,10 +448,11 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
return -1; return -1;
count++; count++;
} }
out: out:
/* Do we have some preallocated blocks saved? */ /* Do we have some preallocated blocks saved? */
if (prealloc_len) { if (prealloc_len) {
if (udf_add_aext(inode, last_pos, prealloc_loc, prealloc_len, 1) == -1) if (udf_add_aext(inode, last_pos, prealloc_loc, prealloc_len, 1)
== -1)
return -1; return -1;
last_ext->extLocation = prealloc_loc; last_ext->extLocation = prealloc_loc;
last_ext->extLength = prealloc_len; last_ext->extLength = prealloc_len;
...@@ -462,7 +468,7 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos, ...@@ -462,7 +468,7 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
return count; return count;
} }
static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
int *err, long *phys, int *new) int *err, long *phys, int *new)
{ {
static sector_t last_block; static sector_t last_block;
...@@ -484,21 +490,18 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -484,21 +490,18 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
prev_epos.block = UDF_I_LOCATION(inode); prev_epos.block = UDF_I_LOCATION(inode);
prev_epos.bh = NULL; prev_epos.bh = NULL;
cur_epos = next_epos = prev_epos; cur_epos = next_epos = prev_epos;
b_off = (loff_t)block << inode->i_sb->s_blocksize_bits; b_off = (loff_t) block << inode->i_sb->s_blocksize_bits;
/* find the extent which contains the block we are looking for. /* find the extent which contains the block we are looking for.
alternate between laarr[0] and laarr[1] for locations of the alternate between laarr[0] and laarr[1] for locations of the
current extent, and the previous extent */ current extent, and the previous extent */
do do {
{ if (prev_epos.bh != cur_epos.bh) {
if (prev_epos.bh != cur_epos.bh)
{
brelse(prev_epos.bh); brelse(prev_epos.bh);
get_bh(cur_epos.bh); get_bh(cur_epos.bh);
prev_epos.bh = cur_epos.bh; prev_epos.bh = cur_epos.bh;
} }
if (cur_epos.bh != next_epos.bh) if (cur_epos.bh != next_epos.bh) {
{
brelse(cur_epos.bh); brelse(cur_epos.bh);
get_bh(next_epos.bh); get_bh(next_epos.bh);
cur_epos.bh = next_epos.bh; cur_epos.bh = next_epos.bh;
...@@ -512,7 +515,8 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -512,7 +515,8 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
prev_epos.offset = cur_epos.offset; prev_epos.offset = cur_epos.offset;
cur_epos.offset = next_epos.offset; cur_epos.offset = next_epos.offset;
if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1) if ((etype =
udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1)
break; break;
c = !c; c = !c;
...@@ -525,7 +529,7 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -525,7 +529,7 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
((elen + inode->i_sb->s_blocksize - 1) >> ((elen + inode->i_sb->s_blocksize - 1) >>
inode->i_sb->s_blocksize_bits); inode->i_sb->s_blocksize_bits);
count ++; count++;
} while (lbcount + elen <= b_off); } while (lbcount + elen <= b_off);
b_off -= lbcount; b_off -= lbcount;
...@@ -540,10 +544,8 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -540,10 +544,8 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
/* if the extent is allocated and recorded, return the block /* if the extent is allocated and recorded, return the block
if the extent is not a multiple of the blocksize, round up */ if the extent is not a multiple of the blocksize, round up */
if (etype == (EXT_RECORDED_ALLOCATED >> 30)) if (etype == (EXT_RECORDED_ALLOCATED >> 30)) {
{ if (elen & (inode->i_sb->s_blocksize - 1)) {
if (elen & (inode->i_sb->s_blocksize - 1))
{
elen = EXT_RECORDED_ALLOCATED | elen = EXT_RECORDED_ALLOCATED |
((elen + inode->i_sb->s_blocksize - 1) & ((elen + inode->i_sb->s_blocksize - 1) &
~(inode->i_sb->s_blocksize - 1)); ~(inode->i_sb->s_blocksize - 1));
...@@ -559,18 +561,17 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -559,18 +561,17 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
last_block = block; last_block = block;
/* Are we beyond EOF? */ /* Are we beyond EOF? */
if (etype == -1) if (etype == -1) {
{
int ret; int ret;
if (count) { if (count) {
if (c) if (c)
laarr[0] = laarr[1]; laarr[0] = laarr[1];
startnum = 1; startnum = 1;
} } else {
else {
/* Create a fake extent when there's not one */ /* Create a fake extent when there's not one */
memset(&laarr[0].extLocation, 0x00, sizeof(kernel_lb_addr)); memset(&laarr[0].extLocation, 0x00,
sizeof(kernel_lb_addr));
laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED; laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
/* Will udf_extend_file() create real extent from a fake one? */ /* Will udf_extend_file() create real extent from a fake one? */
startnum = (offset > 0); startnum = (offset > 0);
...@@ -590,26 +591,26 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -590,26 +591,26 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
offset = 0; offset = 0;
count += ret; count += ret;
/* We are not covered by a preallocated extent? */ /* We are not covered by a preallocated extent? */
if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) != EXT_NOT_RECORDED_ALLOCATED) { if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) !=
EXT_NOT_RECORDED_ALLOCATED) {
/* Is there any real extent? - otherwise we overwrite /* Is there any real extent? - otherwise we overwrite
* the fake one... */ * the fake one... */
if (count) if (count)
c = !c; c = !c;
laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
inode->i_sb->s_blocksize; inode->i_sb->s_blocksize;
memset(&laarr[c].extLocation, 0x00, sizeof(kernel_lb_addr)); memset(&laarr[c].extLocation, 0x00,
count ++; sizeof(kernel_lb_addr));
endnum ++; count++;
endnum++;
} }
endnum = c+1; endnum = c + 1;
lastblock = 1; lastblock = 1;
} } else {
else {
endnum = startnum = ((count > 2) ? 2 : count); endnum = startnum = ((count > 2) ? 2 : count);
/* if the current extent is in position 0, swap it with the previous */ /* if the current extent is in position 0, swap it with the previous */
if (!c && count != 1) if (!c && count != 1) {
{
laarr[2] = laarr[0]; laarr[2] = laarr[0];
laarr[0] = laarr[1]; laarr[0] = laarr[1];
laarr[1] = laarr[2]; laarr[1] = laarr[2];
...@@ -617,15 +618,14 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -617,15 +618,14 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
} }
/* if the current block is located in an extent, read the next extent */ /* if the current block is located in an extent, read the next extent */
if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1) if ((etype =
{ udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1) {
laarr[c+1].extLength = (etype << 30) | elen; laarr[c + 1].extLength = (etype << 30) | elen;
laarr[c+1].extLocation = eloc; laarr[c + 1].extLocation = eloc;
count ++; count++;
startnum ++; startnum++;
endnum ++; endnum++;
} } else {
else {
lastblock = 1; lastblock = 1;
} }
} }
...@@ -634,20 +634,21 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -634,20 +634,21 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
block in the extent corresponding to the requested block */ block in the extent corresponding to the requested block */
if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
newblocknum = laarr[c].extLocation.logicalBlockNum + offset; newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
else /* otherwise, allocate a new block */ else { /* otherwise, allocate a new block */
{
if (UDF_I_NEXT_ALLOC_BLOCK(inode) == block) if (UDF_I_NEXT_ALLOC_BLOCK(inode) == block)
goal = UDF_I_NEXT_ALLOC_GOAL(inode); goal = UDF_I_NEXT_ALLOC_GOAL(inode);
if (!goal) if (!goal) {
{
if (!(goal = pgoal)) if (!(goal = pgoal))
goal = UDF_I_LOCATION(inode).logicalBlockNum + 1; goal =
UDF_I_LOCATION(inode).logicalBlockNum + 1;
} }
if (!(newblocknum = udf_new_block(inode->i_sb, inode, if (!(newblocknum = udf_new_block(inode->i_sb, inode,
UDF_I_LOCATION(inode).partitionReferenceNum, goal, err))) UDF_I_LOCATION(inode).
{ partitionReferenceNum, goal,
err))) {
brelse(prev_epos.bh); brelse(prev_epos.bh);
*err = -ENOSPC; *err = -ENOSPC;
return NULL; return NULL;
...@@ -676,8 +677,8 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -676,8 +677,8 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
brelse(prev_epos.bh); brelse(prev_epos.bh);
if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum, if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum,
UDF_I_LOCATION(inode).partitionReferenceNum, 0))) UDF_I_LOCATION(inode).
{ partitionReferenceNum, 0))) {
return NULL; return NULL;
} }
*phys = newblock; *phys = newblock;
...@@ -694,46 +695,48 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block, ...@@ -694,46 +695,48 @@ static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
return result; return result;
} }
static void udf_split_extents(struct inode *inode, int *c, int offset, int newblocknum, static void udf_split_extents(struct inode *inode, int *c, int offset,
kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum) int newblocknum,
kernel_long_ad laarr[EXTENT_MERGE_SIZE],
int *endnum)
{ {
if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) || if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
(laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) (laarr[*c].extLength >> 30) ==
{ (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
int curr = *c; int curr = *c;
int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) + int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits; inode->i_sb->s_blocksize -
1) >> inode->i_sb->s_blocksize_bits;
int8_t etype = (laarr[curr].extLength >> 30); int8_t etype = (laarr[curr].extLength >> 30);
if (blen == 1) if (blen == 1) ;
; else if (!offset || blen == offset + 1) {
else if (!offset || blen == offset + 1) laarr[curr + 2] = laarr[curr + 1];
{ laarr[curr + 1] = laarr[curr];
laarr[curr+2] = laarr[curr+1]; } else {
laarr[curr+1] = laarr[curr]; laarr[curr + 3] = laarr[curr + 1];
} laarr[curr + 2] = laarr[curr + 1] = laarr[curr];
else }
{
laarr[curr+3] = laarr[curr+1]; if (offset) {
laarr[curr+2] = laarr[curr+1] = laarr[curr]; if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
} udf_free_blocks(inode->i_sb, inode,
laarr[curr].extLocation, 0,
if (offset) offset);
{ laarr[curr].extLength =
if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) EXT_NOT_RECORDED_NOT_ALLOCATED | (offset <<
{ inode->
udf_free_blocks(inode->i_sb, inode, laarr[curr].extLocation, 0, offset); i_sb->
laarr[curr].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | s_blocksize_bits);
(offset << inode->i_sb->s_blocksize_bits);
laarr[curr].extLocation.logicalBlockNum = 0; laarr[curr].extLocation.logicalBlockNum = 0;
laarr[curr].extLocation.partitionReferenceNum = 0; laarr[curr].extLocation.partitionReferenceNum =
} 0;
else } else
laarr[curr].extLength = (etype << 30) | laarr[curr].extLength = (etype << 30) |
(offset << inode->i_sb->s_blocksize_bits); (offset << inode->i_sb->s_blocksize_bits);
curr ++; curr++;
(*c) ++; (*c)++;
(*endnum) ++; (*endnum)++;
} }
laarr[curr].extLocation.logicalBlockNum = newblocknum; laarr[curr].extLocation.logicalBlockNum = newblocknum;
...@@ -742,235 +745,279 @@ static void udf_split_extents(struct inode *inode, int *c, int offset, int newbl ...@@ -742,235 +745,279 @@ static void udf_split_extents(struct inode *inode, int *c, int offset, int newbl
UDF_I_LOCATION(inode).partitionReferenceNum; UDF_I_LOCATION(inode).partitionReferenceNum;
laarr[curr].extLength = EXT_RECORDED_ALLOCATED | laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
inode->i_sb->s_blocksize; inode->i_sb->s_blocksize;
curr ++; curr++;
if (blen != offset + 1) if (blen != offset + 1) {
{
if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
laarr[curr].extLocation.logicalBlockNum += (offset + 1); laarr[curr].extLocation.logicalBlockNum +=
laarr[curr].extLength = (etype << 30) | (offset + 1);
((blen - (offset + 1)) << inode->i_sb->s_blocksize_bits); laarr[curr].extLength =
curr ++; (etype << 30) | ((blen - (offset + 1)) << inode->
(*endnum) ++; i_sb->s_blocksize_bits);
curr++;
(*endnum)++;
} }
} }
} }
static void udf_prealloc_extents(struct inode *inode, int c, int lastblock, static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum) kernel_long_ad laarr[EXTENT_MERGE_SIZE],
int *endnum)
{ {
int start, length = 0, currlength = 0, i; int start, length = 0, currlength = 0, i;
if (*endnum >= (c+1)) if (*endnum >= (c + 1)) {
{
if (!lastblock) if (!lastblock)
return; return;
else else
start = c; start = c;
} } else {
else if ((laarr[c + 1].extLength >> 30) ==
{ (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
if ((laarr[c+1].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) start = c + 1;
{ length = currlength =
start = c+1; (((laarr[c + 1].
length = currlength = (((laarr[c+1].extLength & UDF_EXTENT_LENGTH_MASK) + extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits); inode->i_sb->s_blocksize -
} 1) >> inode->i_sb->s_blocksize_bits);
else } else
start = c; start = c;
} }
for (i=start+1; i<=*endnum; i++) for (i = start + 1; i <= *endnum; i++) {
{ if (i == *endnum) {
if (i == *endnum)
{
if (lastblock) if (lastblock)
length += UDF_DEFAULT_PREALLOC_BLOCKS; length += UDF_DEFAULT_PREALLOC_BLOCKS;
} } else if ((laarr[i].extLength >> 30) ==
else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
length += (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + length +=
inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits); (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize -
1) >> inode->i_sb->s_blocksize_bits);
else else
break; break;
} }
if (length) if (length) {
{
int next = laarr[start].extLocation.logicalBlockNum + int next = laarr[start].extLocation.logicalBlockNum +
(((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) + (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits); inode->i_sb->s_blocksize -
1) >> inode->i_sb->s_blocksize_bits);
int numalloc = udf_prealloc_blocks(inode->i_sb, inode, int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
laarr[start].extLocation.partitionReferenceNum, laarr[start].extLocation.
next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ? length : partitionReferenceNum,
UDF_DEFAULT_PREALLOC_BLOCKS) - currlength); next,
(UDF_DEFAULT_PREALLOC_BLOCKS
if (numalloc) >
{ length ? length :
if (start == (c+1)) UDF_DEFAULT_PREALLOC_BLOCKS)
- currlength);
if (numalloc) {
if (start == (c + 1))
laarr[start].extLength += laarr[start].extLength +=
(numalloc << inode->i_sb->s_blocksize_bits); (numalloc << inode->i_sb->s_blocksize_bits);
else else {
{ memmove(&laarr[c + 2], &laarr[c + 1],
memmove(&laarr[c+2], &laarr[c+1], sizeof(long_ad) * (*endnum - (c + 1)));
sizeof(long_ad) * (*endnum - (c+1))); (*endnum)++;
(*endnum) ++; laarr[c + 1].extLocation.logicalBlockNum = next;
laarr[c+1].extLocation.logicalBlockNum = next; laarr[c + 1].extLocation.partitionReferenceNum =
laarr[c+1].extLocation.partitionReferenceNum =
laarr[c].extLocation.partitionReferenceNum; laarr[c].extLocation.partitionReferenceNum;
laarr[c+1].extLength = EXT_NOT_RECORDED_ALLOCATED | laarr[c + 1].extLength =
(numalloc << inode->i_sb->s_blocksize_bits); EXT_NOT_RECORDED_ALLOCATED | (numalloc <<
start = c+1; inode->i_sb->
s_blocksize_bits);
start = c + 1;
} }
for (i=start+1; numalloc && i<*endnum; i++) for (i = start + 1; numalloc && i < *endnum; i++) {
{ int elen =
int elen = ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + ((laarr[i].
inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits; extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize -
1) >> inode->i_sb->s_blocksize_bits;
if (elen > numalloc) if (elen > numalloc) {
{
laarr[i].extLength -= laarr[i].extLength -=
(numalloc << inode->i_sb->s_blocksize_bits); (numalloc << inode->i_sb->
s_blocksize_bits);
numalloc = 0; numalloc = 0;
} } else {
else
{
numalloc -= elen; numalloc -= elen;
if (*endnum > (i+1)) if (*endnum > (i + 1))
memmove(&laarr[i], &laarr[i+1], memmove(&laarr[i],
sizeof(long_ad) * (*endnum - (i+1))); &laarr[i + 1],
i --; sizeof(long_ad) *
(*endnum) --; (*endnum - (i + 1)));
i--;
(*endnum)--;
} }
} }
UDF_I_LENEXTENTS(inode) += numalloc << inode->i_sb->s_blocksize_bits; UDF_I_LENEXTENTS(inode) +=
numalloc << inode->i_sb->s_blocksize_bits;
} }
} }
} }
static void udf_merge_extents(struct inode *inode, static void udf_merge_extents(struct inode *inode,
kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum) kernel_long_ad laarr[EXTENT_MERGE_SIZE],
int *endnum)
{ {
int i; int i;
for (i=0; i<(*endnum-1); i++) for (i = 0; i < (*endnum - 1); i++) {
{ if ((laarr[i].extLength >> 30) ==
if ((laarr[i].extLength >> 30) == (laarr[i+1].extLength >> 30)) (laarr[i + 1].extLength >> 30)) {
{ if (((laarr[i].extLength >> 30) ==
if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) || (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
((laarr[i+1].extLocation.logicalBlockNum - laarr[i].extLocation.logicalBlockNum) == ||
((laarr[i + 1].extLocation.logicalBlockNum -
laarr[i].extLocation.logicalBlockNum) ==
(((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits))) inode->i_sb->s_blocksize -
{ 1) >> inode->i_sb->s_blocksize_bits))) {
if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + if (((laarr[i].
(laarr[i+1].extLength & UDF_EXTENT_LENGTH_MASK) + extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) (laarr[i + 1].
{ extLength & UDF_EXTENT_LENGTH_MASK) +
laarr[i+1].extLength = (laarr[i+1].extLength - inode->i_sb->s_blocksize -
(laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + 1) & ~UDF_EXTENT_LENGTH_MASK) {
UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize-1); laarr[i + 1].extLength =
laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) + (laarr[i + 1].extLength -
(UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize; (laarr[i].
laarr[i+1].extLocation.logicalBlockNum = extLength &
laarr[i].extLocation.logicalBlockNum + UDF_EXTENT_LENGTH_MASK) +
((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) >> UDF_EXTENT_LENGTH_MASK) & ~(inode->
inode->i_sb->s_blocksize_bits); i_sb->
} s_blocksize
else - 1);
{ laarr[i].extLength =
laarr[i].extLength = laarr[i+1].extLength + (laarr[i].
(((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + extLength & UDF_EXTENT_FLAG_MASK) +
inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize-1)); (UDF_EXTENT_LENGTH_MASK + 1) -
if (*endnum > (i+2)) inode->i_sb->s_blocksize;
memmove(&laarr[i+1], &laarr[i+2], laarr[i +
sizeof(long_ad) * (*endnum - (i+2))); 1].extLocation.logicalBlockNum =
i --; laarr[i].extLocation.
(*endnum) --; logicalBlockNum +
} ((laarr[i].
} extLength &
} UDF_EXTENT_LENGTH_MASK) >> inode->
else if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) && i_sb->s_blocksize_bits);
((laarr[i+1].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) } else {
{ laarr[i].extLength =
udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0, laarr[i + 1].extLength +
((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + (((laarr[i].
inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits); extLength &
UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize -
1) & ~(inode->i_sb->s_blocksize -
1));
if (*endnum > (i + 2))
memmove(&laarr[i + 1],
&laarr[i + 2],
sizeof(long_ad) *
(*endnum - (i + 2)));
i--;
(*endnum)--;
}
}
} else
if (((laarr[i].extLength >> 30) ==
(EXT_NOT_RECORDED_ALLOCATED >> 30))
&& ((laarr[i + 1].extLength >> 30) ==
(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
udf_free_blocks(inode->i_sb, inode,
laarr[i].extLocation, 0,
((laarr[i].
extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize -
1) >> inode->i_sb->s_blocksize_bits);
laarr[i].extLocation.logicalBlockNum = 0; laarr[i].extLocation.logicalBlockNum = 0;
laarr[i].extLocation.partitionReferenceNum = 0; laarr[i].extLocation.partitionReferenceNum = 0;
if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
(laarr[i+1].extLength & UDF_EXTENT_LENGTH_MASK) + (laarr[i + 1].extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) inode->i_sb->s_blocksize -
{ 1) & ~UDF_EXTENT_LENGTH_MASK) {
laarr[i+1].extLength = (laarr[i+1].extLength - laarr[i + 1].extLength =
(laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + (laarr[i + 1].extLength -
UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize-1); (laarr[i].
laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) + extLength & UDF_EXTENT_LENGTH_MASK) +
(UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize; UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->
} s_blocksize -
else 1);
{ laarr[i].extLength =
laarr[i].extLength = laarr[i+1].extLength + (laarr[i].
(((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + extLength & UDF_EXTENT_FLAG_MASK) +
inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize-1)); (UDF_EXTENT_LENGTH_MASK + 1) -
if (*endnum > (i+2)) inode->i_sb->s_blocksize;
memmove(&laarr[i+1], &laarr[i+2], } else {
sizeof(long_ad) * (*endnum - (i+2))); laarr[i].extLength = laarr[i + 1].extLength +
i --; (((laarr[i].
(*endnum) --; extLength & UDF_EXTENT_LENGTH_MASK) +
} inode->i_sb->s_blocksize -
} 1) & ~(inode->i_sb->s_blocksize - 1));
else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) if (*endnum > (i + 2))
{ memmove(&laarr[i + 1], &laarr[i + 2],
udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0, sizeof(long_ad) * (*endnum -
((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) + (i + 2)));
inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits); i--;
(*endnum)--;
}
} else if ((laarr[i].extLength >> 30) ==
(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
udf_free_blocks(inode->i_sb, inode,
laarr[i].extLocation, 0,
((laarr[i].
extLength & UDF_EXTENT_LENGTH_MASK) +
inode->i_sb->s_blocksize -
1) >> inode->i_sb->s_blocksize_bits);
laarr[i].extLocation.logicalBlockNum = 0; laarr[i].extLocation.logicalBlockNum = 0;
laarr[i].extLocation.partitionReferenceNum = 0; laarr[i].extLocation.partitionReferenceNum = 0;
laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) | laarr[i].extLength =
(laarr[i].
extLength & UDF_EXTENT_LENGTH_MASK) |
EXT_NOT_RECORDED_NOT_ALLOCATED; EXT_NOT_RECORDED_NOT_ALLOCATED;
} }
} }
} }
static void udf_update_extents(struct inode *inode, static void udf_update_extents(struct inode *inode,
kernel_long_ad laarr[EXTENT_MERGE_SIZE], int startnum, int endnum, kernel_long_ad laarr[EXTENT_MERGE_SIZE],
int startnum, int endnum,
struct extent_position *epos) struct extent_position *epos)
{ {
int start = 0, i; int start = 0, i;
kernel_lb_addr tmploc; kernel_lb_addr tmploc;
uint32_t tmplen; uint32_t tmplen;
if (startnum > endnum) if (startnum > endnum) {
{ for (i = 0; i < (startnum - endnum); i++)
for (i=0; i<(startnum-endnum); i++)
udf_delete_aext(inode, *epos, laarr[i].extLocation, udf_delete_aext(inode, *epos, laarr[i].extLocation,
laarr[i].extLength); laarr[i].extLength);
} } else if (startnum < endnum) {
else if (startnum < endnum) for (i = 0; i < (endnum - startnum); i++) {
{
for (i=0; i<(endnum-startnum); i++)
{
udf_insert_aext(inode, *epos, laarr[i].extLocation, udf_insert_aext(inode, *epos, laarr[i].extLocation,
laarr[i].extLength); laarr[i].extLength);
udf_next_aext(inode, epos, &laarr[i].extLocation, udf_next_aext(inode, epos, &laarr[i].extLocation,
&laarr[i].extLength, 1); &laarr[i].extLength, 1);
start ++; start++;
} }
} }
for (i=start; i<endnum; i++) for (i = start; i < endnum; i++) {
{
udf_next_aext(inode, epos, &tmploc, &tmplen, 0); udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
udf_write_aext(inode, epos, laarr[i].extLocation, udf_write_aext(inode, epos, laarr[i].extLocation,
laarr[i].extLength, 1); laarr[i].extLength, 1);
} }
} }
struct buffer_head * udf_bread(struct inode * inode, int block, struct buffer_head *udf_bread(struct inode *inode, int block,
int create, int * err) int create, int *err)
{ {
struct buffer_head * bh = NULL; struct buffer_head *bh = NULL;
bh = udf_getblk(inode, block, create, err); bh = udf_getblk(inode, block, create, err);
if (!bh) if (!bh)
...@@ -987,7 +1034,7 @@ struct buffer_head * udf_bread(struct inode * inode, int block, ...@@ -987,7 +1034,7 @@ struct buffer_head * udf_bread(struct inode * inode, int block,
return NULL; return NULL;
} }
void udf_truncate(struct inode * inode) void udf_truncate(struct inode *inode)
{ {
int offset; int offset;
int err; int err;
...@@ -999,44 +1046,39 @@ void udf_truncate(struct inode * inode) ...@@ -999,44 +1046,39 @@ void udf_truncate(struct inode * inode)
return; return;
lock_kernel(); lock_kernel();
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
{ if (inode->i_sb->s_blocksize <
if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) + (udf_file_entry_alloc_offset(inode) + inode->i_size)) {
inode->i_size))
{
udf_expand_file_adinicb(inode, inode->i_size, &err); udf_expand_file_adinicb(inode, inode->i_size, &err);
if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
{
inode->i_size = UDF_I_LENALLOC(inode); inode->i_size = UDF_I_LENALLOC(inode);
unlock_kernel(); unlock_kernel();
return; return;
} } else
else
udf_truncate_extents(inode); udf_truncate_extents(inode);
} } else {
else
{
offset = inode->i_size & (inode->i_sb->s_blocksize - 1); offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset, 0x00, inode->i_sb->s_blocksize - offset - udf_file_entry_alloc_offset(inode)); memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) +
offset, 0x00,
inode->i_sb->s_blocksize - offset -
udf_file_entry_alloc_offset(inode));
UDF_I_LENALLOC(inode) = inode->i_size; UDF_I_LENALLOC(inode) = inode->i_size;
} }
} } else {
else block_truncate_page(inode->i_mapping, inode->i_size,
{ udf_get_block);
block_truncate_page(inode->i_mapping, inode->i_size, udf_get_block);
udf_truncate_extents(inode); udf_truncate_extents(inode);
} }
inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb); inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
if (IS_SYNC(inode)) if (IS_SYNC(inode))
udf_sync_inode (inode); udf_sync_inode(inode);
else else
mark_inode_dirty(inode); mark_inode_dirty(inode);
unlock_kernel(); unlock_kernel();
} }
static void static void __udf_read_inode(struct inode *inode)
__udf_read_inode(struct inode *inode)
{ {
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
struct fileEntry *fe; struct fileEntry *fe;
...@@ -1056,8 +1098,7 @@ __udf_read_inode(struct inode *inode) ...@@ -1056,8 +1098,7 @@ __udf_read_inode(struct inode *inode)
*/ */
bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident); bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);
if (!bh) if (!bh) {
{
printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n", printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
inode->i_ino); inode->i_ino);
make_bad_inode(inode); make_bad_inode(inode);
...@@ -1065,9 +1106,9 @@ __udf_read_inode(struct inode *inode) ...@@ -1065,9 +1106,9 @@ __udf_read_inode(struct inode *inode)
} }
if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE && if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
ident != TAG_IDENT_USE) ident != TAG_IDENT_USE) {
{ printk(KERN_ERR
printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n", "udf: udf_read_inode(ino %ld) failed ident=%d\n",
inode->i_ino, ident); inode->i_ino, ident);
brelse(bh); brelse(bh);
make_bad_inode(inode); make_bad_inode(inode);
...@@ -1076,49 +1117,44 @@ __udf_read_inode(struct inode *inode) ...@@ -1076,49 +1117,44 @@ __udf_read_inode(struct inode *inode)
fe = (struct fileEntry *)bh->b_data; fe = (struct fileEntry *)bh->b_data;
if (le16_to_cpu(fe->icbTag.strategyType) == 4096) if (le16_to_cpu(fe->icbTag.strategyType) == 4096) {
{
struct buffer_head *ibh = NULL, *nbh = NULL; struct buffer_head *ibh = NULL, *nbh = NULL;
struct indirectEntry *ie; struct indirectEntry *ie;
ibh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1, &ident); ibh =
if (ident == TAG_IDENT_IE) udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1,
{ &ident);
if (ibh) if (ident == TAG_IDENT_IE) {
{ if (ibh) {
kernel_lb_addr loc; kernel_lb_addr loc;
ie = (struct indirectEntry *)ibh->b_data; ie = (struct indirectEntry *)ibh->b_data;
loc = lelb_to_cpu(ie->indirectICB.extLocation); loc = lelb_to_cpu(ie->indirectICB.extLocation);
if (ie->indirectICB.extLength && if (ie->indirectICB.extLength &&
(nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident))) (nbh =
{ udf_read_ptagged(inode->i_sb, loc, 0,
if (ident == TAG_IDENT_FE || &ident))) {
ident == TAG_IDENT_EFE) if (ident == TAG_IDENT_FE
{ || ident == TAG_IDENT_EFE) {
memcpy(&UDF_I_LOCATION(inode), &loc, sizeof(kernel_lb_addr)); memcpy(&UDF_I_LOCATION(inode),
&loc,
sizeof(kernel_lb_addr));
brelse(bh); brelse(bh);
brelse(ibh); brelse(ibh);
brelse(nbh); brelse(nbh);
__udf_read_inode(inode); __udf_read_inode(inode);
return; return;
} } else {
else
{
brelse(nbh); brelse(nbh);
brelse(ibh); brelse(ibh);
} }
} } else
else
brelse(ibh); brelse(ibh);
} }
} } else
else
brelse(ibh); brelse(ibh);
} } else if (le16_to_cpu(fe->icbTag.strategyType) != 4) {
else if (le16_to_cpu(fe->icbTag.strategyType) != 4)
{
printk(KERN_ERR "udf: unsupported strategy type: %d\n", printk(KERN_ERR "udf: unsupported strategy type: %d\n",
le16_to_cpu(fe->icbTag.strategyType)); le16_to_cpu(fe->icbTag.strategyType));
brelse(bh); brelse(bh);
...@@ -1146,48 +1182,56 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1146,48 +1182,56 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */ else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
UDF_I_STRAT4096(inode) = 1; UDF_I_STRAT4096(inode) = 1;
UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK; UDF_I_ALLOCTYPE(inode) =
le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK;
UDF_I_UNIQUE(inode) = 0; UDF_I_UNIQUE(inode) = 0;
UDF_I_LENEATTR(inode) = 0; UDF_I_LENEATTR(inode) = 0;
UDF_I_LENEXTENTS(inode) = 0; UDF_I_LENEXTENTS(inode) = 0;
UDF_I_LENALLOC(inode) = 0; UDF_I_LENALLOC(inode) = 0;
UDF_I_NEXT_ALLOC_BLOCK(inode) = 0; UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
UDF_I_NEXT_ALLOC_GOAL(inode) = 0; UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE) if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE) {
{
UDF_I_EFE(inode) = 1; UDF_I_EFE(inode) = 1;
UDF_I_USE(inode) = 0; UDF_I_USE(inode) = 0;
if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry))) if (udf_alloc_i_data
{ (inode,
inode->i_sb->s_blocksize -
sizeof(struct extendedFileEntry))) {
make_bad_inode(inode); make_bad_inode(inode);
return; return;
} }
memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct extendedFileEntry), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry)); memcpy(UDF_I_DATA(inode),
} bh->b_data + sizeof(struct extendedFileEntry),
else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE) inode->i_sb->s_blocksize -
{ sizeof(struct extendedFileEntry));
} else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE) {
UDF_I_EFE(inode) = 0; UDF_I_EFE(inode) = 0;
UDF_I_USE(inode) = 0; UDF_I_USE(inode) = 0;
if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct fileEntry))) if (udf_alloc_i_data
{ (inode,
inode->i_sb->s_blocksize - sizeof(struct fileEntry))) {
make_bad_inode(inode); make_bad_inode(inode);
return; return;
} }
memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry), inode->i_sb->s_blocksize - sizeof(struct fileEntry)); memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry),
} inode->i_sb->s_blocksize - sizeof(struct fileEntry));
else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) } else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) {
{
UDF_I_EFE(inode) = 0; UDF_I_EFE(inode) = 0;
UDF_I_USE(inode) = 1; UDF_I_USE(inode) = 1;
UDF_I_LENALLOC(inode) = UDF_I_LENALLOC(inode) =
le32_to_cpu( le32_to_cpu(((struct unallocSpaceEntry *)bh->b_data)->
((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs); lengthAllocDescs);
if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry))) if (udf_alloc_i_data
{ (inode,
inode->i_sb->s_blocksize -
sizeof(struct unallocSpaceEntry))) {
make_bad_inode(inode); make_bad_inode(inode);
return; return;
} }
memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct unallocSpaceEntry), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry)); memcpy(UDF_I_DATA(inode),
bh->b_data + sizeof(struct unallocSpaceEntry),
inode->i_sb->s_blocksize -
sizeof(struct unallocSpaceEntry));
return; return;
} }
...@@ -1211,41 +1255,31 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1211,41 +1255,31 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
inode->i_mode = udf_convert_permissions(fe); inode->i_mode = udf_convert_permissions(fe);
inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask; inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
if (UDF_I_EFE(inode) == 0) if (UDF_I_EFE(inode) == 0) {
{
inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) << inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
(inode->i_sb->s_blocksize_bits - 9); (inode->i_sb->s_blocksize_bits - 9);
if ( udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
lets_to_cpu(fe->accessTime)) ) lets_to_cpu(fe->accessTime))) {
{
inode->i_atime.tv_sec = convtime; inode->i_atime.tv_sec = convtime;
inode->i_atime.tv_nsec = convtime_usec * 1000; inode->i_atime.tv_nsec = convtime_usec * 1000;
} } else {
else
{
inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb); inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
} }
if ( udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
lets_to_cpu(fe->modificationTime)) ) lets_to_cpu(fe->modificationTime))) {
{
inode->i_mtime.tv_sec = convtime; inode->i_mtime.tv_sec = convtime;
inode->i_mtime.tv_nsec = convtime_usec * 1000; inode->i_mtime.tv_nsec = convtime_usec * 1000;
} } else {
else
{
inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb); inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
} }
if ( udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
lets_to_cpu(fe->attrTime)) ) lets_to_cpu(fe->attrTime))) {
{
inode->i_ctime.tv_sec = convtime; inode->i_ctime.tv_sec = convtime;
inode->i_ctime.tv_nsec = convtime_usec * 1000; inode->i_ctime.tv_nsec = convtime_usec * 1000;
} } else {
else
{
inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb); inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
} }
...@@ -1253,64 +1287,50 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1253,64 +1287,50 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr); UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr);
UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs); UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs);
offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode); offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode);
} } else {
else
{
inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) << inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
(inode->i_sb->s_blocksize_bits - 9); (inode->i_sb->s_blocksize_bits - 9);
if ( udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
lets_to_cpu(efe->accessTime)) ) lets_to_cpu(efe->accessTime))) {
{
inode->i_atime.tv_sec = convtime; inode->i_atime.tv_sec = convtime;
inode->i_atime.tv_nsec = convtime_usec * 1000; inode->i_atime.tv_nsec = convtime_usec * 1000;
} } else {
else
{
inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb); inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
} }
if ( udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
lets_to_cpu(efe->modificationTime)) ) lets_to_cpu(efe->modificationTime))) {
{
inode->i_mtime.tv_sec = convtime; inode->i_mtime.tv_sec = convtime;
inode->i_mtime.tv_nsec = convtime_usec * 1000; inode->i_mtime.tv_nsec = convtime_usec * 1000;
} } else {
else
{
inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb); inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
} }
if ( udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
lets_to_cpu(efe->createTime)) ) lets_to_cpu(efe->createTime))) {
{
UDF_I_CRTIME(inode).tv_sec = convtime; UDF_I_CRTIME(inode).tv_sec = convtime;
UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000; UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000;
} } else {
else
{
UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb); UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb);
} }
if ( udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
lets_to_cpu(efe->attrTime)) ) lets_to_cpu(efe->attrTime))) {
{
inode->i_ctime.tv_sec = convtime; inode->i_ctime.tv_sec = convtime;
inode->i_ctime.tv_nsec = convtime_usec * 1000; inode->i_ctime.tv_nsec = convtime_usec * 1000;
} } else {
else
{
inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb); inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
} }
UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID); UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr); UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr);
UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs); UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs);
offset = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode); offset =
sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
} }
switch (fe->icbTag.fileType) switch (fe->icbTag.fileType) {
{
case ICBTAG_FILE_TYPE_DIRECTORY: case ICBTAG_FILE_TYPE_DIRECTORY:
{ {
inode->i_op = &udf_dir_inode_operations; inode->i_op = &udf_dir_inode_operations;
...@@ -1356,32 +1376,30 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) ...@@ -1356,32 +1376,30 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
{ {
inode->i_data.a_ops = &udf_symlink_aops; inode->i_data.a_ops = &udf_symlink_aops;
inode->i_op = &page_symlink_inode_operations; inode->i_op = &page_symlink_inode_operations;
inode->i_mode = S_IFLNK|S_IRWXUGO; inode->i_mode = S_IFLNK | S_IRWXUGO;
break; break;
} }
default: default:
{ {
printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n", printk(KERN_ERR
"udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
inode->i_ino, fe->icbTag.fileType); inode->i_ino, fe->icbTag.fileType);
make_bad_inode(inode); make_bad_inode(inode);
return; return;
} }
} }
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
{ struct deviceSpec *dsea = (struct deviceSpec *)
struct deviceSpec *dsea =
(struct deviceSpec *)
udf_get_extendedattr(inode, 12, 1); udf_get_extendedattr(inode, 12, 1);
if (dsea) if (dsea) {
{ init_special_inode(inode, inode->i_mode,
init_special_inode(inode, inode->i_mode, MKDEV( MKDEV(le32_to_cpu
le32_to_cpu(dsea->majorDeviceIdent), (dsea->majorDeviceIdent),
le32_to_cpu(dsea->minorDeviceIdent))); le32_to_cpu(dsea->
minorDeviceIdent)));
/* Developer ID ??? */ /* Developer ID ??? */
} } else {
else
{
make_bad_inode(inode); make_bad_inode(inode);
} }
} }
...@@ -1391,9 +1409,9 @@ static int udf_alloc_i_data(struct inode *inode, size_t size) ...@@ -1391,9 +1409,9 @@ static int udf_alloc_i_data(struct inode *inode, size_t size)
{ {
UDF_I_DATA(inode) = kmalloc(size, GFP_KERNEL); UDF_I_DATA(inode) = kmalloc(size, GFP_KERNEL);
if (!UDF_I_DATA(inode)) if (!UDF_I_DATA(inode)) {
{ printk(KERN_ERR
printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) no free memory\n", "udf:udf_alloc_i_data (ino %ld) no free memory\n",
inode->i_ino); inode->i_ino);
return -ENOMEM; return -ENOMEM;
} }
...@@ -1401,8 +1419,7 @@ static int udf_alloc_i_data(struct inode *inode, size_t size) ...@@ -1401,8 +1419,7 @@ static int udf_alloc_i_data(struct inode *inode, size_t size)
return 0; return 0;
} }
static mode_t static mode_t udf_convert_permissions(struct fileEntry *fe)
udf_convert_permissions(struct fileEntry *fe)
{ {
mode_t mode; mode_t mode;
uint32_t permissions; uint32_t permissions;
...@@ -1411,12 +1428,12 @@ udf_convert_permissions(struct fileEntry *fe) ...@@ -1411,12 +1428,12 @@ udf_convert_permissions(struct fileEntry *fe)
permissions = le32_to_cpu(fe->permissions); permissions = le32_to_cpu(fe->permissions);
flags = le16_to_cpu(fe->icbTag.flags); flags = le16_to_cpu(fe->icbTag.flags);
mode = (( permissions ) & S_IRWXO) | mode = ((permissions) & S_IRWXO) |
(( permissions >> 2 ) & S_IRWXG) | ((permissions >> 2) & S_IRWXG) |
(( permissions >> 4 ) & S_IRWXU) | ((permissions >> 4) & S_IRWXU) |
(( flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) | ((flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
(( flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) | ((flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
(( flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0); ((flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
return mode; return mode;
} }
...@@ -1436,7 +1453,7 @@ udf_convert_permissions(struct fileEntry *fe) ...@@ -1436,7 +1453,7 @@ udf_convert_permissions(struct fileEntry *fe)
* Written, tested, and released. * Written, tested, and released.
*/ */
int udf_write_inode(struct inode * inode, int sync) int udf_write_inode(struct inode *inode, int sync)
{ {
int ret; int ret;
lock_kernel(); lock_kernel();
...@@ -1445,13 +1462,12 @@ int udf_write_inode(struct inode * inode, int sync) ...@@ -1445,13 +1462,12 @@ int udf_write_inode(struct inode * inode, int sync)
return ret; return ret;
} }
int udf_sync_inode(struct inode * inode) int udf_sync_inode(struct inode *inode)
{ {
return udf_update_inode(inode, 1); return udf_update_inode(inode, 1);
} }
static int static int udf_update_inode(struct inode *inode, int do_sync)
udf_update_inode(struct inode *inode, int do_sync)
{ {
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
struct fileEntry *fe; struct fileEntry *fe;
...@@ -1464,10 +1480,10 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1464,10 +1480,10 @@ udf_update_inode(struct inode *inode, int do_sync)
int err = 0; int err = 0;
bh = udf_tread(inode->i_sb, bh = udf_tread(inode->i_sb,
udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0)); udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode),
0));
if (!bh) if (!bh) {
{
udf_debug("bread failure\n"); udf_debug("bread failure\n");
return -EIO; return -EIO;
} }
...@@ -1477,23 +1493,29 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1477,23 +1493,29 @@ udf_update_inode(struct inode *inode, int do_sync)
fe = (struct fileEntry *)bh->b_data; fe = (struct fileEntry *)bh->b_data;
efe = (struct extendedFileEntry *)bh->b_data; efe = (struct extendedFileEntry *)bh->b_data;
if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) {
{
struct unallocSpaceEntry *use = struct unallocSpaceEntry *use =
(struct unallocSpaceEntry *)bh->b_data; (struct unallocSpaceEntry *)bh->b_data;
use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode)); use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry)); memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
crclen = sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) - UDF_I_DATA(inode),
inode->i_sb->s_blocksize -
sizeof(struct unallocSpaceEntry));
crclen =
sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) -
sizeof(tag); sizeof(tag);
use->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum); use->descTag.tagLocation =
cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
use->descTag.descCRCLength = cpu_to_le16(crclen); use->descTag.descCRCLength = cpu_to_le16(crclen);
use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0)); use->descTag.descCRC =
cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0));
use->descTag.tagChecksum = 0; use->descTag.tagChecksum = 0;
for (i=0; i<16; i++) for (i = 0; i < 16; i++)
if (i != 4) if (i != 4)
use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i]; use->descTag.tagChecksum +=
((uint8_t *) & (use->descTag))[i];
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
brelse(bh); brelse(bh);
...@@ -1502,15 +1524,16 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1502,15 +1524,16 @@ udf_update_inode(struct inode *inode, int do_sync)
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET)) if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
fe->uid = cpu_to_le32(-1); fe->uid = cpu_to_le32(-1);
else fe->uid = cpu_to_le32(inode->i_uid); else
fe->uid = cpu_to_le32(inode->i_uid);
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET)) if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
fe->gid = cpu_to_le32(-1); fe->gid = cpu_to_le32(-1);
else fe->gid = cpu_to_le32(inode->i_gid); else
fe->gid = cpu_to_le32(inode->i_gid);
udfperms = ((inode->i_mode & S_IRWXO) ) | udfperms = ((inode->i_mode & S_IRWXO)) |
((inode->i_mode & S_IRWXG) << 2) | ((inode->i_mode & S_IRWXG) << 2) | ((inode->i_mode & S_IRWXU) << 4);
((inode->i_mode & S_IRWXU) << 4);
udfperms |= (le32_to_cpu(fe->permissions) & udfperms |= (le32_to_cpu(fe->permissions) &
(FE_PERM_O_DELETE | FE_PERM_O_CHATTR | (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
...@@ -1525,26 +1548,24 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1525,26 +1548,24 @@ udf_update_inode(struct inode *inode, int do_sync)
fe->informationLength = cpu_to_le64(inode->i_size); fe->informationLength = cpu_to_le64(inode->i_size);
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
{
regid *eid; regid *eid;
struct deviceSpec *dsea = struct deviceSpec *dsea = (struct deviceSpec *)
(struct deviceSpec *)
udf_get_extendedattr(inode, 12, 1); udf_get_extendedattr(inode, 12, 1);
if (!dsea) if (!dsea) {
{
dsea = (struct deviceSpec *) dsea = (struct deviceSpec *)
udf_add_extendedattr(inode, udf_add_extendedattr(inode,
sizeof(struct deviceSpec) + sizeof(struct deviceSpec) +
sizeof(regid), 12, 0x3); sizeof(regid), 12, 0x3);
dsea->attrType = cpu_to_le32(12); dsea->attrType = cpu_to_le32(12);
dsea->attrSubtype = 1; dsea->attrSubtype = 1;
dsea->attrLength = cpu_to_le32(sizeof(struct deviceSpec) + dsea->attrLength =
cpu_to_le32(sizeof(struct deviceSpec) +
sizeof(regid)); sizeof(regid));
dsea->impUseLength = cpu_to_le32(sizeof(regid)); dsea->impUseLength = cpu_to_le32(sizeof(regid));
} }
eid = (regid *)dsea->impUse; eid = (regid *) dsea->impUse;
memset(eid, 0, sizeof(regid)); memset(eid, 0, sizeof(regid));
strcpy(eid->ident, UDF_ID_DEVELOPER); strcpy(eid->ident, UDF_ID_DEVELOPER);
eid->identSuffix[0] = UDF_OS_CLASS_UNIX; eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
...@@ -1553,12 +1574,13 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1553,12 +1574,13 @@ udf_update_inode(struct inode *inode, int do_sync)
dsea->minorDeviceIdent = cpu_to_le32(iminor(inode)); dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
} }
if (UDF_I_EFE(inode) == 0) if (UDF_I_EFE(inode) == 0) {
{ memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode),
memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct fileEntry)); inode->i_sb->s_blocksize - sizeof(struct fileEntry));
fe->logicalBlocksRecorded = cpu_to_le64( fe->logicalBlocksRecorded =
(inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >> cpu_to_le64((inode->i_blocks +
(inode->i_sb->s_blocksize_bits - 9)); (1 << (inode->i_sb->s_blocksize_bits - 9)) -
1) >> (inode->i_sb->s_blocksize_bits - 9));
if (udf_time_to_stamp(&cpu_time, inode->i_atime)) if (udf_time_to_stamp(&cpu_time, inode->i_atime))
fe->accessTime = cpu_to_lets(cpu_time); fe->accessTime = cpu_to_lets(cpu_time);
...@@ -1575,31 +1597,34 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1575,31 +1597,34 @@ udf_update_inode(struct inode *inode, int do_sync)
fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode)); fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE); fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
crclen = sizeof(struct fileEntry); crclen = sizeof(struct fileEntry);
} } else {
else memcpy(bh->b_data + sizeof(struct extendedFileEntry),
{ UDF_I_DATA(inode),
memcpy(bh->b_data + sizeof(struct extendedFileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry)); inode->i_sb->s_blocksize -
sizeof(struct extendedFileEntry));
efe->objectSize = cpu_to_le64(inode->i_size); efe->objectSize = cpu_to_le64(inode->i_size);
efe->logicalBlocksRecorded = cpu_to_le64( efe->logicalBlocksRecorded = cpu_to_le64((inode->i_blocks +
(inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >> (1 <<
(inode->i_sb->s_blocksize_bits - 9)); (inode->i_sb->
s_blocksize_bits -
9)) -
1) >> (inode->i_sb->
s_blocksize_bits
- 9));
if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec || if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec ||
(UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec && (UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec &&
UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec)) UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec)) {
{
UDF_I_CRTIME(inode) = inode->i_atime; UDF_I_CRTIME(inode) = inode->i_atime;
} }
if (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec || if (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec ||
(UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec && (UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec &&
UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec)) UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec)) {
{
UDF_I_CRTIME(inode) = inode->i_mtime; UDF_I_CRTIME(inode) = inode->i_mtime;
} }
if (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec || if (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec ||
(UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec && (UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec &&
UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec)) UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec)) {
{
UDF_I_CRTIME(inode) = inode->i_ctime; UDF_I_CRTIME(inode) = inode->i_ctime;
} }
...@@ -1622,14 +1647,11 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1622,14 +1647,11 @@ udf_update_inode(struct inode *inode, int do_sync)
efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE); efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
crclen = sizeof(struct extendedFileEntry); crclen = sizeof(struct extendedFileEntry);
} }
if (UDF_I_STRAT4096(inode)) if (UDF_I_STRAT4096(inode)) {
{
fe->icbTag.strategyType = cpu_to_le16(4096); fe->icbTag.strategyType = cpu_to_le16(4096);
fe->icbTag.strategyParameter = cpu_to_le16(1); fe->icbTag.strategyParameter = cpu_to_le16(1);
fe->icbTag.numEntries = cpu_to_le16(2); fe->icbTag.numEntries = cpu_to_le16(2);
} } else {
else
{
fe->icbTag.strategyType = cpu_to_le16(4); fe->icbTag.strategyType = cpu_to_le16(4);
fe->icbTag.numEntries = cpu_to_le16(1); fe->icbTag.numEntries = cpu_to_le16(1);
} }
...@@ -1663,23 +1685,24 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1663,23 +1685,24 @@ udf_update_inode(struct inode *inode, int do_sync)
else else
fe->descTag.descVersion = cpu_to_le16(2); fe->descTag.descVersion = cpu_to_le16(2);
fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb)); fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum); fe->descTag.tagLocation =
cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag); crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
fe->descTag.descCRCLength = cpu_to_le16(crclen); fe->descTag.descCRCLength = cpu_to_le16(crclen);
fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0)); fe->descTag.descCRC =
cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0));
fe->descTag.tagChecksum = 0; fe->descTag.tagChecksum = 0;
for (i=0; i<16; i++) for (i = 0; i < 16; i++)
if (i != 4) if (i != 4)
fe->descTag.tagChecksum += ((uint8_t *)&(fe->descTag))[i]; fe->descTag.tagChecksum +=
((uint8_t *) & (fe->descTag))[i];
/* write the data blocks */ /* write the data blocks */
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
if (do_sync) if (do_sync) {
{
sync_dirty_buffer(bh); sync_dirty_buffer(bh);
if (buffer_req(bh) && !buffer_uptodate(bh)) if (buffer_req(bh) && !buffer_uptodate(bh)) {
{
printk("IO error syncing udf inode [%s:%08lx]\n", printk("IO error syncing udf inode [%s:%08lx]\n",
inode->i_sb->s_id, inode->i_ino); inode->i_sb->s_id, inode->i_ino);
err = -EIO; err = -EIO;
...@@ -1689,8 +1712,7 @@ udf_update_inode(struct inode *inode, int do_sync) ...@@ -1689,8 +1712,7 @@ udf_update_inode(struct inode *inode, int do_sync)
return err; return err;
} }
struct inode * struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
udf_iget(struct super_block *sb, kernel_lb_addr ino)
{ {
unsigned long block = udf_get_lb_pblock(sb, ino, 0); unsigned long block = udf_get_lb_pblock(sb, ino, 0);
struct inode *inode = iget_locked(sb, block); struct inode *inode = iget_locked(sb, block);
...@@ -1707,7 +1729,8 @@ udf_iget(struct super_block *sb, kernel_lb_addr ino) ...@@ -1707,7 +1729,8 @@ udf_iget(struct super_block *sb, kernel_lb_addr ino)
if (is_bad_inode(inode)) if (is_bad_inode(inode))
goto out_iput; goto out_iput;
if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) { if (ino.logicalBlockNum >=
UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
udf_debug("block=%d, partition=%d out of range\n", udf_debug("block=%d, partition=%d out of range\n",
ino.logicalBlockNum, ino.partitionReferenceNum); ino.logicalBlockNum, ino.partitionReferenceNum);
make_bad_inode(inode); make_bad_inode(inode);
...@@ -1721,7 +1744,7 @@ udf_iget(struct super_block *sb, kernel_lb_addr ino) ...@@ -1721,7 +1744,7 @@ udf_iget(struct super_block *sb, kernel_lb_addr ino)
return NULL; return NULL;
} }
int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
kernel_lb_addr eloc, uint32_t elen, int inc) kernel_lb_addr eloc, uint32_t elen, int inc)
{ {
int adsize; int adsize;
...@@ -1732,7 +1755,9 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, ...@@ -1732,7 +1755,9 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
uint8_t *ptr; uint8_t *ptr;
if (!epos->bh) if (!epos->bh)
ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode); ptr =
UDF_I_DATA(inode) + epos->offset -
udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
else else
ptr = epos->bh->b_data + epos->offset; ptr = epos->bh->b_data + epos->offset;
...@@ -1743,21 +1768,24 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, ...@@ -1743,21 +1768,24 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
else else
return -1; return -1;
if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) {
{
char *sptr, *dptr; char *sptr, *dptr;
struct buffer_head *nbh; struct buffer_head *nbh;
int err, loffset; int err, loffset;
kernel_lb_addr obloc = epos->block; kernel_lb_addr obloc = epos->block;
if (!(epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL, if (!
obloc.partitionReferenceNum, obloc.logicalBlockNum, &err))) (epos->block.logicalBlockNum =
{ udf_new_block(inode->i_sb, NULL,
obloc.partitionReferenceNum,
obloc.logicalBlockNum, &err))) {
return -1; return -1;
} }
if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb, if (!
epos->block, 0)))) (nbh =
{ udf_tgetblk(inode->i_sb,
udf_get_lb_pblock(inode->i_sb, epos->block,
0)))) {
return -1; return -1;
} }
lock_buffer(nbh); lock_buffer(nbh);
...@@ -1768,31 +1796,28 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, ...@@ -1768,31 +1796,28 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
aed = (struct allocExtDesc *)(nbh->b_data); aed = (struct allocExtDesc *)(nbh->b_data);
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum); aed->previousAllocExtLocation =
if (epos->offset + adsize > inode->i_sb->s_blocksize) cpu_to_le32(obloc.logicalBlockNum);
{ if (epos->offset + adsize > inode->i_sb->s_blocksize) {
loffset = epos->offset; loffset = epos->offset;
aed->lengthAllocDescs = cpu_to_le32(adsize); aed->lengthAllocDescs = cpu_to_le32(adsize);
sptr = ptr - adsize; sptr = ptr - adsize;
dptr = nbh->b_data + sizeof(struct allocExtDesc); dptr = nbh->b_data + sizeof(struct allocExtDesc);
memcpy(dptr, sptr, adsize); memcpy(dptr, sptr, adsize);
epos->offset = sizeof(struct allocExtDesc) + adsize; epos->offset = sizeof(struct allocExtDesc) + adsize;
} } else {
else
{
loffset = epos->offset + adsize; loffset = epos->offset + adsize;
aed->lengthAllocDescs = cpu_to_le32(0); aed->lengthAllocDescs = cpu_to_le32(0);
sptr = ptr; sptr = ptr;
epos->offset = sizeof(struct allocExtDesc); epos->offset = sizeof(struct allocExtDesc);
if (epos->bh) if (epos->bh) {
{
aed = (struct allocExtDesc *)epos->bh->b_data; aed = (struct allocExtDesc *)epos->bh->b_data;
aed->lengthAllocDescs = aed->lengthAllocDescs =
cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize); cpu_to_le32(le32_to_cpu
} (aed->lengthAllocDescs) +
else adsize);
{ } else {
UDF_I_LENALLOC(inode) += adsize; UDF_I_LENALLOC(inode) += adsize;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} }
...@@ -1803,80 +1828,81 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, ...@@ -1803,80 +1828,81 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
else else
udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1, udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
epos->block.logicalBlockNum, sizeof(tag)); epos->block.logicalBlockNum, sizeof(tag));
switch (UDF_I_ALLOCTYPE(inode)) switch (UDF_I_ALLOCTYPE(inode)) {
{
case ICBTAG_FLAG_AD_SHORT: case ICBTAG_FLAG_AD_SHORT:
{ {
sad = (short_ad *)sptr; sad = (short_ad *) sptr;
sad->extLength = cpu_to_le32( sad->extLength =
EXT_NEXT_EXTENT_ALLOCDECS | cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
inode->i_sb->s_blocksize); inode->i_sb->s_blocksize);
sad->extPosition = cpu_to_le32(epos->block.logicalBlockNum); sad->extPosition =
cpu_to_le32(epos->block.logicalBlockNum);
break; break;
} }
case ICBTAG_FLAG_AD_LONG: case ICBTAG_FLAG_AD_LONG:
{ {
lad = (long_ad *)sptr; lad = (long_ad *) sptr;
lad->extLength = cpu_to_le32( lad->extLength =
EXT_NEXT_EXTENT_ALLOCDECS | cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
inode->i_sb->s_blocksize); inode->i_sb->s_blocksize);
lad->extLocation = cpu_to_lelb(epos->block); lad->extLocation = cpu_to_lelb(epos->block);
memset(lad->impUse, 0x00, sizeof(lad->impUse)); memset(lad->impUse, 0x00, sizeof(lad->impUse));
break; break;
} }
} }
if (epos->bh) if (epos->bh) {
{ if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
udf_update_tag(epos->bh->b_data, loffset); udf_update_tag(epos->bh->b_data, loffset);
else else
udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc)); udf_update_tag(epos->bh->b_data,
sizeof(struct allocExtDesc));
mark_buffer_dirty_inode(epos->bh, inode); mark_buffer_dirty_inode(epos->bh, inode);
brelse(epos->bh); brelse(epos->bh);
} } else
else
mark_inode_dirty(inode); mark_inode_dirty(inode);
epos->bh = nbh; epos->bh = nbh;
} }
etype = udf_write_aext(inode, epos, eloc, elen, inc); etype = udf_write_aext(inode, epos, eloc, elen, inc);
if (!epos->bh) if (!epos->bh) {
{
UDF_I_LENALLOC(inode) += adsize; UDF_I_LENALLOC(inode) += adsize;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} } else {
else
{
aed = (struct allocExtDesc *)epos->bh->b_data; aed = (struct allocExtDesc *)epos->bh->b_data;
aed->lengthAllocDescs = aed->lengthAllocDescs =
cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize); cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize)); || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
udf_update_tag(epos->bh->b_data,
epos->offset + (inc ? 0 : adsize));
else else
udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc)); udf_update_tag(epos->bh->b_data,
sizeof(struct allocExtDesc));
mark_buffer_dirty_inode(epos->bh, inode); mark_buffer_dirty_inode(epos->bh, inode);
} }
return etype; return etype;
} }
int8_t udf_write_aext(struct inode *inode, struct extent_position *epos, int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,
kernel_lb_addr eloc, uint32_t elen, int inc) kernel_lb_addr eloc, uint32_t elen, int inc)
{ {
int adsize; int adsize;
uint8_t *ptr; uint8_t *ptr;
if (!epos->bh) if (!epos->bh)
ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode); ptr =
UDF_I_DATA(inode) + epos->offset -
udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
else else
ptr = epos->bh->b_data + epos->offset; ptr = epos->bh->b_data + epos->offset;
switch (UDF_I_ALLOCTYPE(inode)) switch (UDF_I_ALLOCTYPE(inode)) {
{
case ICBTAG_FLAG_AD_SHORT: case ICBTAG_FLAG_AD_SHORT:
{ {
short_ad *sad = (short_ad *)ptr; short_ad *sad = (short_ad *) ptr;
sad->extLength = cpu_to_le32(elen); sad->extLength = cpu_to_le32(elen);
sad->extPosition = cpu_to_le32(eloc.logicalBlockNum); sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
adsize = sizeof(short_ad); adsize = sizeof(short_ad);
...@@ -1884,7 +1910,7 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos, ...@@ -1884,7 +1910,7 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
} }
case ICBTAG_FLAG_AD_LONG: case ICBTAG_FLAG_AD_LONG:
{ {
long_ad *lad = (long_ad *)ptr; long_ad *lad = (long_ad *) ptr;
lad->extLength = cpu_to_le32(elen); lad->extLength = cpu_to_le32(elen);
lad->extLocation = cpu_to_lelb(eloc); lad->extLocation = cpu_to_lelb(eloc);
memset(lad->impUse, 0x00, sizeof(lad->impUse)); memset(lad->impUse, 0x00, sizeof(lad->impUse));
...@@ -1895,17 +1921,17 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos, ...@@ -1895,17 +1921,17 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
return -1; return -1;
} }
if (epos->bh) if (epos->bh) {
{ if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) {
{ struct allocExtDesc *aed =
struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data; (struct allocExtDesc *)epos->bh->b_data;
udf_update_tag(epos->bh->b_data, udf_update_tag(epos->bh->b_data,
le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc)); le32_to_cpu(aed->lengthAllocDescs) +
sizeof(struct allocExtDesc));
} }
mark_buffer_dirty_inode(epos->bh, inode); mark_buffer_dirty_inode(epos->bh, inode);
} } else
else
mark_inode_dirty(inode); mark_inode_dirty(inode);
if (inc) if (inc)
...@@ -1913,21 +1939,24 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos, ...@@ -1913,21 +1939,24 @@ int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
return (elen >> 30); return (elen >> 30);
} }
int8_t udf_next_aext(struct inode *inode, struct extent_position *epos, int8_t udf_next_aext(struct inode * inode, struct extent_position * epos,
kernel_lb_addr *eloc, uint32_t *elen, int inc) kernel_lb_addr * eloc, uint32_t * elen, int inc)
{ {
int8_t etype; int8_t etype;
while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) == while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
(EXT_NEXT_EXTENT_ALLOCDECS >> 30)) (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
{
epos->block = *eloc; epos->block = *eloc;
epos->offset = sizeof(struct allocExtDesc); epos->offset = sizeof(struct allocExtDesc);
brelse(epos->bh); brelse(epos->bh);
if (!(epos->bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, epos->block, 0)))) if (!
{ (epos->bh =
udf_tread(inode->i_sb,
udf_get_lb_pblock(inode->i_sb, epos->block,
0)))) {
udf_debug("reading block %d failed!\n", udf_debug("reading block %d failed!\n",
udf_get_lb_pblock(inode->i_sb, epos->block, 0)); udf_get_lb_pblock(inode->i_sb, epos->block,
0));
return -1; return -1;
} }
} }
...@@ -1935,58 +1964,71 @@ int8_t udf_next_aext(struct inode *inode, struct extent_position *epos, ...@@ -1935,58 +1964,71 @@ int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
return etype; return etype;
} }
int8_t udf_current_aext(struct inode *inode, struct extent_position *epos, int8_t udf_current_aext(struct inode * inode, struct extent_position * epos,
kernel_lb_addr *eloc, uint32_t *elen, int inc) kernel_lb_addr * eloc, uint32_t * elen, int inc)
{ {
int alen; int alen;
int8_t etype; int8_t etype;
uint8_t *ptr; uint8_t *ptr;
if (!epos->bh) if (!epos->bh) {
{
if (!epos->offset) if (!epos->offset)
epos->offset = udf_file_entry_alloc_offset(inode); epos->offset = udf_file_entry_alloc_offset(inode);
ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode); ptr =
alen = udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode); UDF_I_DATA(inode) + epos->offset -
} udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
else alen =
{ udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode);
} else {
if (!epos->offset) if (!epos->offset)
epos->offset = sizeof(struct allocExtDesc); epos->offset = sizeof(struct allocExtDesc);
ptr = epos->bh->b_data + epos->offset; ptr = epos->bh->b_data + epos->offset;
alen = sizeof(struct allocExtDesc) + le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->lengthAllocDescs); alen =
sizeof(struct allocExtDesc) +
le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
lengthAllocDescs);
} }
switch (UDF_I_ALLOCTYPE(inode)) switch (UDF_I_ALLOCTYPE(inode)) {
{
case ICBTAG_FLAG_AD_SHORT: case ICBTAG_FLAG_AD_SHORT:
{ {
short_ad *sad; short_ad *sad;
if (!(sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc))) if (!
(sad =
udf_get_fileshortad(ptr, alen, &epos->offset,
inc)))
return -1; return -1;
etype = le32_to_cpu(sad->extLength) >> 30; etype = le32_to_cpu(sad->extLength) >> 30;
eloc->logicalBlockNum = le32_to_cpu(sad->extPosition); eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum; eloc->partitionReferenceNum =
*elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK; UDF_I_LOCATION(inode).partitionReferenceNum;
*elen =
le32_to_cpu(sad->
extLength) & UDF_EXTENT_LENGTH_MASK;
break; break;
} }
case ICBTAG_FLAG_AD_LONG: case ICBTAG_FLAG_AD_LONG:
{ {
long_ad *lad; long_ad *lad;
if (!(lad = udf_get_filelongad(ptr, alen, &epos->offset, inc))) if (!
(lad =
udf_get_filelongad(ptr, alen, &epos->offset, inc)))
return -1; return -1;
etype = le32_to_cpu(lad->extLength) >> 30; etype = le32_to_cpu(lad->extLength) >> 30;
*eloc = lelb_to_cpu(lad->extLocation); *eloc = lelb_to_cpu(lad->extLocation);
*elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK; *elen =
le32_to_cpu(lad->
extLength) & UDF_EXTENT_LENGTH_MASK;
break; break;
} }
default: default:
{ {
udf_debug("alloc_type = %d unsupported\n", UDF_I_ALLOCTYPE(inode)); udf_debug("alloc_type = %d unsupported\n",
UDF_I_ALLOCTYPE(inode));
return -1; return -1;
} }
} }
...@@ -2005,8 +2047,7 @@ udf_insert_aext(struct inode *inode, struct extent_position epos, ...@@ -2005,8 +2047,7 @@ udf_insert_aext(struct inode *inode, struct extent_position epos,
if (epos.bh) if (epos.bh)
get_bh(epos.bh); get_bh(epos.bh);
while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
{
udf_write_aext(inode, &epos, neloc, nelen, 1); udf_write_aext(inode, &epos, neloc, nelen, 1);
neloc = oeloc; neloc = oeloc;
...@@ -2017,7 +2058,7 @@ udf_insert_aext(struct inode *inode, struct extent_position epos, ...@@ -2017,7 +2058,7 @@ udf_insert_aext(struct inode *inode, struct extent_position epos,
return (nelen >> 30); return (nelen >> 30);
} }
int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
kernel_lb_addr eloc, uint32_t elen) kernel_lb_addr eloc, uint32_t elen)
{ {
struct extent_position oepos; struct extent_position oepos;
...@@ -2025,8 +2066,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, ...@@ -2025,8 +2066,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
int8_t etype; int8_t etype;
struct allocExtDesc *aed; struct allocExtDesc *aed;
if (epos.bh) if (epos.bh) {
{
get_bh(epos.bh); get_bh(epos.bh);
get_bh(epos.bh); get_bh(epos.bh);
} }
...@@ -2042,11 +2082,9 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, ...@@ -2042,11 +2082,9 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1) if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
return -1; return -1;
while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
{
udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1); udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1);
if (oepos.bh != epos.bh) if (oepos.bh != epos.bh) {
{
oepos.block = epos.block; oepos.block = epos.block;
brelse(oepos.bh); brelse(oepos.bh);
get_bh(epos.bh); get_bh(epos.bh);
...@@ -2057,45 +2095,44 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, ...@@ -2057,45 +2095,44 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
memset(&eloc, 0x00, sizeof(kernel_lb_addr)); memset(&eloc, 0x00, sizeof(kernel_lb_addr));
elen = 0; elen = 0;
if (epos.bh != oepos.bh) if (epos.bh != oepos.bh) {
{
udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1); udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1);
udf_write_aext(inode, &oepos, eloc, elen, 1); udf_write_aext(inode, &oepos, eloc, elen, 1);
udf_write_aext(inode, &oepos, eloc, elen, 1); udf_write_aext(inode, &oepos, eloc, elen, 1);
if (!oepos.bh) if (!oepos.bh) {
{
UDF_I_LENALLOC(inode) -= (adsize * 2); UDF_I_LENALLOC(inode) -= (adsize * 2);
mark_inode_dirty(inode); mark_inode_dirty(inode);
} } else {
else
{
aed = (struct allocExtDesc *)oepos.bh->b_data; aed = (struct allocExtDesc *)oepos.bh->b_data;
aed->lengthAllocDescs = aed->lengthAllocDescs =
cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2*adsize)); cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) (2 * adsize));
udf_update_tag(oepos.bh->b_data, oepos.offset - (2*adsize)); if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
|| UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
udf_update_tag(oepos.bh->b_data,
oepos.offset - (2 * adsize));
else else
udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc)); udf_update_tag(oepos.bh->b_data,
sizeof(struct allocExtDesc));
mark_buffer_dirty_inode(oepos.bh, inode); mark_buffer_dirty_inode(oepos.bh, inode);
} }
} } else {
else
{
udf_write_aext(inode, &oepos, eloc, elen, 1); udf_write_aext(inode, &oepos, eloc, elen, 1);
if (!oepos.bh) if (!oepos.bh) {
{
UDF_I_LENALLOC(inode) -= adsize; UDF_I_LENALLOC(inode) -= adsize;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} } else {
else
{
aed = (struct allocExtDesc *)oepos.bh->b_data; aed = (struct allocExtDesc *)oepos.bh->b_data;
aed->lengthAllocDescs = aed->lengthAllocDescs =
cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize); cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) adsize);
udf_update_tag(oepos.bh->b_data, epos.offset - adsize); if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
|| UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
udf_update_tag(oepos.bh->b_data,
epos.offset - adsize);
else else
udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc)); udf_update_tag(oepos.bh->b_data,
sizeof(struct allocExtDesc));
mark_buffer_dirty_inode(oepos.bh, inode); mark_buffer_dirty_inode(oepos.bh, inode);
} }
} }
...@@ -2105,14 +2142,15 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, ...@@ -2105,14 +2142,15 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
return (elen >> 30); return (elen >> 30);
} }
int8_t inode_bmap(struct inode *inode, sector_t block, struct extent_position *pos, int8_t inode_bmap(struct inode * inode, sector_t block,
kernel_lb_addr *eloc, uint32_t *elen, sector_t *offset) struct extent_position * pos, kernel_lb_addr * eloc,
uint32_t * elen, sector_t * offset)
{ {
loff_t lbcount = 0, bcount = (loff_t)block << inode->i_sb->s_blocksize_bits; loff_t lbcount = 0, bcount =
(loff_t) block << inode->i_sb->s_blocksize_bits;
int8_t etype; int8_t etype;
if (block < 0) if (block < 0) {
{
printk(KERN_ERR "udf: inode_bmap: block < 0\n"); printk(KERN_ERR "udf: inode_bmap: block < 0\n");
return -1; return -1;
} }
...@@ -2122,11 +2160,10 @@ int8_t inode_bmap(struct inode *inode, sector_t block, struct extent_position *p ...@@ -2122,11 +2160,10 @@ int8_t inode_bmap(struct inode *inode, sector_t block, struct extent_position *p
pos->bh = NULL; pos->bh = NULL;
*elen = 0; *elen = 0;
do do {
{ if ((etype = udf_next_aext(inode, pos, eloc, elen, 1)) == -1) {
if ((etype = udf_next_aext(inode, pos, eloc, elen, 1)) == -1) *offset =
{ (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
*offset = (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
UDF_I_LENEXTENTS(inode) = lbcount; UDF_I_LENEXTENTS(inode) = lbcount;
return -1; return -1;
} }
...@@ -2143,12 +2180,13 @@ long udf_block_map(struct inode *inode, sector_t block) ...@@ -2143,12 +2180,13 @@ long udf_block_map(struct inode *inode, sector_t block)
kernel_lb_addr eloc; kernel_lb_addr eloc;
uint32_t elen; uint32_t elen;
sector_t offset; sector_t offset;
struct extent_position epos = { NULL, 0, { 0, 0}}; struct extent_position epos = { NULL, 0, {0, 0} };
int ret; int ret;
lock_kernel(); lock_kernel();
if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
(EXT_RECORDED_ALLOCATED >> 30))
ret = udf_get_lb_pblock(inode->i_sb, eloc, offset); ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
else else
ret = 0; ret = 0;
......
fs/udf/lowlevel.c
View file @ cb00ea35
...@@ -26,43 +26,38 @@ ...@@ -26,43 +26,38 @@
#include <linux/udf_fs.h> #include <linux/udf_fs.h>
#include "udf_sb.h" #include "udf_sb.h"
unsigned int unsigned int udf_get_last_session(struct super_block *sb)
udf_get_last_session(struct super_block *sb)
{ {
struct cdrom_multisession ms_info; struct cdrom_multisession ms_info;
unsigned int vol_desc_start; unsigned int vol_desc_start;
struct block_device *bdev = sb->s_bdev; struct block_device *bdev = sb->s_bdev;
int i; int i;
vol_desc_start=0; vol_desc_start = 0;
ms_info.addr_format=CDROM_LBA; ms_info.addr_format = CDROM_LBA;
i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info); i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long)&ms_info);
#define WE_OBEY_THE_WRITTEN_STANDARDS 1 #define WE_OBEY_THE_WRITTEN_STANDARDS 1
if (i == 0) if (i == 0) {
{
udf_debug("XA disk: %s, vol_desc_start=%d\n", udf_debug("XA disk: %s, vol_desc_start=%d\n",
(ms_info.xa_flag ? "yes" : "no"), ms_info.addr.lba); (ms_info.xa_flag ? "yes" : "no"), ms_info.addr.lba);
#if WE_OBEY_THE_WRITTEN_STANDARDS #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 #endif
vol_desc_start = ms_info.addr.lba; vol_desc_start = ms_info.addr.lba;
} } else {
else
{
udf_debug("CDROMMULTISESSION not supported: rc=%d\n", i); udf_debug("CDROMMULTISESSION not supported: rc=%d\n", i);
} }
return vol_desc_start; return vol_desc_start;
} }
unsigned long unsigned long udf_get_last_block(struct super_block *sb)
udf_get_last_block(struct super_block *sb)
{ {
struct block_device *bdev = sb->s_bdev; struct block_device *bdev = sb->s_bdev;
unsigned long lblock = 0; 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; lblock = bdev->bd_inode->i_size >> sb->s_blocksize_bits;
if (lblock) if (lblock)
......
fs/udf/misc.c
View file @ cb00ea35
...@@ -29,8 +29,7 @@ ...@@ -29,8 +29,7 @@
#include "udf_i.h" #include "udf_i.h"
#include "udf_sb.h" #include "udf_sb.h"
struct buffer_head * struct buffer_head *udf_tgetblk(struct super_block *sb, int block)
udf_tgetblk(struct super_block *sb, int block)
{ {
if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV)) if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
return sb_getblk(sb, udf_fixed_to_variable(block)); return sb_getblk(sb, udf_fixed_to_variable(block));
...@@ -38,8 +37,7 @@ udf_tgetblk(struct super_block *sb, int block) ...@@ -38,8 +37,7 @@ udf_tgetblk(struct super_block *sb, int block)
return sb_getblk(sb, block); return sb_getblk(sb, block);
} }
struct buffer_head * struct buffer_head *udf_tread(struct super_block *sb, int block)
udf_tread(struct super_block *sb, int block)
{ {
if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV)) if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
return sb_bread(sb, udf_fixed_to_variable(block)); return sb_bread(sb, udf_fixed_to_variable(block));
...@@ -47,9 +45,8 @@ udf_tread(struct super_block *sb, int block) ...@@ -47,9 +45,8 @@ udf_tread(struct super_block *sb, int block)
return sb_bread(sb, block); return sb_bread(sb, block);
} }
struct genericFormat * struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type, uint32_t type, uint8_t loc)
uint8_t loc)
{ {
uint8_t *ea = NULL, *ad = NULL; uint8_t *ea = NULL, *ad = NULL;
int offset; int offset;
...@@ -59,8 +56,7 @@ udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type, ...@@ -59,8 +56,7 @@ udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type,
ea = UDF_I_DATA(inode); ea = UDF_I_DATA(inode);
if (UDF_I_LENEATTR(inode)) if (UDF_I_LENEATTR(inode))
ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode); ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
else else {
{
ad = ea; ad = ea;
size += sizeof(struct extendedAttrHeaderDesc); size += sizeof(struct extendedAttrHeaderDesc);
} }
...@@ -70,67 +66,66 @@ udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type, ...@@ -70,67 +66,66 @@ udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type,
/* TODO - Check for FreeEASpace */ /* TODO - Check for FreeEASpace */
if (loc & 0x01 && offset >= size) if (loc & 0x01 && offset >= size) {
{
struct extendedAttrHeaderDesc *eahd; struct extendedAttrHeaderDesc *eahd;
eahd = (struct extendedAttrHeaderDesc *)ea; eahd = (struct extendedAttrHeaderDesc *)ea;
if (UDF_I_LENALLOC(inode)) if (UDF_I_LENALLOC(inode)) {
{
memmove(&ad[size], ad, UDF_I_LENALLOC(inode)); memmove(&ad[size], ad, UDF_I_LENALLOC(inode));
} }
if (UDF_I_LENEATTR(inode)) if (UDF_I_LENEATTR(inode)) {
{
/* check checksum/crc */ /* check checksum/crc */
if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD || if (le16_to_cpu(eahd->descTag.tagIdent) !=
le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) TAG_IDENT_EAHD
{ || le32_to_cpu(eahd->descTag.tagLocation) !=
UDF_I_LOCATION(inode).logicalBlockNum) {
return NULL; return NULL;
} }
} } else {
else
{
size -= sizeof(struct extendedAttrHeaderDesc); 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); eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200) if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
eahd->descTag.descVersion = cpu_to_le16(3); eahd->descTag.descVersion = cpu_to_le16(3);
else else
eahd->descTag.descVersion = cpu_to_le16(2); eahd->descTag.descVersion = cpu_to_le16(2);
eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb)); eahd->descTag.tagSerialNum =
eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum); 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->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF); eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
} }
offset = UDF_I_LENEATTR(inode); offset = UDF_I_LENEATTR(inode);
if (type < 2048) if (type < 2048) {
{ if (le32_to_cpu(eahd->appAttrLocation) <
if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) UDF_I_LENEATTR(inode)) {
{ uint32_t aal =
uint32_t aal = le32_to_cpu(eahd->appAttrLocation); le32_to_cpu(eahd->appAttrLocation);
memmove(&ea[offset - aal + size], memmove(&ea[offset - aal + size], &ea[aal],
&ea[aal], offset - aal); offset - aal);
offset -= aal; offset -= aal;
eahd->appAttrLocation = cpu_to_le32(aal + size); eahd->appAttrLocation = cpu_to_le32(aal + size);
} }
if (le32_to_cpu(eahd->impAttrLocation) < UDF_I_LENEATTR(inode)) if (le32_to_cpu(eahd->impAttrLocation) <
{ UDF_I_LENEATTR(inode)) {
uint32_t ial = le32_to_cpu(eahd->impAttrLocation); uint32_t ial =
memmove(&ea[offset - ial + size], le32_to_cpu(eahd->impAttrLocation);
&ea[ial], offset - ial); memmove(&ea[offset - ial + size], &ea[ial],
offset - ial);
offset -= ial; offset -= ial;
eahd->impAttrLocation = cpu_to_le32(ial + size); eahd->impAttrLocation = cpu_to_le32(ial + size);
} }
} } else if (type < 65536) {
else if (type < 65536) if (le32_to_cpu(eahd->appAttrLocation) <
{ UDF_I_LENEATTR(inode)) {
if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) uint32_t aal =
{ le32_to_cpu(eahd->appAttrLocation);
uint32_t aal = le32_to_cpu(eahd->appAttrLocation); memmove(&ea[offset - aal + size], &ea[aal],
memmove(&ea[offset - aal + size], offset - aal);
&ea[aal], offset - aal);
offset -= aal; offset -= aal;
eahd->appAttrLocation = cpu_to_le32(aal + size); eahd->appAttrLocation = cpu_to_le32(aal + size);
} }
...@@ -138,22 +133,23 @@ udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type, ...@@ -138,22 +133,23 @@ udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type,
/* rewrite CRC + checksum of eahd */ /* rewrite CRC + checksum of eahd */
crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag); crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag);
eahd->descTag.descCRCLength = cpu_to_le16(crclen); 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; eahd->descTag.tagChecksum = 0;
for (i=0; i<16; i++) for (i = 0; i < 16; i++)
if (i != 4) if (i != 4)
eahd->descTag.tagChecksum += ((uint8_t *)&(eahd->descTag))[i]; eahd->descTag.tagChecksum +=
((uint8_t *) & (eahd->descTag))[i];
UDF_I_LENEATTR(inode) += size; UDF_I_LENEATTR(inode) += size;
return (struct genericFormat *)&ea[offset]; return (struct genericFormat *)&ea[offset];
} }
if (loc & 0x02) if (loc & 0x02) {
{
} }
return NULL; return NULL;
} }
struct genericFormat * struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype) uint8_t subtype)
{ {
struct genericFormat *gaf; struct genericFormat *gaf;
uint8_t *ea = NULL; uint8_t *ea = NULL;
...@@ -161,15 +157,14 @@ udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype) ...@@ -161,15 +157,14 @@ udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype)
ea = UDF_I_DATA(inode); ea = UDF_I_DATA(inode);
if (UDF_I_LENEATTR(inode)) if (UDF_I_LENEATTR(inode)) {
{
struct extendedAttrHeaderDesc *eahd; struct extendedAttrHeaderDesc *eahd;
eahd = (struct extendedAttrHeaderDesc *)ea; eahd = (struct extendedAttrHeaderDesc *)ea;
/* check checksum/crc */ /* check checksum/crc */
if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD || 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; return NULL;
} }
...@@ -180,10 +175,10 @@ udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype) ...@@ -180,10 +175,10 @@ udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype)
else else
offset = le32_to_cpu(eahd->appAttrLocation); offset = le32_to_cpu(eahd->appAttrLocation);
while (offset < UDF_I_LENEATTR(inode)) while (offset < UDF_I_LENEATTR(inode)) {
{
gaf = (struct genericFormat *)&ea[offset]; 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; return gaf;
else else
offset += le32_to_cpu(gaf->attrLength); offset += le32_to_cpu(gaf->attrLength);
...@@ -202,8 +197,8 @@ udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype) ...@@ -202,8 +197,8 @@ udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype)
* July 1, 1997 - Andrew E. Mileski * July 1, 1997 - Andrew E. Mileski
* Written, tested, and released. * Written, tested, and released.
*/ */
struct buffer_head * struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint16_t *ident) uint32_t location, uint16_t * ident)
{ {
tag *tag_p; tag *tag_p;
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
...@@ -215,29 +210,29 @@ udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint1 ...@@ -215,29 +210,29 @@ udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint1
return NULL; return NULL;
bh = udf_tread(sb, block + UDF_SB_SESSION(sb)); bh = udf_tread(sb, block + UDF_SB_SESSION(sb));
if (!bh) if (!bh) {
{ udf_debug("block=%d, location=%d: read failed\n",
udf_debug("block=%d, location=%d: read failed\n", block + UDF_SB_SESSION(sb), location); block + UDF_SB_SESSION(sb), location);
return NULL; return NULL;
} }
tag_p = (tag *)(bh->b_data); tag_p = (tag *) (bh->b_data);
*ident = le16_to_cpu(tag_p->tagIdent); *ident = le16_to_cpu(tag_p->tagIdent);
if ( location != le32_to_cpu(tag_p->tagLocation) ) if (location != le32_to_cpu(tag_p->tagLocation)) {
{
udf_debug("location mismatch block %u, tag %u != %u\n", 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; goto error_out;
} }
/* Verify the tag checksum */ /* Verify the tag checksum */
checksum = 0U; checksum = 0U;
for (i = 0; i < 4; i++) 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++) 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) { if (checksum != tag_p->tagChecksum) {
printk(KERN_ERR "udf: tag checksum failed block %d\n", block); printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
goto error_out; goto error_out;
...@@ -245,8 +240,7 @@ udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint1 ...@@ -245,8 +240,7 @@ udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint1
/* Verify the tag version */ /* Verify the tag version */
if (le16_to_cpu(tag_p->descVersion) != 0x0002U && if (le16_to_cpu(tag_p->descVersion) != 0x0002U &&
le16_to_cpu(tag_p->descVersion) != 0x0003U) le16_to_cpu(tag_p->descVersion) != 0x0003U) {
{
udf_debug("tag version 0x%04x != 0x0002 || 0x0003 block %d\n", udf_debug("tag version 0x%04x != 0x0002 || 0x0003 block %d\n",
le16_to_cpu(tag_p->descVersion), block); le16_to_cpu(tag_p->descVersion), block);
goto error_out; goto error_out;
...@@ -255,20 +249,22 @@ udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint1 ...@@ -255,20 +249,22 @@ udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint1
/* Verify the descriptor CRC */ /* Verify the descriptor CRC */
if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize || 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->descCRC) == udf_crc(bh->b_data + sizeof(tag),
le16_to_cpu(tag_p->descCRCLength), 0)) le16_to_cpu(tag_p->
{ descCRCLength),
0)) {
return bh; return bh;
} }
udf_debug("Crc failure block %d: crc = %d, crclen = %d\n", 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)); block + UDF_SB_SESSION(sb), le16_to_cpu(tag_p->descCRC),
le16_to_cpu(tag_p->descCRCLength));
error_out: error_out:
brelse(bh); brelse(bh);
return NULL; return NULL;
} }
struct buffer_head * struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc, uint32_t offset, uint16_t *ident) uint32_t offset, uint16_t * ident)
{ {
return udf_read_tagged(sb, udf_get_lb_pblock(sb, loc, offset), return udf_read_tagged(sb, udf_get_lb_pblock(sb, loc, offset),
loc.logicalBlockNum + offset, ident); loc.logicalBlockNum + offset, ident);
...@@ -276,7 +272,7 @@ udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc, uint32_t offset, ui ...@@ -276,7 +272,7 @@ udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc, uint32_t offset, ui
void udf_update_tag(char *data, int length) void udf_update_tag(char *data, int length)
{ {
tag *tptr = (tag *)data; tag *tptr = (tag *) data;
int i; int i;
length -= sizeof(tag); length -= sizeof(tag);
...@@ -285,15 +281,15 @@ void udf_update_tag(char *data, int length) ...@@ -285,15 +281,15 @@ void udf_update_tag(char *data, int length)
tptr->descCRCLength = cpu_to_le16(length); tptr->descCRCLength = cpu_to_le16(length);
tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0)); tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0));
for (i=0; i<16; i++) for (i = 0; i < 16; i++)
if (i != 4) 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, void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
uint32_t loc, int length) uint32_t loc, int length)
{ {
tag *tptr = (tag *)data; tag *tptr = (tag *) data;
tptr->tagIdent = cpu_to_le16(ident); tptr->tagIdent = cpu_to_le16(ident);
tptr->descVersion = cpu_to_le16(version); tptr->descVersion = cpu_to_le16(version);
tptr->tagSerialNum = cpu_to_le16(snum); tptr->tagSerialNum = cpu_to_le16(snum);
......
fs/udf/namei.c
View file @ cb00ea35
...@@ -32,7 +32,8 @@ ...@@ -32,7 +32,8 @@
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/sched.h> #include <linux/sched.h>
static inline int udf_match(int len1, const char *name1, int len2, const char *name2) static inline int udf_match(int len1, const char *name1, int len2,
const char *name2)
{ {
if (len1 != len2) if (len1 != len2)
return 0; return 0;
...@@ -41,7 +42,7 @@ static inline int udf_match(int len1, const char *name1, int len2, const char *n ...@@ -41,7 +42,7 @@ static inline int udf_match(int len1, const char *name1, int len2, const char *n
int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi, int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
struct fileIdentDesc *sfi, struct udf_fileident_bh *fibh, struct fileIdentDesc *sfi, struct udf_fileident_bh *fibh,
uint8_t *impuse, uint8_t *fileident) uint8_t * impuse, uint8_t * fileident)
{ {
uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag); uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag);
uint16_t crc; uint16_t crc;
...@@ -59,83 +60,86 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi, ...@@ -59,83 +60,86 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
offset = fibh->soffset + sizeof(struct fileIdentDesc); offset = fibh->soffset + sizeof(struct fileIdentDesc);
if (impuse) if (impuse) {
{
if (adinicb || (offset + liu < 0)) if (adinicb || (offset + liu < 0))
memcpy((uint8_t *)sfi->impUse, impuse, liu); memcpy((uint8_t *) sfi->impUse, impuse, liu);
else if (offset >= 0) else if (offset >= 0)
memcpy(fibh->ebh->b_data + offset, impuse, liu); memcpy(fibh->ebh->b_data + offset, impuse, liu);
else else {
{ memcpy((uint8_t *) sfi->impUse, impuse, -offset);
memcpy((uint8_t *)sfi->impUse, impuse, -offset); memcpy(fibh->ebh->b_data, impuse - offset,
memcpy(fibh->ebh->b_data, impuse - offset, liu + offset); liu + offset);
} }
} }
offset += liu; offset += liu;
if (fileident) if (fileident) {
{
if (adinicb || (offset + lfi < 0)) if (adinicb || (offset + lfi < 0))
memcpy((uint8_t *)sfi->fileIdent + liu, fileident, lfi); memcpy((uint8_t *) sfi->fileIdent + liu, fileident,
lfi);
else if (offset >= 0) else if (offset >= 0)
memcpy(fibh->ebh->b_data + offset, fileident, lfi); memcpy(fibh->ebh->b_data + offset, fileident, lfi);
else else {
{ memcpy((uint8_t *) sfi->fileIdent + liu, fileident,
memcpy((uint8_t *)sfi->fileIdent + liu, fileident, -offset); -offset);
memcpy(fibh->ebh->b_data, fileident - offset, lfi + offset); memcpy(fibh->ebh->b_data, fileident - offset,
lfi + offset);
} }
} }
offset += lfi; offset += lfi;
if (adinicb || (offset + padlen < 0)) if (adinicb || (offset + padlen < 0))
memset((uint8_t *)sfi->padding + liu + lfi, 0x00, padlen); memset((uint8_t *) sfi->padding + liu + lfi, 0x00, padlen);
else if (offset >= 0) else if (offset >= 0)
memset(fibh->ebh->b_data + offset, 0x00, padlen); memset(fibh->ebh->b_data + offset, 0x00, padlen);
else else {
{ memset((uint8_t *) sfi->padding + liu + lfi, 0x00, -offset);
memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset);
memset(fibh->ebh->b_data, 0x00, padlen + offset); memset(fibh->ebh->b_data, 0x00, padlen + offset);
} }
crc = udf_crc((uint8_t *)cfi + sizeof(tag), sizeof(struct fileIdentDesc) - crc =
sizeof(tag), 0); udf_crc((uint8_t *) cfi + sizeof(tag),
sizeof(struct fileIdentDesc) - sizeof(tag), 0);
if (fibh->sbh == fibh->ebh) if (fibh->sbh == fibh->ebh)
crc = udf_crc((uint8_t *)sfi->impUse, crc = udf_crc((uint8_t *) sfi->impUse,
crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc); crclen + sizeof(tag) -
sizeof(struct fileIdentDesc), crc);
else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) else if (sizeof(struct fileIdentDesc) >= -fibh->soffset)
crc = udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) + fibh->soffset, crc =
crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc); udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) +
else fibh->soffset,
{ crclen + sizeof(tag) - sizeof(struct fileIdentDesc),
crc = udf_crc((uint8_t *)sfi->impUse, crc);
-fibh->soffset - 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); crc = udf_crc(fibh->ebh->b_data, fibh->eoffset, crc);
} }
cfi->descTag.descCRC = cpu_to_le16(crc); cfi->descTag.descCRC = cpu_to_le16(crc);
cfi->descTag.descCRCLength = cpu_to_le16(crclen); cfi->descTag.descCRCLength = cpu_to_le16(crclen);
for (i=0; i<16; i++) for (i = 0; i < 16; i++)
if (i != 4) if (i != 4)
checksum += ((uint8_t *)&cfi->descTag)[i]; checksum += ((uint8_t *) & cfi->descTag)[i];
cfi->descTag.tagChecksum = checksum; cfi->descTag.tagChecksum = checksum;
if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset))
memcpy((uint8_t *)sfi, (uint8_t *)cfi, sizeof(struct fileIdentDesc)); memcpy((uint8_t *) sfi, (uint8_t *) cfi,
else sizeof(struct fileIdentDesc));
{ else {
memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset); memcpy((uint8_t *) sfi, (uint8_t *) cfi, -fibh->soffset);
memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset, memcpy(fibh->ebh->b_data, (uint8_t *) cfi - fibh->soffset,
sizeof(struct fileIdentDesc) + fibh->soffset); sizeof(struct fileIdentDesc) + fibh->soffset);
} }
if (adinicb) if (adinicb)
mark_inode_dirty(inode); mark_inode_dirty(inode);
else else {
{
if (fibh->sbh != fibh->ebh) if (fibh->sbh != fibh->ebh)
mark_buffer_dirty_inode(fibh->ebh, inode); mark_buffer_dirty_inode(fibh->ebh, inode);
mark_buffer_dirty_inode(fibh->sbh, inode); mark_buffer_dirty_inode(fibh->sbh, inode);
...@@ -143,12 +147,12 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi, ...@@ -143,12 +147,12 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
return 0; return 0;
} }
static struct fileIdentDesc * static struct fileIdentDesc *udf_find_entry(struct inode *dir,
udf_find_entry(struct inode *dir, struct dentry *dentry, struct dentry *dentry,
struct udf_fileident_bh *fibh, struct udf_fileident_bh *fibh,
struct fileIdentDesc *cfi) struct fileIdentDesc *cfi)
{ {
struct fileIdentDesc *fi=NULL; struct fileIdentDesc *fi = NULL;
loff_t f_pos; loff_t f_pos;
int block, flen; int block, flen;
char fname[UDF_NAME_LEN]; char fname[UDF_NAME_LEN];
...@@ -159,46 +163,41 @@ udf_find_entry(struct inode *dir, struct dentry *dentry, ...@@ -159,46 +163,41 @@ udf_find_entry(struct inode *dir, struct dentry *dentry,
kernel_lb_addr eloc; kernel_lb_addr eloc;
uint32_t elen; uint32_t elen;
sector_t offset; sector_t offset;
struct extent_position epos = { NULL, 0, { 0, 0}}; struct extent_position epos = { NULL, 0, {0, 0} };
size = (udf_ext0_offset(dir) + dir->i_size) >> 2; size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
f_pos = (udf_ext0_offset(dir) >> 2); f_pos = (udf_ext0_offset(dir) >> 2);
fibh->soffset = fibh->eoffset = (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; fibh->sbh = fibh->ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) &epos, &eloc, &elen,
{ &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset); block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
{
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad); epos.offset -= sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad); epos.offset -= sizeof(long_ad);
} } else
else
offset = 0; offset = 0;
if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) {
{
brelse(epos.bh); brelse(epos.bh);
return NULL; return NULL;
} }
} } else {
else
{
brelse(epos.bh); brelse(epos.bh);
return NULL; return NULL;
} }
while ( (f_pos < size) ) while ((f_pos < size)) {
{ fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, &elen, &offset); &elen, &offset);
if (!fi) if (!fi) {
{
if (fibh->sbh != fibh->ebh) if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh); brelse(fibh->ebh);
brelse(fibh->sbh); brelse(fibh->sbh);
...@@ -209,45 +208,45 @@ udf_find_entry(struct inode *dir, struct dentry *dentry, ...@@ -209,45 +208,45 @@ udf_find_entry(struct inode *dir, struct dentry *dentry,
liu = le16_to_cpu(cfi->lengthOfImpUse); liu = le16_to_cpu(cfi->lengthOfImpUse);
lfi = cfi->lengthFileIdent; lfi = cfi->lengthFileIdent;
if (fibh->sbh == fibh->ebh) if (fibh->sbh == fibh->ebh) {
{
nameptr = fi->fileIdent + liu; nameptr = fi->fileIdent + liu;
} } else {
else
{
int poffset; /* Unpaded ending offset */ int poffset; /* Unpaded ending offset */
poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi; poffset =
fibh->soffset + sizeof(struct fileIdentDesc) + liu +
lfi;
if (poffset >= lfi) if (poffset >= lfi)
nameptr = (uint8_t *)(fibh->ebh->b_data + poffset - lfi); nameptr =
else (uint8_t *) (fibh->ebh->b_data + poffset -
{ lfi);
else {
nameptr = fname; nameptr = fname;
memcpy(nameptr, fi->fileIdent + liu, lfi - poffset); memcpy(nameptr, fi->fileIdent + liu,
memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset); lfi - poffset);
memcpy(nameptr + lfi - poffset,
fibh->ebh->b_data, poffset);
} }
} }
if ( (cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 ) if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
{ if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE))
if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE) )
continue; continue;
} }
if ( (cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0 ) if ((cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0) {
{ if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE))
if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE) )
continue; continue;
} }
if (!lfi) if (!lfi)
continue; continue;
if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi))) if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi))) {
{ if (udf_match
if (udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) (flen, fname, dentry->d_name.len,
{ dentry->d_name.name)) {
brelse(epos.bh); brelse(epos.bh);
return fi; return fi;
} }
...@@ -293,41 +292,37 @@ udf_find_entry(struct inode *dir, struct dentry *dentry, ...@@ -293,41 +292,37 @@ udf_find_entry(struct inode *dir, struct dentry *dentry,
* Written, tested, and released. * Written, tested, and released.
*/ */
static struct dentry * static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
udf_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) struct nameidata *nd)
{ {
struct inode *inode = NULL; struct inode *inode = NULL;
struct fileIdentDesc cfi; struct fileIdentDesc cfi;
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
if (dentry->d_name.len > UDF_NAME_LEN-2) if (dentry->d_name.len > UDF_NAME_LEN - 2)
return ERR_PTR(-ENAMETOOLONG); return ERR_PTR(-ENAMETOOLONG);
lock_kernel(); lock_kernel();
#ifdef UDF_RECOVERY #ifdef UDF_RECOVERY
/* temporary shorthand for specifying files by inode number */ /* temporary shorthand for specifying files by inode number */
if (!strncmp(dentry->d_name.name, ".B=", 3) ) if (!strncmp(dentry->d_name.name, ".B=", 3)) {
{ kernel_lb_addr lb =
kernel_lb_addr lb = { 0, simple_strtoul(dentry->d_name.name+3, NULL, 0) }; { 0, simple_strtoul(dentry->d_name.name + 3, NULL, 0) };
inode = udf_iget(dir->i_sb, lb); inode = udf_iget(dir->i_sb, lb);
if (!inode) if (!inode) {
{
unlock_kernel(); unlock_kernel();
return ERR_PTR(-EACCES); return ERR_PTR(-EACCES);
} }
} } else
else
#endif /* UDF_RECOVERY */ #endif /* UDF_RECOVERY */
if (udf_find_entry(dir, dentry, &fibh, &cfi)) if (udf_find_entry(dir, dentry, &fibh, &cfi)) {
{
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
brelse(fibh.sbh); brelse(fibh.sbh);
inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation)); inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation));
if ( !inode ) if (!inode) {
{
unlock_kernel(); unlock_kernel();
return ERR_PTR(-EACCES); return ERR_PTR(-EACCES);
} }
...@@ -337,13 +332,13 @@ udf_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) ...@@ -337,13 +332,13 @@ udf_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
return NULL; return NULL;
} }
static struct fileIdentDesc * static struct fileIdentDesc *udf_add_entry(struct inode *dir,
udf_add_entry(struct inode *dir, struct dentry *dentry, struct dentry *dentry,
struct udf_fileident_bh *fibh, struct udf_fileident_bh *fibh,
struct fileIdentDesc *cfi, int *err) struct fileIdentDesc *cfi, int *err)
{ {
struct super_block *sb; struct super_block *sb;
struct fileIdentDesc *fi=NULL; struct fileIdentDesc *fi = NULL;
char name[UDF_NAME_LEN], fname[UDF_NAME_LEN]; char name[UDF_NAME_LEN], fname[UDF_NAME_LEN];
int namelen; int namelen;
loff_t f_pos; loff_t f_pos;
...@@ -357,50 +352,47 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -357,50 +352,47 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
kernel_lb_addr eloc; kernel_lb_addr eloc;
uint32_t elen; uint32_t elen;
sector_t offset; sector_t offset;
struct extent_position epos = { NULL, 0, { 0, 0 }}; struct extent_position epos = { NULL, 0, {0, 0} };
sb = dir->i_sb; sb = dir->i_sb;
if (dentry) if (dentry) {
{ if (!dentry->d_name.len) {
if (!dentry->d_name.len)
{
*err = -EINVAL; *err = -EINVAL;
return NULL; 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; *err = -ENAMETOOLONG;
return NULL; return NULL;
} }
} } else
else
namelen = 0; namelen = 0;
nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3; nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;
f_pos = (udf_ext0_offset(dir) >> 2); 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; fibh->sbh = fibh->ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) &epos, &eloc, &elen,
{ &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset); block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
{
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad); epos.offset -= sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad); epos.offset -= sizeof(long_ad);
} } else
else
offset = 0; offset = 0;
if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) {
{
brelse(epos.bh); brelse(epos.bh);
*err = -EIO; *err = -EIO;
return NULL; return NULL;
...@@ -408,21 +400,18 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -408,21 +400,18 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
block = UDF_I_LOCATION(dir).logicalBlockNum; block = UDF_I_LOCATION(dir).logicalBlockNum;
} } else {
else
{
block = udf_get_lb_pblock(dir->i_sb, UDF_I_LOCATION(dir), 0); block = udf_get_lb_pblock(dir->i_sb, UDF_I_LOCATION(dir), 0);
fibh->sbh = fibh->ebh = NULL; fibh->sbh = fibh->ebh = NULL;
fibh->soffset = fibh->eoffset = sb->s_blocksize; fibh->soffset = fibh->eoffset = sb->s_blocksize;
goto add; goto add;
} }
while ( (f_pos < size) ) while ((f_pos < size)) {
{ fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, &elen, &offset); &elen, &offset);
if (!fi) if (!fi) {
{
if (fibh->sbh != fibh->ebh) if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh); brelse(fibh->ebh);
brelse(fibh->sbh); brelse(fibh->sbh);
...@@ -436,36 +425,38 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -436,36 +425,38 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
if (fibh->sbh == fibh->ebh) if (fibh->sbh == fibh->ebh)
nameptr = fi->fileIdent + liu; nameptr = fi->fileIdent + liu;
else else {
{
int poffset; /* Unpaded ending offset */ int poffset; /* Unpaded ending offset */
poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi; poffset =
fibh->soffset + sizeof(struct fileIdentDesc) + liu +
lfi;
if (poffset >= lfi) if (poffset >= lfi)
nameptr = (char *)(fibh->ebh->b_data + poffset - lfi); nameptr =
else (char *)(fibh->ebh->b_data + poffset - lfi);
{ else {
nameptr = fname; nameptr = fname;
memcpy(nameptr, fi->fileIdent + liu, lfi - poffset); memcpy(nameptr, fi->fileIdent + liu,
memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset); lfi - poffset);
memcpy(nameptr + lfi - poffset,
fibh->ebh->b_data, poffset);
} }
} }
if ( (cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 ) if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
{ if (((sizeof(struct fileIdentDesc) + liu + lfi +
if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen) 3) & ~3) == nfidlen) {
{
brelse(epos.bh); brelse(epos.bh);
cfi->descTag.tagSerialNum = cpu_to_le16(1); cfi->descTag.tagSerialNum = cpu_to_le16(1);
cfi->fileVersionNum = cpu_to_le16(1); cfi->fileVersionNum = cpu_to_le16(1);
cfi->fileCharacteristics = 0; cfi->fileCharacteristics = 0;
cfi->lengthFileIdent = namelen; cfi->lengthFileIdent = namelen;
cfi->lengthOfImpUse = cpu_to_le16(0); 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; return fi;
else else {
{
*err = -EIO; *err = -EIO;
return NULL; return NULL;
} }
...@@ -476,8 +467,8 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -476,8 +467,8 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
continue; continue;
if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi)) && 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) if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh); brelse(fibh->ebh);
brelse(fibh->sbh); brelse(fibh->sbh);
...@@ -487,12 +478,11 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -487,12 +478,11 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
} }
} }
add: add:
f_pos += nfidlen; f_pos += nfidlen;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB && if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&
sb->s_blocksize - fibh->eoffset < nfidlen) sb->s_blocksize - fibh->eoffset < nfidlen) {
{
brelse(epos.bh); brelse(epos.bh);
epos.bh = NULL; epos.bh = NULL;
fibh->soffset -= udf_ext0_offset(dir); fibh->soffset -= udf_ext0_offset(dir);
...@@ -501,11 +491,14 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -501,11 +491,14 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
if (fibh->sbh != fibh->ebh) if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh); brelse(fibh->ebh);
brelse(fibh->sbh); 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; return NULL;
epos.block = UDF_I_LOCATION(dir); epos.block = UDF_I_LOCATION(dir);
eloc.logicalBlockNum = block; eloc.logicalBlockNum = block;
eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum; eloc.partitionReferenceNum =
UDF_I_LOCATION(dir).partitionReferenceNum;
elen = dir->i_sb->s_blocksize; elen = dir->i_sb->s_blocksize;
epos.offset = udf_file_entry_alloc_offset(dir); epos.offset = udf_file_entry_alloc_offset(dir);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
...@@ -514,34 +507,31 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -514,34 +507,31 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
epos.offset += sizeof(long_ad); epos.offset += sizeof(long_ad);
} }
if (sb->s_blocksize - fibh->eoffset >= nfidlen) if (sb->s_blocksize - fibh->eoffset >= nfidlen) {
{
fibh->soffset = fibh->eoffset; fibh->soffset = fibh->eoffset;
fibh->eoffset += nfidlen; fibh->eoffset += nfidlen;
if (fibh->sbh != fibh->ebh) if (fibh->sbh != fibh->ebh) {
{
brelse(fibh->sbh); brelse(fibh->sbh);
fibh->sbh = fibh->ebh; fibh->sbh = fibh->ebh;
} }
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
{
block = UDF_I_LOCATION(dir).logicalBlockNum; block = UDF_I_LOCATION(dir).logicalBlockNum;
fi = (struct fileIdentDesc *)(UDF_I_DATA(dir) + fibh->soffset - udf_ext0_offset(dir) + UDF_I_LENEATTR(dir)); fi = (struct fileIdentDesc *)(UDF_I_DATA(dir) +
} fibh->soffset -
else udf_ext0_offset(dir) +
{ UDF_I_LENEATTR(dir));
} else {
block = eloc.logicalBlockNum + ((elen - 1) >> block = eloc.logicalBlockNum + ((elen - 1) >>
dir->i_sb->s_blocksize_bits); dir->i_sb->
fi = (struct fileIdentDesc *)(fibh->sbh->b_data + fibh->soffset); s_blocksize_bits);
fi = (struct fileIdentDesc *)(fibh->sbh->b_data +
fibh->soffset);
} }
} } else {
else
{
fibh->soffset = fibh->eoffset - sb->s_blocksize; fibh->soffset = fibh->eoffset - sb->s_blocksize;
fibh->eoffset += nfidlen - sb->s_blocksize; fibh->eoffset += nfidlen - sb->s_blocksize;
if (fibh->sbh != fibh->ebh) if (fibh->sbh != fibh->ebh) {
{
brelse(fibh->sbh); brelse(fibh->sbh);
fibh->sbh = fibh->ebh; fibh->sbh = fibh->ebh;
} }
...@@ -549,54 +539,52 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -549,54 +539,52 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
block = eloc.logicalBlockNum + ((elen - 1) >> block = eloc.logicalBlockNum + ((elen - 1) >>
dir->i_sb->s_blocksize_bits); dir->i_sb->s_blocksize_bits);
if (!(fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err))) if (!
{ (fibh->ebh =
udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
1, err))) {
brelse(epos.bh); brelse(epos.bh);
brelse(fibh->sbh); brelse(fibh->sbh);
return NULL; return NULL;
} }
if (!(fibh->soffset)) if (!(fibh->soffset)) {
{
if (udf_next_aext(dir, &epos, &eloc, &elen, 1) == if (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
(EXT_RECORDED_ALLOCATED >> 30)) (EXT_RECORDED_ALLOCATED >> 30)) {
{
block = eloc.logicalBlockNum + ((elen - 1) >> block = eloc.logicalBlockNum + ((elen - 1) >>
dir->i_sb->s_blocksize_bits); dir->i_sb->
} s_blocksize_bits);
else } else
block ++; block++;
brelse(fibh->sbh); brelse(fibh->sbh);
fibh->sbh = fibh->ebh; fibh->sbh = fibh->ebh;
fi = (struct fileIdentDesc *)(fibh->sbh->b_data); fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
} } else {
else
{
fi = (struct fileIdentDesc *) 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)); memset(cfi, 0, sizeof(struct fileIdentDesc));
if (UDF_SB_UDFREV(sb) >= 0x0200) 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 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->fileVersionNum = cpu_to_le16(1);
cfi->lengthFileIdent = namelen; cfi->lengthFileIdent = namelen;
cfi->lengthOfImpUse = cpu_to_le16(0); 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)) {
{
brelse(epos.bh); brelse(epos.bh);
dir->i_size += nfidlen; dir->i_size += nfidlen;
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
UDF_I_LENALLOC(dir) += nfidlen; UDF_I_LENALLOC(dir) += nfidlen;
mark_inode_dirty(dir); mark_inode_dirty(dir);
return fi; return fi;
} } else {
else
{
brelse(epos.bh); brelse(epos.bh);
if (fibh->sbh != fibh->ebh) if (fibh->sbh != fibh->ebh)
brelse(fibh->ebh); brelse(fibh->ebh);
...@@ -607,7 +595,8 @@ udf_add_entry(struct inode *dir, struct dentry *dentry, ...@@ -607,7 +595,8 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
} }
static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
struct udf_fileident_bh *fibh, struct fileIdentDesc *cfi) struct udf_fileident_bh *fibh,
struct fileIdentDesc *cfi)
{ {
cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED; cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED;
if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
...@@ -615,7 +604,8 @@ static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, ...@@ -615,7 +604,8 @@ static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL); return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL);
} }
static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd) static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
struct nameidata *nd)
{ {
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct inode *inode; struct inode *inode;
...@@ -624,8 +614,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct ...@@ -624,8 +614,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct
lock_kernel(); lock_kernel();
inode = udf_new_inode(dir, mode, &err); inode = udf_new_inode(dir, mode, &err);
if (!inode) if (!inode) {
{
unlock_kernel(); unlock_kernel();
return err; return err;
} }
...@@ -639,9 +628,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct ...@@ -639,9 +628,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct
inode->i_mode = mode; inode->i_mode = mode;
mark_inode_dirty(inode); mark_inode_dirty(inode);
if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) {
{ inode->i_nlink--;
inode->i_nlink --;
mark_inode_dirty(inode); mark_inode_dirty(inode);
iput(inode); iput(inode);
unlock_kernel(); unlock_kernel();
...@@ -649,11 +637,10 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct ...@@ -649,11 +637,10 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct
} }
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL); cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
{
mark_inode_dirty(dir); mark_inode_dirty(dir);
} }
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
...@@ -664,9 +651,10 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct ...@@ -664,9 +651,10 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct
return 0; return 0;
} }
static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t rdev) static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
dev_t rdev)
{ {
struct inode * inode; struct inode *inode;
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct fileIdentDesc cfi, *fi; struct fileIdentDesc cfi, *fi;
int err; int err;
...@@ -682,9 +670,8 @@ static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t ...@@ -682,9 +670,8 @@ static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t
inode->i_uid = current->fsuid; inode->i_uid = current->fsuid;
init_special_inode(inode, mode, rdev); init_special_inode(inode, mode, rdev);
if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) {
{ inode->i_nlink--;
inode->i_nlink --;
mark_inode_dirty(inode); mark_inode_dirty(inode);
iput(inode); iput(inode);
unlock_kernel(); unlock_kernel();
...@@ -692,11 +679,10 @@ static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t ...@@ -692,11 +679,10 @@ static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t
} }
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL); cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
{
mark_inode_dirty(dir); mark_inode_dirty(dir);
} }
mark_inode_dirty(inode); mark_inode_dirty(inode);
...@@ -706,21 +692,21 @@ static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t ...@@ -706,21 +692,21 @@ static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t
brelse(fibh.sbh); brelse(fibh.sbh);
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
err = 0; err = 0;
out: out:
unlock_kernel(); unlock_kernel();
return err; return err;
} }
static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode) static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{ {
struct inode * inode; struct inode *inode;
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct fileIdentDesc cfi, *fi; struct fileIdentDesc cfi, *fi;
int err; int err;
lock_kernel(); lock_kernel();
err = -EMLINK; err = -EMLINK;
if (dir->i_nlink >= (256<<sizeof(dir->i_nlink))-1) if (dir->i_nlink >= (256 << sizeof(dir->i_nlink)) - 1)
goto out; goto out;
err = -EIO; err = -EIO;
...@@ -730,8 +716,7 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode) ...@@ -730,8 +716,7 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode)
inode->i_op = &udf_dir_inode_operations; inode->i_op = &udf_dir_inode_operations;
inode->i_fop = &udf_dir_operations; inode->i_fop = &udf_dir_operations;
if (!(fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err))) if (!(fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err))) {
{
inode->i_nlink--; inode->i_nlink--;
mark_inode_dirty(inode); mark_inode_dirty(inode);
iput(inode); iput(inode);
...@@ -740,9 +725,10 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode) ...@@ -740,9 +725,10 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode)
inode->i_nlink = 2; inode->i_nlink = 2;
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(dir)); cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(dir));
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL); cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
cfi.fileCharacteristics = FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT; cfi.fileCharacteristics =
FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
brelse(fibh.sbh); brelse(fibh.sbh);
inode->i_mode = S_IFDIR | mode; inode->i_mode = S_IFDIR | mode;
...@@ -750,8 +736,7 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode) ...@@ -750,8 +736,7 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode)
inode->i_mode |= S_ISGID; inode->i_mode |= S_ISGID;
mark_inode_dirty(inode); mark_inode_dirty(inode);
if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) {
{
inode->i_nlink = 0; inode->i_nlink = 0;
mark_inode_dirty(inode); mark_inode_dirty(inode);
iput(inode); iput(inode);
...@@ -759,7 +744,7 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode) ...@@ -759,7 +744,7 @@ 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.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL); cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY; cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
...@@ -770,7 +755,7 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode) ...@@ -770,7 +755,7 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode)
brelse(fibh.ebh); brelse(fibh.ebh);
brelse(fibh.sbh); brelse(fibh.sbh);
err = 0; err = 0;
out: out:
unlock_kernel(); unlock_kernel();
return err; return err;
} }
...@@ -785,47 +770,41 @@ static int empty_dir(struct inode *dir) ...@@ -785,47 +770,41 @@ static int empty_dir(struct inode *dir)
kernel_lb_addr eloc; kernel_lb_addr eloc;
uint32_t elen; uint32_t elen;
sector_t offset; sector_t offset;
struct extent_position epos = { NULL, 0, { 0, 0}}; struct extent_position epos = { NULL, 0, {0, 0} };
f_pos = (udf_ext0_offset(dir) >> 2); 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; fibh.sbh = fibh.ebh = NULL;
else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) &epos, &eloc, &elen,
{ &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
block = udf_get_lb_pblock(dir->i_sb, eloc, offset); block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
if ((++offset << dir->i_sb->s_blocksize_bits) < elen) if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
{
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
epos.offset -= sizeof(short_ad); epos.offset -= sizeof(short_ad);
else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
epos.offset -= sizeof(long_ad); epos.offset -= sizeof(long_ad);
} } else
else
offset = 0; offset = 0;
if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) {
{
brelse(epos.bh); brelse(epos.bh);
return 0; return 0;
} }
} } else {
else
{
brelse(epos.bh); brelse(epos.bh);
return 0; return 0;
} }
while ((f_pos < size)) {
fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc,
&elen, &offset);
while ( (f_pos < size) ) if (!fi) {
{
fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset);
if (!fi)
{
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
brelse(fibh.sbh); brelse(fibh.sbh);
...@@ -833,8 +812,8 @@ static int empty_dir(struct inode *dir) ...@@ -833,8 +812,8 @@ static int empty_dir(struct inode *dir)
return 0; 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) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
brelse(fibh.sbh); brelse(fibh.sbh);
...@@ -849,10 +828,10 @@ static int empty_dir(struct inode *dir) ...@@ -849,10 +828,10 @@ static int empty_dir(struct inode *dir)
return 1; return 1;
} }
static int udf_rmdir(struct inode * dir, struct dentry * dentry) static int udf_rmdir(struct inode *dir, struct dentry *dentry)
{ {
int retval; int retval;
struct inode * inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct fileIdentDesc *fi, cfi; struct fileIdentDesc *fi, cfi;
kernel_lb_addr tloc; kernel_lb_addr tloc;
...@@ -880,22 +859,23 @@ static int udf_rmdir(struct inode * dir, struct dentry * dentry) ...@@ -880,22 +859,23 @@ static int udf_rmdir(struct inode * dir, struct dentry * dentry)
clear_nlink(inode); clear_nlink(inode);
inode->i_size = 0; inode->i_size = 0;
inode_dec_link_count(dir); 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); mark_inode_dirty(dir);
end_rmdir: end_rmdir:
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
brelse(fibh.sbh); brelse(fibh.sbh);
out: out:
unlock_kernel(); unlock_kernel();
return retval; return retval;
} }
static int udf_unlink(struct inode * dir, struct dentry * dentry) static int udf_unlink(struct inode *dir, struct dentry *dentry)
{ {
int retval; int retval;
struct inode * inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct fileIdentDesc *fi; struct fileIdentDesc *fi;
struct fileIdentDesc cfi; struct fileIdentDesc cfi;
...@@ -912,8 +892,7 @@ static int udf_unlink(struct inode * dir, struct dentry * dentry) ...@@ -912,8 +892,7 @@ static int udf_unlink(struct inode * dir, struct dentry * dentry)
if (udf_get_lb_pblock(dir->i_sb, tloc, 0) != inode->i_ino) if (udf_get_lb_pblock(dir->i_sb, tloc, 0) != inode->i_ino)
goto end_unlink; goto end_unlink;
if (!inode->i_nlink) if (!inode->i_nlink) {
{
udf_debug("Deleting nonexistent file (%lu), %d\n", udf_debug("Deleting nonexistent file (%lu), %d\n",
inode->i_ino, inode->i_nlink); inode->i_ino, inode->i_nlink);
inode->i_nlink = 1; inode->i_nlink = 1;
...@@ -927,22 +906,23 @@ static int udf_unlink(struct inode * dir, struct dentry * dentry) ...@@ -927,22 +906,23 @@ static int udf_unlink(struct inode * dir, struct dentry * dentry)
inode->i_ctime = dir->i_ctime; inode->i_ctime = dir->i_ctime;
retval = 0; retval = 0;
end_unlink: end_unlink:
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
brelse(fibh.ebh); brelse(fibh.ebh);
brelse(fibh.sbh); brelse(fibh.sbh);
out: out:
unlock_kernel(); unlock_kernel();
return retval; return retval;
} }
static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * symname) static int udf_symlink(struct inode *dir, struct dentry *dentry,
const char *symname)
{ {
struct inode * inode; struct inode *inode;
struct pathComponent *pc; struct pathComponent *pc;
char *compstart; char *compstart;
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct extent_position epos = { NULL, 0, {0, 0}}; struct extent_position epos = { NULL, 0, {0, 0} };
int eoffset, elen = 0; int eoffset, elen = 0;
struct fileIdentDesc *fi; struct fileIdentDesc *fi;
struct fileIdentDesc cfi; struct fileIdentDesc cfi;
...@@ -960,28 +940,31 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * ...@@ -960,28 +940,31 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
inode->i_data.a_ops = &udf_symlink_aops; inode->i_data.a_ops = &udf_symlink_aops;
inode->i_op = &page_symlink_inode_operations; inode->i_op = &page_symlink_inode_operations;
if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB) {
{
kernel_lb_addr eloc; kernel_lb_addr eloc;
uint32_t elen; uint32_t elen;
block = udf_new_block(inode->i_sb, inode, block = udf_new_block(inode->i_sb, inode,
UDF_I_LOCATION(inode).partitionReferenceNum, UDF_I_LOCATION(inode).
UDF_I_LOCATION(inode).logicalBlockNum, &err); partitionReferenceNum,
UDF_I_LOCATION(inode).logicalBlockNum,
&err);
if (!block) if (!block)
goto out_no_entry; goto out_no_entry;
epos.block = UDF_I_LOCATION(inode); epos.block = UDF_I_LOCATION(inode);
epos.offset = udf_file_entry_alloc_offset(inode); epos.offset = udf_file_entry_alloc_offset(inode);
epos.bh = NULL; epos.bh = NULL;
eloc.logicalBlockNum = block; eloc.logicalBlockNum = block;
eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum; eloc.partitionReferenceNum =
UDF_I_LOCATION(inode).partitionReferenceNum;
elen = inode->i_sb->s_blocksize; elen = inode->i_sb->s_blocksize;
UDF_I_LENEXTENTS(inode) = elen; UDF_I_LENEXTENTS(inode) = elen;
udf_add_aext(inode, &epos, eloc, elen, 0); udf_add_aext(inode, &epos, eloc, elen, 0);
brelse(epos.bh); brelse(epos.bh);
block = udf_get_pblock(inode->i_sb, block, block = udf_get_pblock(inode->i_sb, block,
UDF_I_LOCATION(inode).partitionReferenceNum, 0); UDF_I_LOCATION(inode).
partitionReferenceNum, 0);
epos.bh = udf_tread(inode->i_sb, block); epos.bh = udf_tread(inode->i_sb, block);
lock_buffer(epos.bh); lock_buffer(epos.bh);
memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize); memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
...@@ -989,17 +972,14 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * ...@@ -989,17 +972,14 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
unlock_buffer(epos.bh); unlock_buffer(epos.bh);
mark_buffer_dirty_inode(epos.bh, inode); mark_buffer_dirty_inode(epos.bh, inode);
ea = epos.bh->b_data + udf_ext0_offset(inode); ea = epos.bh->b_data + udf_ext0_offset(inode);
} } else
else
ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode); ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode); eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
pc = (struct pathComponent *)ea; pc = (struct pathComponent *)ea;
if (*symname == '/') if (*symname == '/') {
{ do {
do
{
symname++; symname++;
} while (*symname == '/'); } while (*symname == '/');
...@@ -1012,8 +992,7 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * ...@@ -1012,8 +992,7 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
err = -ENAMETOOLONG; err = -ENAMETOOLONG;
while (*symname) while (*symname) {
{
if (elen + sizeof(struct pathComponent) > eoffset) if (elen + sizeof(struct pathComponent) > eoffset)
goto out_no_entry; goto out_no_entry;
...@@ -1021,28 +1000,30 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * ...@@ -1021,28 +1000,30 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
compstart = (char *)symname; compstart = (char *)symname;
do do {
{
symname++; symname++;
} while (*symname && *symname != '/'); } while (*symname && *symname != '/');
pc->componentType = 5; pc->componentType = 5;
pc->lengthComponentIdent = 0; pc->lengthComponentIdent = 0;
pc->componentFileVersionNum = 0; pc->componentFileVersionNum = 0;
if (compstart[0] == '.') if (compstart[0] == '.') {
{ if ((symname - compstart) == 1)
if ((symname-compstart) == 1)
pc->componentType = 4; pc->componentType = 4;
else if ((symname-compstart) == 2 && compstart[1] == '.') else if ((symname - compstart) == 2
&& compstart[1] == '.')
pc->componentType = 3; pc->componentType = 3;
} }
if (pc->componentType == 5) if (pc->componentType == 5) {
{ if (!
if ( !(namelen = udf_put_filename(inode->i_sb, compstart, name, symname-compstart))) (namelen =
udf_put_filename(inode->i_sb, compstart, name,
symname - compstart)))
goto out_no_entry; goto out_no_entry;
if (elen + sizeof(struct pathComponent) + namelen > eoffset) if (elen + sizeof(struct pathComponent) + namelen >
eoffset)
goto out_no_entry; goto out_no_entry;
else else
pc->lengthComponentIdent = namelen; pc->lengthComponentIdent = namelen;
...@@ -1052,10 +1033,8 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * ...@@ -1052,10 +1033,8 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
elen += sizeof(struct pathComponent) + pc->lengthComponentIdent; elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;
if (*symname) if (*symname) {
{ do {
do
{
symname++; symname++;
} while (*symname == '/'); } while (*symname == '/');
} }
...@@ -1071,13 +1050,14 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * ...@@ -1071,13 +1050,14 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
goto out_no_entry; goto out_no_entry;
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
if (UDF_SB_LVIDBH(inode->i_sb)) if (UDF_SB_LVIDBH(inode->i_sb)) {
{
struct logicalVolHeaderDesc *lvhd; struct logicalVolHeaderDesc *lvhd;
uint64_t uniqueID; 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); uniqueID = le64_to_cpu(lvhd->uniqueID);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL); cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
if (!(++uniqueID & 0x00000000FFFFFFFFUL)) if (!(++uniqueID & 0x00000000FFFFFFFFUL))
uniqueID += 16; uniqueID += 16;
...@@ -1085,8 +1065,7 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * ...@@ -1085,8 +1065,7 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb)); mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb));
} }
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
{
mark_inode_dirty(dir); mark_inode_dirty(dir);
} }
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
...@@ -1095,17 +1074,17 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * ...@@ -1095,17 +1074,17 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
err = 0; err = 0;
out: out:
unlock_kernel(); unlock_kernel();
return err; return err;
out_no_entry: out_no_entry:
inode_dec_link_count(inode); inode_dec_link_count(inode);
iput(inode); iput(inode);
goto out; goto out;
} }
static int udf_link(struct dentry * old_dentry, struct inode * dir, static int udf_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry) struct dentry *dentry)
{ {
struct inode *inode = old_dentry->d_inode; struct inode *inode = old_dentry->d_inode;
...@@ -1114,26 +1093,25 @@ static int udf_link(struct dentry * old_dentry, struct inode * dir, ...@@ -1114,26 +1093,25 @@ static int udf_link(struct dentry * old_dentry, struct inode * dir,
int err; int err;
lock_kernel(); lock_kernel();
if (inode->i_nlink >= (256<<sizeof(inode->i_nlink))-1) if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) {
{
unlock_kernel(); unlock_kernel();
return -EMLINK; return -EMLINK;
} }
if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) {
{
unlock_kernel(); unlock_kernel();
return err; return err;
} }
cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
if (UDF_SB_LVIDBH(inode->i_sb)) if (UDF_SB_LVIDBH(inode->i_sb)) {
{
struct logicalVolHeaderDesc *lvhd; struct logicalVolHeaderDesc *lvhd;
uint64_t uniqueID; 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); uniqueID = le64_to_cpu(lvhd->uniqueID);
*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL); cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
if (!(++uniqueID & 0x00000000FFFFFFFFUL)) if (!(++uniqueID & 0x00000000FFFFFFFFUL))
uniqueID += 16; uniqueID += 16;
...@@ -1141,8 +1119,7 @@ static int udf_link(struct dentry * old_dentry, struct inode * dir, ...@@ -1141,8 +1119,7 @@ static int udf_link(struct dentry * old_dentry, struct inode * dir,
mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb)); mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb));
} }
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
{
mark_inode_dirty(dir); mark_inode_dirty(dir);
} }
if (fibh.sbh != fibh.ebh) if (fibh.sbh != fibh.ebh)
...@@ -1160,20 +1137,20 @@ static int udf_link(struct dentry * old_dentry, struct inode * dir, ...@@ -1160,20 +1137,20 @@ static int udf_link(struct dentry * old_dentry, struct inode * dir,
/* Anybody can rename anything with this: the permission checks are left to the /* Anybody can rename anything with this: the permission checks are left to the
* higher-level routines. * higher-level routines.
*/ */
static int udf_rename (struct inode * old_dir, struct dentry * old_dentry, static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode * new_dir, struct dentry * new_dentry) struct inode *new_dir, struct dentry *new_dentry)
{ {
struct inode * old_inode = old_dentry->d_inode; struct inode *old_inode = old_dentry->d_inode;
struct inode * new_inode = new_dentry->d_inode; struct inode *new_inode = new_dentry->d_inode;
struct udf_fileident_bh ofibh, nfibh; 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; struct buffer_head *dir_bh = NULL;
int retval = -ENOENT; int retval = -ENOENT;
kernel_lb_addr tloc; kernel_lb_addr tloc;
lock_kernel(); lock_kernel();
if ((ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi))) if ((ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi))) {
{
if (ofibh.sbh != ofibh.ebh) if (ofibh.sbh != ofibh.ebh)
brelse(ofibh.ebh); brelse(ofibh.ebh);
brelse(ofibh.sbh); brelse(ofibh.sbh);
...@@ -1184,41 +1161,39 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry, ...@@ -1184,41 +1161,39 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
goto end_rename; goto end_rename;
nfi = udf_find_entry(new_dir, new_dentry, &nfibh, &ncfi); nfi = udf_find_entry(new_dir, new_dentry, &nfibh, &ncfi);
if (nfi) if (nfi) {
{ if (!new_inode) {
if (!new_inode)
{
if (nfibh.sbh != nfibh.ebh) if (nfibh.sbh != nfibh.ebh)
brelse(nfibh.ebh); brelse(nfibh.ebh);
brelse(nfibh.sbh); brelse(nfibh.sbh);
nfi = NULL; nfi = NULL;
} }
} }
if (S_ISDIR(old_inode->i_mode)) if (S_ISDIR(old_inode->i_mode)) {
{
uint32_t offset = udf_ext0_offset(old_inode); uint32_t offset = udf_ext0_offset(old_inode);
if (new_inode) if (new_inode) {
{
retval = -ENOTEMPTY; retval = -ENOTEMPTY;
if (!empty_dir(new_inode)) if (!empty_dir(new_inode))
goto end_rename; goto end_rename;
} }
retval = -EIO; retval = -EIO;
if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) {
{
dir_fi = udf_get_fileident(UDF_I_DATA(old_inode) - dir_fi = udf_get_fileident(UDF_I_DATA(old_inode) -
(UDF_I_EFE(old_inode) ? (UDF_I_EFE(old_inode) ?
sizeof(struct extendedFileEntry) : sizeof(struct
extendedFileEntry) :
sizeof(struct fileEntry)), sizeof(struct fileEntry)),
old_inode->i_sb->s_blocksize, &offset); old_inode->i_sb->s_blocksize,
} &offset);
else } else {
{
dir_bh = udf_bread(old_inode, 0, 0, &retval); dir_bh = udf_bread(old_inode, 0, 0, &retval);
if (!dir_bh) if (!dir_bh)
goto end_rename; 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) if (!dir_fi)
goto end_rename; goto end_rename;
...@@ -1228,12 +1203,14 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry, ...@@ -1228,12 +1203,14 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
goto end_rename; goto end_rename;
retval = -EMLINK; 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; goto end_rename;
} }
if (!nfi) if (!nfi) {
{ nfi =
nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval); udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval);
if (!nfi) if (!nfi)
goto end_rename; goto end_rename;
} }
...@@ -1257,39 +1234,33 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry, ...@@ -1257,39 +1234,33 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi); ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi);
udf_delete_entry(old_dir, ofi, &ofibh, &ocfi); udf_delete_entry(old_dir, ofi, &ofibh, &ocfi);
if (new_inode) if (new_inode) {
{
new_inode->i_ctime = current_fs_time(new_inode->i_sb); new_inode->i_ctime = current_fs_time(new_inode->i_sb);
inode_dec_link_count(new_inode); inode_dec_link_count(new_inode);
} }
old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb); old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb);
mark_inode_dirty(old_dir); mark_inode_dirty(old_dir);
if (dir_fi) if (dir_fi) {
{
dir_fi->icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(new_dir)); dir_fi->icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(new_dir));
udf_update_tag((char *)dir_fi, (sizeof(struct fileIdentDesc) + udf_update_tag((char *)dir_fi, (sizeof(struct fileIdentDesc) +
le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3); le16_to_cpu(dir_fi->
if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) lengthOfImpUse) +
{ 3) & ~3);
if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) {
mark_inode_dirty(old_inode); mark_inode_dirty(old_inode);
} } else
else
mark_buffer_dirty_inode(dir_bh, old_inode); mark_buffer_dirty_inode(dir_bh, old_inode);
inode_dec_link_count(old_dir); inode_dec_link_count(old_dir);
if (new_inode) if (new_inode) {
{
inode_dec_link_count(new_inode); inode_dec_link_count(new_inode);
} } else {
else
{
inc_nlink(new_dir); inc_nlink(new_dir);
mark_inode_dirty(new_dir); mark_inode_dirty(new_dir);
} }
} }
if (ofi) if (ofi) {
{
if (ofibh.sbh != ofibh.ebh) if (ofibh.sbh != ofibh.ebh)
brelse(ofibh.ebh); brelse(ofibh.ebh);
brelse(ofibh.sbh); brelse(ofibh.sbh);
...@@ -1297,10 +1268,9 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry, ...@@ -1297,10 +1268,9 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
retval = 0; retval = 0;
end_rename: end_rename:
brelse(dir_bh); brelse(dir_bh);
if (nfi) if (nfi) {
{
if (nfibh.sbh != nfibh.ebh) if (nfibh.sbh != nfibh.ebh)
brelse(nfibh.ebh); brelse(nfibh.ebh);
brelse(nfibh.sbh); brelse(nfibh.sbh);
......
fs/udf/osta_udf.h
View file @ cb00ea35
...@@ -65,30 +65,26 @@ ...@@ -65,30 +65,26 @@
#define IS_DF_HARD_WRITE_PROTECT 0x01 #define IS_DF_HARD_WRITE_PROTECT 0x01
#define IS_DF_SOFT_WRITE_PROTECT 0x02 #define IS_DF_SOFT_WRITE_PROTECT 0x02
struct UDFIdentSuffix struct UDFIdentSuffix {
{
__le16 UDFRevision; __le16 UDFRevision;
uint8_t OSClass; uint8_t OSClass;
uint8_t OSIdentifier; uint8_t OSIdentifier;
uint8_t reserved[4]; uint8_t reserved[4];
} __attribute__ ((packed)); } __attribute__ ((packed));
struct impIdentSuffix struct impIdentSuffix {
{
uint8_t OSClass; uint8_t OSClass;
uint8_t OSIdentifier; uint8_t OSIdentifier;
uint8_t reserved[6]; uint8_t reserved[6];
} __attribute__ ((packed)); } __attribute__ ((packed));
struct appIdentSuffix struct appIdentSuffix {
{
uint8_t impUse[8]; uint8_t impUse[8];
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Logical Volume Integrity Descriptor (UDF 2.50 2.2.6) */ /* Logical Volume Integrity Descriptor (UDF 2.50 2.2.6) */
/* Implementation Use (UDF 2.50 2.2.6.4) */ /* Implementation Use (UDF 2.50 2.2.6.4) */
struct logicalVolIntegrityDescImpUse struct logicalVolIntegrityDescImpUse {
{
regid impIdent; regid impIdent;
__le32 numFiles; __le32 numFiles;
__le32 numDirs; __le32 numDirs;
...@@ -100,8 +96,7 @@ struct logicalVolIntegrityDescImpUse ...@@ -100,8 +96,7 @@ struct logicalVolIntegrityDescImpUse
/* Implementation Use Volume Descriptor (UDF 2.50 2.2.7) */ /* Implementation Use Volume Descriptor (UDF 2.50 2.2.7) */
/* Implementation Use (UDF 2.50 2.2.7.2) */ /* Implementation Use (UDF 2.50 2.2.7.2) */
struct impUseVolDescImpUse struct impUseVolDescImpUse {
{
charspec LVICharset; charspec LVICharset;
dstring logicalVolIdent[128]; dstring logicalVolIdent[128];
dstring LVInfo1[36]; dstring LVInfo1[36];
...@@ -111,8 +106,7 @@ struct impUseVolDescImpUse ...@@ -111,8 +106,7 @@ struct impUseVolDescImpUse
uint8_t impUse[128]; uint8_t impUse[128];
} __attribute__ ((packed)); } __attribute__ ((packed));
struct udfPartitionMap2 struct udfPartitionMap2 {
{
uint8_t partitionMapType; uint8_t partitionMapType;
uint8_t partitionMapLength; uint8_t partitionMapLength;
uint8_t reserved1[2]; uint8_t reserved1[2];
...@@ -122,8 +116,7 @@ struct udfPartitionMap2 ...@@ -122,8 +116,7 @@ struct udfPartitionMap2
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Virtual Partition Map (UDF 2.50 2.2.8) */ /* Virtual Partition Map (UDF 2.50 2.2.8) */
struct virtualPartitionMap struct virtualPartitionMap {
{
uint8_t partitionMapType; uint8_t partitionMapType;
uint8_t partitionMapLength; uint8_t partitionMapLength;
uint8_t reserved1[2]; uint8_t reserved1[2];
...@@ -134,8 +127,7 @@ struct virtualPartitionMap ...@@ -134,8 +127,7 @@ struct virtualPartitionMap
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Sparable Partition Map (UDF 2.50 2.2.9) */ /* Sparable Partition Map (UDF 2.50 2.2.9) */
struct sparablePartitionMap struct sparablePartitionMap {
{
uint8_t partitionMapType; uint8_t partitionMapType;
uint8_t partitionMapLength; uint8_t partitionMapLength;
uint8_t reserved1[2]; uint8_t reserved1[2];
...@@ -150,8 +142,7 @@ struct sparablePartitionMap ...@@ -150,8 +142,7 @@ struct sparablePartitionMap
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Metadata Partition Map (UDF 2.4.0 2.2.10) */ /* Metadata Partition Map (UDF 2.4.0 2.2.10) */
struct metadataPartitionMap struct metadataPartitionMap {
{
uint8_t partitionMapType; uint8_t partitionMapType;
uint8_t partitionMapLength; uint8_t partitionMapLength;
uint8_t reserved1[2]; uint8_t reserved1[2];
...@@ -168,8 +159,7 @@ struct metadataPartitionMap ...@@ -168,8 +159,7 @@ struct metadataPartitionMap
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Virtual Allocation Table (UDF 1.5 2.2.10) */ /* Virtual Allocation Table (UDF 1.5 2.2.10) */
struct virtualAllocationTable15 struct virtualAllocationTable15 {
{
__le32 VirtualSector[0]; __le32 VirtualSector[0];
regid vatIdent; regid vatIdent;
__le32 previousVATICBLoc; __le32 previousVATICBLoc;
...@@ -178,8 +168,7 @@ struct virtualAllocationTable15 ...@@ -178,8 +168,7 @@ struct virtualAllocationTable15
#define ICBTAG_FILE_TYPE_VAT15 0x00U #define ICBTAG_FILE_TYPE_VAT15 0x00U
/* Virtual Allocation Table (UDF 2.50 2.2.11) */ /* Virtual Allocation Table (UDF 2.50 2.2.11) */
struct virtualAllocationTable20 struct virtualAllocationTable20 {
{
__le16 lengthHeader; __le16 lengthHeader;
__le16 lengthImpUse; __le16 lengthImpUse;
dstring logicalVolIdent[128]; dstring logicalVolIdent[128];
...@@ -197,14 +186,12 @@ struct virtualAllocationTable20 ...@@ -197,14 +186,12 @@ struct virtualAllocationTable20
#define ICBTAG_FILE_TYPE_VAT20 0xF8U #define ICBTAG_FILE_TYPE_VAT20 0xF8U
/* Sparing Table (UDF 2.50 2.2.12) */ /* Sparing Table (UDF 2.50 2.2.12) */
struct sparingEntry struct sparingEntry {
{
__le32 origLocation; __le32 origLocation;
__le32 mappedLocation; __le32 mappedLocation;
} __attribute__ ((packed)); } __attribute__ ((packed));
struct sparingTable struct sparingTable {
{
tag descTag; tag descTag;
regid sparingIdent; regid sparingIdent;
__le16 reallocationTableLen; __le16 reallocationTableLen;
...@@ -220,8 +207,7 @@ struct sparingTable ...@@ -220,8 +207,7 @@ struct sparingTable
#define ICBTAG_FILE_TYPE_BITMAP 0xFC #define ICBTAG_FILE_TYPE_BITMAP 0xFC
/* struct long_ad ICB - ADImpUse (UDF 2.50 2.2.4.3) */ /* struct long_ad ICB - ADImpUse (UDF 2.50 2.2.4.3) */
struct allocDescImpUse struct allocDescImpUse {
{
__le16 flags; __le16 flags;
uint8_t impUse[4]; uint8_t impUse[4];
} __attribute__ ((packed)); } __attribute__ ((packed));
...@@ -233,15 +219,13 @@ struct allocDescImpUse ...@@ -233,15 +219,13 @@ struct allocDescImpUse
/* Implementation Use Extended Attribute (UDF 2.50 3.3.4.5) */ /* Implementation Use Extended Attribute (UDF 2.50 3.3.4.5) */
/* FreeEASpace (UDF 2.50 3.3.4.5.1.1) */ /* FreeEASpace (UDF 2.50 3.3.4.5.1.1) */
struct freeEaSpace struct freeEaSpace {
{
__le16 headerChecksum; __le16 headerChecksum;
uint8_t freeEASpace[0]; uint8_t freeEASpace[0];
} __attribute__ ((packed)); } __attribute__ ((packed));
/* DVD Copyright Management Information (UDF 2.50 3.3.4.5.1.2) */ /* DVD Copyright Management Information (UDF 2.50 3.3.4.5.1.2) */
struct DVDCopyrightImpUse struct DVDCopyrightImpUse {
{
__le16 headerChecksum; __le16 headerChecksum;
uint8_t CGMSInfo; uint8_t CGMSInfo;
uint8_t dataType; uint8_t dataType;
...@@ -250,8 +234,7 @@ struct DVDCopyrightImpUse ...@@ -250,8 +234,7 @@ struct DVDCopyrightImpUse
/* Application Use Extended Attribute (UDF 2.50 3.3.4.6) */ /* Application Use Extended Attribute (UDF 2.50 3.3.4.6) */
/* FreeAppEASpace (UDF 2.50 3.3.4.6.1) */ /* FreeAppEASpace (UDF 2.50 3.3.4.6.1) */
struct freeAppEASpace struct freeAppEASpace {
{
__le16 headerChecksum; __le16 headerChecksum;
uint8_t freeEASpace[0]; uint8_t freeEASpace[0];
} __attribute__ ((packed)); } __attribute__ ((packed));
......
fs/udf/partition.c
View file @ cb00ea35
...@@ -28,106 +28,120 @@ ...@@ -28,106 +28,120 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block, uint16_t partition, uint32_t offset) 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)) if (partition >= UDF_SB_NUMPARTS(sb)) {
{ udf_debug
udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n", ("block=%d, partition=%d, offset=%d: invalid partition\n",
block, partition, offset); block, partition, offset);
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
if (UDF_SB_PARTFUNC(sb, partition)) 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 else
return UDF_SB_PARTROOT(sb, partition) + block + offset; return UDF_SB_PARTROOT(sb, partition) + block + offset;
} }
uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, uint16_t partition, uint32_t offset) uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
uint16_t partition, uint32_t offset)
{ {
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
uint32_t newblock; uint32_t newblock;
uint32_t index; uint32_t index;
uint32_t loc; 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) if (block > UDF_SB_TYPEVIRT(sb, partition).s_num_entries) {
{ udf_debug
udf_debug("Trying to access block beyond end of VAT (%d max %d)\n", ("Trying to access block beyond end of VAT (%d max %d)\n",
block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries); block, UDF_SB_TYPEVIRT(sb, partition).s_num_entries);
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
if (block >= index) if (block >= index) {
{
block -= index; block -= index;
newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t))); newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t)));
index = block % (sb->s_blocksize / sizeof(uint32_t)); index = block % (sb->s_blocksize / sizeof(uint32_t));
} } else {
else
{
newblock = 0; 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); loc = udf_block_map(UDF_SB_VAT(sb), newblock);
if (!(bh = sb_bread(sb, loc))) if (!(bh = sb_bread(sb, loc))) {
{
udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n", udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
sb, block, partition, loc, index); sb, block, partition, loc, index);
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
loc = le32_to_cpu(((__le32 *)bh->b_data)[index]); loc = le32_to_cpu(((__le32 *) bh->b_data)[index]);
brelse(bh); brelse(bh);
if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition) if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition) {
{
udf_debug("recursive call to udf_get_pblock!\n"); udf_debug("recursive call to udf_get_pblock!\n");
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
return udf_get_pblock(sb, loc, UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum, offset); return udf_get_pblock(sb, loc,
UDF_I_LOCATION(UDF_SB_VAT(sb)).
partitionReferenceNum, offset);
} }
inline uint32_t udf_get_pblock_virt20(struct super_block *sb, uint32_t block, uint16_t partition, uint32_t offset) inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
uint16_t partition, uint32_t offset)
{ {
return udf_get_pblock_virt15(sb, block, partition, offset); return udf_get_pblock_virt15(sb, block, partition, offset);
} }
uint32_t udf_get_pblock_spar15(struct super_block *sb, uint32_t block, uint16_t partition, uint32_t offset) uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
uint16_t partition, uint32_t offset)
{ {
int i; int i;
struct sparingTable *st = NULL; 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++) for (i = 0; i < 4; i++) {
{ if (UDF_SB_TYPESPAR(sb, partition).s_spar_map[i] != NULL) {
if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,
{ partition).
st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data; s_spar_map[i]->b_data;
break; break;
} }
} }
if (st) if (st) {
{ for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) {
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; break;
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) + return le32_to_cpu(st->mapEntry[i].
((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1)); mappedLocation) + ((block +
} offset) &
else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) (UDF_SB_TYPESPAR
(sb,
partition).
s_packet_len
- 1));
} else if (le32_to_cpu(st->mapEntry[i].origLocation) >
packet)
break; 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) int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
...@@ -138,19 +152,21 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block) ...@@ -138,19 +152,21 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
uint32_t packet; uint32_t packet;
int i, j, k, l; int i, j, k, l;
for (i=0; i<UDF_SB_NUMPARTS(sb); i++) for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
{ if (old_block > UDF_SB_PARTROOT(sb, i) &&
if (old_block > UDF_SB_PARTROOT(sb,i) && old_block < UDF_SB_PARTROOT(sb, i) + UDF_SB_PARTLEN(sb, i))
old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i))
{ {
sdata = &UDF_SB_TYPESPAR(sb,i); sdata = &UDF_SB_TYPESPAR(sb, i);
packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1); packet =
(old_block -
UDF_SB_PARTROOT(sb,
i)) & ~(sdata->s_packet_len - 1);
for (j=0; j<4; j++) for (j = 0; j < 4; j++) {
{ if (UDF_SB_TYPESPAR(sb, i).s_spar_map[j] !=
if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) NULL) {
{ st = (struct sparingTable *)sdata->
st = (struct sparingTable *)sdata->s_spar_map[j]->b_data; s_spar_map[j]->b_data;
break; break;
} }
} }
...@@ -158,60 +174,123 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block) ...@@ -158,60 +174,123 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
if (!st) if (!st)
return 1; return 1;
for (k=0; k<le16_to_cpu(st->reallocationTableLen); k++) for (k = 0; k < le16_to_cpu(st->reallocationTableLen);
{ k++) {
if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF) if (le32_to_cpu(st->mapEntry[k].origLocation) ==
{ 0xFFFFFFFF) {
for (; j<4; j++) for (; j < 4; j++) {
{ if (sdata->s_spar_map[j]) {
if (sdata->s_spar_map[j]) st = (struct
{ sparingTable *)
st = (struct sparingTable *)sdata->s_spar_map[j]->b_data; sdata->
st->mapEntry[k].origLocation = cpu_to_le32(packet); s_spar_map[j]->
udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry)); b_data;
mark_buffer_dirty(sdata->s_spar_map[j]); 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) + *new_block =
((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1)); le32_to_cpu(st->mapEntry[k].
mappedLocation) +
((old_block -
UDF_SB_PARTROOT(sb,
i)) & (sdata->
s_packet_len
- 1));
return 0; return 0;
} } else
else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) if (le32_to_cpu
{ (st->mapEntry[k].origLocation) ==
*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) + packet) {
((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 0;
} } else
else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) if (le32_to_cpu
(st->mapEntry[k].origLocation) > packet)
break; break;
} }
for (l=k; l<le16_to_cpu(st->reallocationTableLen); l++) for (l = k; l < le16_to_cpu(st->reallocationTableLen);
{ l++) {
if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF) if (le32_to_cpu(st->mapEntry[l].origLocation) ==
{ 0xFFFFFFFF) {
for (; j<4; j++) for (; j < 4; j++) {
{ if (sdata->s_spar_map[j]) {
if (sdata->s_spar_map[j]) st = (struct
{ sparingTable *)
st = (struct sparingTable *)sdata->s_spar_map[j]->b_data; sdata->
mapEntry = st->mapEntry[l]; s_spar_map[j]->
mapEntry.origLocation = cpu_to_le32(packet); b_data;
memmove(&st->mapEntry[k+1], &st->mapEntry[k], (l-k)*sizeof(struct sparingEntry)); mapEntry =
st->mapEntry[k] = mapEntry; st->mapEntry[l];
udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry)); mapEntry.origLocation =
mark_buffer_dirty(sdata->s_spar_map[j]); 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) + *new_block =
((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1)); le32_to_cpu(st->mapEntry[k].
mappedLocation) +
((old_block -
UDF_SB_PARTROOT(sb,
i)) & (sdata->
s_packet_len
- 1));
return 0; return 0;
} }
} }
return 1; return 1;
} }
} }
if (i == UDF_SB_NUMPARTS(sb)) if (i == UDF_SB_NUMPARTS(sb)) {
{
/* outside of partitions */ /* outside of partitions */
/* for now, fail =) */ /* for now, fail =) */
return 1; return 1;
......
fs/udf/super.c
View file @ cb00ea35
...@@ -80,12 +80,15 @@ static int udf_remount_fs(struct super_block *, int *, char *); ...@@ -80,12 +80,15 @@ static int udf_remount_fs(struct super_block *, int *, char *);
static int udf_check_valid(struct super_block *, int, int); static int udf_check_valid(struct super_block *, int, int);
static int udf_vrs(struct super_block *sb, int silent); static int udf_vrs(struct super_block *sb, int silent);
static int udf_load_partition(struct super_block *, kernel_lb_addr *); static int udf_load_partition(struct super_block *, kernel_lb_addr *);
static int udf_load_logicalvol(struct super_block *, struct buffer_head *, kernel_lb_addr *); static int udf_load_logicalvol(struct super_block *, struct buffer_head *,
kernel_lb_addr *);
static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad); static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad);
static void udf_find_anchor(struct super_block *); static void udf_find_anchor(struct super_block *);
static int udf_find_fileset(struct super_block *, kernel_lb_addr *, kernel_lb_addr *); static int udf_find_fileset(struct super_block *, kernel_lb_addr *,
kernel_lb_addr *);
static void udf_load_pvoldesc(struct super_block *, struct buffer_head *); static void udf_load_pvoldesc(struct super_block *, struct buffer_head *);
static void udf_load_fileset(struct super_block *, struct buffer_head *, kernel_lb_addr *); static void udf_load_fileset(struct super_block *, struct buffer_head *,
kernel_lb_addr *);
static void udf_load_partdesc(struct super_block *, struct buffer_head *); static void udf_load_partdesc(struct super_block *, struct buffer_head *);
static void udf_open_lvid(struct super_block *); static void udf_open_lvid(struct super_block *);
static void udf_close_lvid(struct super_block *); static void udf_close_lvid(struct super_block *);
...@@ -94,7 +97,8 @@ static int udf_statfs(struct dentry *, struct kstatfs *); ...@@ -94,7 +97,8 @@ static int udf_statfs(struct dentry *, struct kstatfs *);
/* UDF filesystem type */ /* UDF filesystem type */
static int udf_get_sb(struct file_system_type *fs_type, static int udf_get_sb(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data, struct vfsmount *mnt) int flags, const char *dev_name, void *data,
struct vfsmount *mnt)
{ {
return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt); return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt);
} }
...@@ -107,12 +111,13 @@ static struct file_system_type udf_fstype = { ...@@ -107,12 +111,13 @@ static struct file_system_type udf_fstype = {
.fs_flags = FS_REQUIRES_DEV, .fs_flags = FS_REQUIRES_DEV,
}; };
static struct kmem_cache * udf_inode_cachep; static struct kmem_cache *udf_inode_cachep;
static struct inode *udf_alloc_inode(struct super_block *sb) static struct inode *udf_alloc_inode(struct super_block *sb)
{ {
struct udf_inode_info *ei; struct udf_inode_info *ei;
ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL); ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep,
GFP_KERNEL);
if (!ei) if (!ei)
return NULL; return NULL;
...@@ -130,9 +135,9 @@ static void udf_destroy_inode(struct inode *inode) ...@@ -130,9 +135,9 @@ static void udf_destroy_inode(struct inode *inode)
kmem_cache_free(udf_inode_cachep, UDF_I(inode)); kmem_cache_free(udf_inode_cachep, UDF_I(inode));
} }
static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags) static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
{ {
struct udf_inode_info *ei = (struct udf_inode_info *) foo; struct udf_inode_info *ei = (struct udf_inode_info *)foo;
ei->i_ext.i_data = NULL; ei->i_ext.i_data = NULL;
inode_init_once(&ei->vfs_inode); inode_init_once(&ei->vfs_inode);
...@@ -142,7 +147,7 @@ static int init_inodecache(void) ...@@ -142,7 +147,7 @@ static int init_inodecache(void)
{ {
udf_inode_cachep = kmem_cache_create("udf_inode_cache", udf_inode_cachep = kmem_cache_create("udf_inode_cache",
sizeof(struct udf_inode_info), sizeof(struct udf_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT |
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD),
init_once, NULL); init_once, NULL);
if (udf_inode_cachep == NULL) if (udf_inode_cachep == NULL)
...@@ -168,8 +173,7 @@ static const struct super_operations udf_sb_ops = { ...@@ -168,8 +173,7 @@ static const struct super_operations udf_sb_ops = {
.remount_fs = udf_remount_fs, .remount_fs = udf_remount_fs,
}; };
struct udf_options struct udf_options {
{
unsigned char novrs; unsigned char novrs;
unsigned int blocksize; unsigned int blocksize;
unsigned int session; unsigned int session;
...@@ -196,9 +200,9 @@ static int __init init_udf_fs(void) ...@@ -196,9 +200,9 @@ static int __init init_udf_fs(void)
if (err) if (err)
goto out; goto out;
return 0; return 0;
out: out:
destroy_inodecache(); destroy_inodecache();
out1: out1:
return err; return err;
} }
...@@ -209,7 +213,7 @@ static void __exit exit_udf_fs(void) ...@@ -209,7 +213,7 @@ static void __exit exit_udf_fs(void)
} }
module_init(init_udf_fs) module_init(init_udf_fs)
module_exit(exit_udf_fs) module_exit(exit_udf_fs)
/* /*
* udf_parse_options * udf_parse_options
...@@ -264,7 +268,6 @@ module_exit(exit_udf_fs) ...@@ -264,7 +268,6 @@ module_exit(exit_udf_fs)
* July 1, 1997 - Andrew E. Mileski * July 1, 1997 - Andrew E. Mileski
* Written, tested, and released. * Written, tested, and released.
*/ */
enum { enum {
Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete, Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete,
Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad, Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad,
...@@ -303,8 +306,7 @@ static match_table_t tokens = { ...@@ -303,8 +306,7 @@ static match_table_t tokens = {
{Opt_err, NULL} {Opt_err, NULL}
}; };
static int static int udf_parse_options(char *options, struct udf_options *uopt)
udf_parse_options(char *options, struct udf_options *uopt)
{ {
char *p; char *p;
int option; int option;
...@@ -323,16 +325,14 @@ udf_parse_options(char *options, struct udf_options *uopt) ...@@ -323,16 +325,14 @@ udf_parse_options(char *options, struct udf_options *uopt)
if (!options) if (!options)
return 1; return 1;
while ((p = strsep(&options, ",")) != NULL) while ((p = strsep(&options, ",")) != NULL) {
{
substring_t args[MAX_OPT_ARGS]; substring_t args[MAX_OPT_ARGS];
int token; int token;
if (!*p) if (!*p)
continue; continue;
token = match_token(p, tokens, args); token = match_token(p, tokens, args);
switch (token) switch (token) {
{
case Opt_novrs: case Opt_novrs:
uopt->novrs = 1; uopt->novrs = 1;
case Opt_bs: case Opt_bs:
...@@ -441,8 +441,7 @@ udf_parse_options(char *options, struct udf_options *uopt) ...@@ -441,8 +441,7 @@ udf_parse_options(char *options, struct udf_options *uopt)
return 1; return 1;
} }
void void udf_write_super(struct super_block *sb)
udf_write_super(struct super_block *sb)
{ {
lock_kernel(); lock_kernel();
if (!(sb->s_flags & MS_RDONLY)) if (!(sb->s_flags & MS_RDONLY))
...@@ -451,17 +450,16 @@ udf_write_super(struct super_block *sb) ...@@ -451,17 +450,16 @@ udf_write_super(struct super_block *sb)
unlock_kernel(); unlock_kernel();
} }
static int static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
udf_remount_fs(struct super_block *sb, int *flags, char *options)
{ {
struct udf_options uopt; struct udf_options uopt;
uopt.flags = UDF_SB(sb)->s_flags ; uopt.flags = UDF_SB(sb)->s_flags;
uopt.uid = UDF_SB(sb)->s_uid ; uopt.uid = UDF_SB(sb)->s_uid;
uopt.gid = UDF_SB(sb)->s_gid ; uopt.gid = UDF_SB(sb)->s_gid;
uopt.umask = UDF_SB(sb)->s_umask ; uopt.umask = UDF_SB(sb)->s_umask;
if ( !udf_parse_options(options, &uopt) ) if (!udf_parse_options(options, &uopt))
return -EINVAL; return -EINVAL;
UDF_SB(sb)->s_flags = uopt.flags; UDF_SB(sb)->s_flags = uopt.flags;
...@@ -512,8 +510,7 @@ udf_remount_fs(struct super_block *sb, int *flags, char *options) ...@@ -512,8 +510,7 @@ udf_remount_fs(struct super_block *sb, int *flags, char *options)
* July 1, 1997 - Andrew E. Mileski * July 1, 1997 - Andrew E. Mileski
* Written, tested, and released. * Written, tested, and released.
*/ */
static int static int udf_set_blocksize(struct super_block *sb, int bsize)
udf_set_blocksize(struct super_block *sb, int bsize)
{ {
if (!sb_min_blocksize(sb, bsize)) { if (!sb_min_blocksize(sb, bsize)) {
udf_debug("Bad block size (%d)\n", bsize); udf_debug("Bad block size (%d)\n", bsize);
...@@ -523,16 +520,15 @@ udf_set_blocksize(struct super_block *sb, int bsize) ...@@ -523,16 +520,15 @@ udf_set_blocksize(struct super_block *sb, int bsize)
return sb->s_blocksize; return sb->s_blocksize;
} }
static int static int udf_vrs(struct super_block *sb, int silent)
udf_vrs(struct super_block *sb, int silent)
{ {
struct volStructDesc *vsd = NULL; struct volStructDesc *vsd = NULL;
int sector = 32768; int sector = 32768;
int sectorsize; int sectorsize;
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
int iso9660=0; int iso9660 = 0;
int nsr02=0; int nsr02 = 0;
int nsr03=0; int nsr03 = 0;
/* Block size must be a multiple of 512 */ /* Block size must be a multiple of 512 */
if (sb->s_blocksize & 511) if (sb->s_blocksize & 511)
...@@ -548,8 +544,7 @@ udf_vrs(struct super_block *sb, int silent) ...@@ -548,8 +544,7 @@ udf_vrs(struct super_block *sb, int silent)
udf_debug("Starting at sector %u (%ld byte sectors)\n", udf_debug("Starting at sector %u (%ld byte sectors)\n",
(sector >> sb->s_blocksize_bits), sb->s_blocksize); (sector >> sb->s_blocksize_bits), sb->s_blocksize);
/* Process the sequence (if applicable) */ /* Process the sequence (if applicable) */
for (;!nsr02 && !nsr03; sector += sectorsize) for (; !nsr02 && !nsr03; sector += sectorsize) {
{
/* Read a block */ /* Read a block */
bh = udf_tread(sb, sector >> sb->s_blocksize_bits); bh = udf_tread(sb, sector >> sb->s_blocksize_bits);
if (!bh) if (!bh)
...@@ -557,52 +552,56 @@ udf_vrs(struct super_block *sb, int silent) ...@@ -557,52 +552,56 @@ udf_vrs(struct super_block *sb, int silent)
/* Look for ISO descriptors */ /* Look for ISO descriptors */
vsd = (struct volStructDesc *)(bh->b_data + vsd = (struct volStructDesc *)(bh->b_data +
(sector & (sb->s_blocksize - 1))); (sector &
(sb->s_blocksize - 1)));
if (vsd->stdIdent[0] == 0) if (vsd->stdIdent[0] == 0) {
{
brelse(bh); brelse(bh);
break; break;
} } else
else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN)) if (!strncmp
{ (vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN)) {
iso9660 = sector; iso9660 = sector;
switch (vsd->structType) switch (vsd->structType) {
{
case 0: case 0:
udf_debug("ISO9660 Boot Record found\n"); udf_debug("ISO9660 Boot Record found\n");
break; break;
case 1: case 1:
udf_debug("ISO9660 Primary Volume Descriptor found\n"); udf_debug
("ISO9660 Primary Volume Descriptor found\n");
break; break;
case 2: case 2:
udf_debug("ISO9660 Supplementary Volume Descriptor found\n"); udf_debug
("ISO9660 Supplementary Volume Descriptor found\n");
break; break;
case 3: case 3:
udf_debug("ISO9660 Volume Partition Descriptor found\n"); udf_debug
("ISO9660 Volume Partition Descriptor found\n");
break; break;
case 255: case 255:
udf_debug("ISO9660 Volume Descriptor Set Terminator found\n"); udf_debug
("ISO9660 Volume Descriptor Set Terminator found\n");
break; break;
default: default:
udf_debug("ISO9660 VRS (%u) found\n", vsd->structType); udf_debug("ISO9660 VRS (%u) found\n",
vsd->structType);
break; break;
} }
} } else
else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN)) if (!strncmp
{ (vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN)) {
} } else
else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN)) if (!strncmp
{ (vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN)) {
brelse(bh); brelse(bh);
break; break;
} } else
else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN)) if (!strncmp
{ (vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN)) {
nsr02 = sector; nsr02 = sector;
} } else
else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN)) if (!strncmp
{ (vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN)) {
nsr03 = sector; nsr03 = sector;
} }
brelse(bh); brelse(bh);
...@@ -635,8 +634,7 @@ udf_vrs(struct super_block *sb, int silent) ...@@ -635,8 +634,7 @@ udf_vrs(struct super_block *sb, int silent)
* July 1, 1997 - Andrew E. Mileski * July 1, 1997 - Andrew E. Mileski
* Written, tested, and released. * Written, tested, and released.
*/ */
static void static void udf_find_anchor(struct super_block *sb)
udf_find_anchor(struct super_block *sb)
{ {
int lastblock = UDF_SB_LASTBLOCK(sb); int lastblock = UDF_SB_LASTBLOCK(sb);
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
...@@ -644,13 +642,13 @@ udf_find_anchor(struct super_block *sb) ...@@ -644,13 +642,13 @@ udf_find_anchor(struct super_block *sb)
uint32_t location; uint32_t location;
int i; int i;
if (lastblock) if (lastblock) {
{
int varlastblock = udf_variable_to_fixed(lastblock); int varlastblock = udf_variable_to_fixed(lastblock);
int last[] = { lastblock, lastblock - 2, int last[] = { lastblock, lastblock - 2,
lastblock - 150, lastblock - 152, lastblock - 150, lastblock - 152,
varlastblock, varlastblock - 2, varlastblock, varlastblock - 2,
varlastblock - 150, varlastblock - 152 }; varlastblock - 150, varlastblock - 152
};
lastblock = 0; lastblock = 0;
...@@ -663,90 +661,103 @@ udf_find_anchor(struct super_block *sb) ...@@ -663,90 +661,103 @@ udf_find_anchor(struct super_block *sb)
* however, if the disc isn't closed, it could be 512 */ * however, if the disc isn't closed, it could be 512 */
for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) { for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) {
if (last[i] < 0 || !(bh = sb_bread(sb, last[i]))) if (last[i] < 0 || !(bh = sb_bread(sb, last[i]))) {
{
ident = location = 0; ident = location = 0;
} } else {
else ident =
{ le16_to_cpu(((tag *) bh->b_data)->tagIdent);
ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent); location =
location = le32_to_cpu(((tag *)bh->b_data)->tagLocation); le32_to_cpu(((tag *) bh->b_data)->
tagLocation);
brelse(bh); brelse(bh);
} }
if (ident == TAG_IDENT_AVDP) if (ident == TAG_IDENT_AVDP) {
{ if (location == last[i] - UDF_SB_SESSION(sb)) {
if (location == last[i] - UDF_SB_SESSION(sb)) lastblock = UDF_SB_ANCHOR(sb)[0] =
{ last[i] - UDF_SB_SESSION(sb);
lastblock = UDF_SB_ANCHOR(sb)[0] = last[i] - UDF_SB_SESSION(sb); UDF_SB_ANCHOR(sb)[1] =
UDF_SB_ANCHOR(sb)[1] = last[i] - 256 - UDF_SB_SESSION(sb); last[i] - 256 - UDF_SB_SESSION(sb);
} } else if (location ==
else if (location == udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb)) udf_variable_to_fixed(last[i]) -
{ UDF_SB_SESSION(sb)) {
UDF_SET_FLAG(sb, UDF_FLAG_VARCONV); UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
lastblock = UDF_SB_ANCHOR(sb)[0] = udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb); lastblock = UDF_SB_ANCHOR(sb)[0] =
UDF_SB_ANCHOR(sb)[1] = lastblock - 256 - UDF_SB_SESSION(sb); udf_variable_to_fixed(last[i]) -
} UDF_SB_SESSION(sb);
else UDF_SB_ANCHOR(sb)[1] =
udf_debug("Anchor found at block %d, location mismatch %d.\n", lastblock - 256 -
UDF_SB_SESSION(sb);
} else
udf_debug
("Anchor found at block %d, location mismatch %d.\n",
last[i], location); last[i], location);
} } else if (ident == TAG_IDENT_FE
else if (ident == TAG_IDENT_FE || ident == TAG_IDENT_EFE) || ident == TAG_IDENT_EFE) {
{
lastblock = last[i]; lastblock = last[i];
UDF_SB_ANCHOR(sb)[3] = 512; UDF_SB_ANCHOR(sb)[3] = 512;
} } else {
else if (last[i] < 256
{ || !(bh = sb_bread(sb, last[i] - 256))) {
if (last[i] < 256 || !(bh = sb_bread(sb, last[i] - 256)))
{
ident = location = 0; ident = location = 0;
} } else {
else ident =
{ le16_to_cpu(((tag *) bh->b_data)->
ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent); tagIdent);
location = le32_to_cpu(((tag *)bh->b_data)->tagLocation); location =
le32_to_cpu(((tag *) bh->b_data)->
tagLocation);
brelse(bh); brelse(bh);
} }
if (ident == TAG_IDENT_AVDP && if (ident == TAG_IDENT_AVDP &&
location == last[i] - 256 - UDF_SB_SESSION(sb)) location ==
{ last[i] - 256 - UDF_SB_SESSION(sb)) {
lastblock = last[i]; lastblock = last[i];
UDF_SB_ANCHOR(sb)[1] = last[i] - 256; UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
} } else {
else if (last[i] < 312 + UDF_SB_SESSION(sb)
{ || !(bh =
if (last[i] < 312 + UDF_SB_SESSION(sb) || !(bh = sb_bread(sb, last[i] - 312 - UDF_SB_SESSION(sb)))) sb_bread(sb,
last[i] - 312 -
UDF_SB_SESSION(sb))))
{ {
ident = location = 0; ident = location = 0;
} } else {
else ident =
{ le16_to_cpu(((tag *) bh->
ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent); b_data)->
location = le32_to_cpu(((tag *)bh->b_data)->tagLocation); tagIdent);
location =
le32_to_cpu(((tag *) bh->
b_data)->
tagLocation);
brelse(bh); brelse(bh);
} }
if (ident == TAG_IDENT_AVDP && if (ident == TAG_IDENT_AVDP &&
location == udf_variable_to_fixed(last[i]) - 256) location ==
{ udf_variable_to_fixed(last[i]) -
UDF_SET_FLAG(sb, UDF_FLAG_VARCONV); 256) {
lastblock = udf_variable_to_fixed(last[i]); UDF_SET_FLAG(sb,
UDF_SB_ANCHOR(sb)[1] = lastblock - 256; UDF_FLAG_VARCONV);
lastblock =
udf_variable_to_fixed(last
[i]);
UDF_SB_ANCHOR(sb)[1] =
lastblock - 256;
} }
} }
} }
} }
} }
if (!lastblock) if (!lastblock) {
{
/* We havn't found the lastblock. check 312 */ /* We havn't found the lastblock. check 312 */
if ((bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb)))) if ((bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb)))) {
{ ident = le16_to_cpu(((tag *) bh->b_data)->tagIdent);
ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent); location =
location = le32_to_cpu(((tag *)bh->b_data)->tagLocation); le32_to_cpu(((tag *) bh->b_data)->tagLocation);
brelse(bh); brelse(bh);
if (ident == TAG_IDENT_AVDP && location == 256) if (ident == TAG_IDENT_AVDP && location == 256)
...@@ -755,18 +766,19 @@ udf_find_anchor(struct super_block *sb) ...@@ -755,18 +766,19 @@ udf_find_anchor(struct super_block *sb)
} }
for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) { for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
if (UDF_SB_ANCHOR(sb)[i]) if (UDF_SB_ANCHOR(sb)[i]) {
{
if (!(bh = udf_read_tagged(sb, if (!(bh = udf_read_tagged(sb,
UDF_SB_ANCHOR(sb)[i], UDF_SB_ANCHOR(sb)[i], &ident))) UDF_SB_ANCHOR(sb)[i],
{ UDF_SB_ANCHOR(sb)[i],
&ident))) {
UDF_SB_ANCHOR(sb)[i] = 0; UDF_SB_ANCHOR(sb)[i] = 0;
} } else {
else
{
brelse(bh); brelse(bh);
if ((ident != TAG_IDENT_AVDP) && (i || if ((ident != TAG_IDENT_AVDP) && (i ||
(ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE))) (ident !=
TAG_IDENT_FE
&& ident !=
TAG_IDENT_EFE)))
{ {
UDF_SB_ANCHOR(sb)[i] = 0; UDF_SB_ANCHOR(sb)[i] = 0;
} }
...@@ -778,59 +790,62 @@ udf_find_anchor(struct super_block *sb) ...@@ -778,59 +790,62 @@ udf_find_anchor(struct super_block *sb)
} }
static int static int
udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr *root) udf_find_fileset(struct super_block *sb, kernel_lb_addr * fileset,
kernel_lb_addr * root)
{ {
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
long lastblock; long lastblock;
uint16_t ident; uint16_t ident;
if (fileset->logicalBlockNum != 0xFFFFFFFF || if (fileset->logicalBlockNum != 0xFFFFFFFF ||
fileset->partitionReferenceNum != 0xFFFF) fileset->partitionReferenceNum != 0xFFFF) {
{
bh = udf_read_ptagged(sb, *fileset, 0, &ident); bh = udf_read_ptagged(sb, *fileset, 0, &ident);
if (!bh) if (!bh)
return 1; return 1;
else if (ident != TAG_IDENT_FSD) else if (ident != TAG_IDENT_FSD) {
{
brelse(bh); brelse(bh);
return 1; return 1;
} }
} }
if (!bh) /* Search backwards through the partitions */ if (!bh) { /* Search backwards through the partitions */
{
kernel_lb_addr newfileset; kernel_lb_addr newfileset;
return 1; return 1;
for (newfileset.partitionReferenceNum=UDF_SB_NUMPARTS(sb)-1; for (newfileset.partitionReferenceNum = UDF_SB_NUMPARTS(sb) - 1;
(newfileset.partitionReferenceNum != 0xFFFF && (newfileset.partitionReferenceNum != 0xFFFF &&
fileset->logicalBlockNum == 0xFFFFFFFF && fileset->logicalBlockNum == 0xFFFFFFFF &&
fileset->partitionReferenceNum == 0xFFFF); fileset->partitionReferenceNum == 0xFFFF);
newfileset.partitionReferenceNum--) newfileset.partitionReferenceNum--) {
{ lastblock =
lastblock = UDF_SB_PARTLEN(sb, newfileset.partitionReferenceNum); UDF_SB_PARTLEN(sb,
newfileset.partitionReferenceNum);
newfileset.logicalBlockNum = 0; newfileset.logicalBlockNum = 0;
do do {
{ bh = udf_read_ptagged(sb, newfileset, 0,
bh = udf_read_ptagged(sb, newfileset, 0, &ident); &ident);
if (!bh) if (!bh) {
{ newfileset.logicalBlockNum++;
newfileset.logicalBlockNum ++;
continue; continue;
} }
switch (ident) switch (ident) {
{
case TAG_IDENT_SBD: case TAG_IDENT_SBD:
{ {
struct spaceBitmapDesc *sp; struct spaceBitmapDesc *sp;
sp = (struct spaceBitmapDesc *)bh->b_data; sp = (struct spaceBitmapDesc *)
newfileset.logicalBlockNum += 1 + bh->b_data;
((le32_to_cpu(sp->numOfBytes) + sizeof(struct spaceBitmapDesc) - 1) newfileset.logicalBlockNum +=
1 +
((le32_to_cpu
(sp->numOfBytes) +
sizeof(struct
spaceBitmapDesc) -
1)
>> sb->s_blocksize_bits); >> sb->s_blocksize_bits);
brelse(bh); brelse(bh);
break; break;
...@@ -842,7 +857,7 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr ...@@ -842,7 +857,7 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr
} }
default: default:
{ {
newfileset.logicalBlockNum ++; newfileset.logicalBlockNum++;
brelse(bh); brelse(bh);
bh = NULL; bh = NULL;
break; break;
...@@ -856,10 +871,10 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr ...@@ -856,10 +871,10 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr
} }
if ((fileset->logicalBlockNum != 0xFFFFFFFF || if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
fileset->partitionReferenceNum != 0xFFFF) && bh) fileset->partitionReferenceNum != 0xFFFF) && bh) {
{
udf_debug("Fileset at block=%d, partition=%d\n", udf_debug("Fileset at block=%d, partition=%d\n",
fileset->logicalBlockNum, fileset->partitionReferenceNum); fileset->logicalBlockNum,
fileset->partitionReferenceNum);
UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum; UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;
udf_load_fileset(sb, bh, root); udf_load_fileset(sb, bh, root);
...@@ -869,8 +884,7 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr ...@@ -869,8 +884,7 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr
return 1; return 1;
} }
static void static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
{ {
struct primaryVolDesc *pvoldesc; struct primaryVolDesc *pvoldesc;
time_t recording; time_t recording;
...@@ -880,37 +894,35 @@ udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh) ...@@ -880,37 +894,35 @@ udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
pvoldesc = (struct primaryVolDesc *)bh->b_data; pvoldesc = (struct primaryVolDesc *)bh->b_data;
if ( udf_stamp_to_time(&recording, &recording_usec, if (udf_stamp_to_time(&recording, &recording_usec,
lets_to_cpu(pvoldesc->recordingDateAndTime)) ) lets_to_cpu(pvoldesc->recordingDateAndTime))) {
{
kernel_timestamp ts; kernel_timestamp ts;
ts = lets_to_cpu(pvoldesc->recordingDateAndTime); ts = lets_to_cpu(pvoldesc->recordingDateAndTime);
udf_debug("recording time %ld/%ld, %04u/%02u/%02u %02u:%02u (%x)\n", udf_debug
recording, recording_usec, ("recording time %ld/%ld, %04u/%02u/%02u %02u:%02u (%x)\n",
ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.typeAndTimezone); recording, recording_usec, ts.year, ts.month, ts.day,
ts.hour, ts.minute, ts.typeAndTimezone);
UDF_SB_RECORDTIME(sb).tv_sec = recording; UDF_SB_RECORDTIME(sb).tv_sec = recording;
UDF_SB_RECORDTIME(sb).tv_nsec = recording_usec * 1000; UDF_SB_RECORDTIME(sb).tv_nsec = recording_usec * 1000;
} }
if ( !udf_build_ustr(&instr, pvoldesc->volIdent, 32) ) if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32)) {
{ if (udf_CS0toUTF8(&outstr, &instr)) {
if (udf_CS0toUTF8(&outstr, &instr)) strncpy(UDF_SB_VOLIDENT(sb), outstr.u_name,
{
strncpy( UDF_SB_VOLIDENT(sb), outstr.u_name,
outstr.u_len > 31 ? 31 : outstr.u_len); outstr.u_len > 31 ? 31 : outstr.u_len);
udf_debug("volIdent[] = '%s'\n", UDF_SB_VOLIDENT(sb)); udf_debug("volIdent[] = '%s'\n", UDF_SB_VOLIDENT(sb));
} }
} }
if ( !udf_build_ustr(&instr, pvoldesc->volSetIdent, 128) ) if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128)) {
{
if (udf_CS0toUTF8(&outstr, &instr)) if (udf_CS0toUTF8(&outstr, &instr))
udf_debug("volSetIdent[] = '%s'\n", outstr.u_name); udf_debug("volSetIdent[] = '%s'\n", outstr.u_name);
} }
} }
static void static void
udf_load_fileset(struct super_block *sb, struct buffer_head *bh, kernel_lb_addr *root) udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
kernel_lb_addr * root)
{ {
struct fileSetDesc *fset; struct fileSetDesc *fset;
...@@ -924,105 +936,150 @@ udf_load_fileset(struct super_block *sb, struct buffer_head *bh, kernel_lb_addr ...@@ -924,105 +936,150 @@ udf_load_fileset(struct super_block *sb, struct buffer_head *bh, kernel_lb_addr
root->logicalBlockNum, root->partitionReferenceNum); root->logicalBlockNum, root->partitionReferenceNum);
} }
static void static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
{ {
struct partitionDesc *p; struct partitionDesc *p;
int i; int i;
p = (struct partitionDesc *)bh->b_data; p = (struct partitionDesc *)bh->b_data;
for (i=0; i<UDF_SB_NUMPARTS(sb); i++) for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
{
udf_debug("Searching map: (%d == %d)\n", udf_debug("Searching map: (%d == %d)\n",
UDF_SB_PARTMAPS(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber)); UDF_SB_PARTMAPS(sb)[i].s_partition_num,
if (UDF_SB_PARTMAPS(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) le16_to_cpu(p->partitionNumber));
{ if (UDF_SB_PARTMAPS(sb)[i].s_partition_num ==
UDF_SB_PARTLEN(sb,i) = le32_to_cpu(p->partitionLength); /* blocks */ le16_to_cpu(p->partitionNumber)) {
UDF_SB_PARTROOT(sb,i) = le32_to_cpu(p->partitionStartingLocation); UDF_SB_PARTLEN(sb, i) = le32_to_cpu(p->partitionLength); /* blocks */
if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_READ_ONLY) UDF_SB_PARTROOT(sb, i) =
UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_READ_ONLY; le32_to_cpu(p->partitionStartingLocation);
if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_WRITE_ONCE) if (le32_to_cpu(p->accessType) ==
UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_WRITE_ONCE; PD_ACCESS_TYPE_READ_ONLY)
if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_REWRITABLE) UDF_SB_PARTFLAGS(sb, i) |=
UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_REWRITABLE; UDF_PART_FLAG_READ_ONLY;
if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_OVERWRITABLE) if (le32_to_cpu(p->accessType) ==
UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_OVERWRITABLE; PD_ACCESS_TYPE_WRITE_ONCE)
UDF_SB_PARTFLAGS(sb, i) |=
if (!strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) || UDF_PART_FLAG_WRITE_ONCE;
!strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03)) if (le32_to_cpu(p->accessType) ==
{ PD_ACCESS_TYPE_REWRITABLE)
UDF_SB_PARTFLAGS(sb, i) |=
UDF_PART_FLAG_REWRITABLE;
if (le32_to_cpu(p->accessType) ==
PD_ACCESS_TYPE_OVERWRITABLE)
UDF_SB_PARTFLAGS(sb, i) |=
UDF_PART_FLAG_OVERWRITABLE;
if (!strcmp
(p->partitionContents.ident,
PD_PARTITION_CONTENTS_NSR02)
|| !strcmp(p->partitionContents.ident,
PD_PARTITION_CONTENTS_NSR03)) {
struct partitionHeaderDesc *phd; struct partitionHeaderDesc *phd;
phd = (struct partitionHeaderDesc *)(p->partitionContentsUse); phd =
if (phd->unallocSpaceTable.extLength) (struct partitionHeaderDesc *)(p->
{ partitionContentsUse);
kernel_lb_addr loc = { le32_to_cpu(phd->unallocSpaceTable.extPosition), i }; if (phd->unallocSpaceTable.extLength) {
kernel_lb_addr loc =
UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table = { le32_to_cpu(phd->
udf_iget(sb, loc); unallocSpaceTable.
UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_TABLE; extPosition), i };
udf_debug("unallocSpaceTable (part %d) @ %ld\n",
i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table->i_ino); UDF_SB_PARTMAPS(sb)[i].s_uspace.
} s_table = udf_iget(sb, loc);
if (phd->unallocSpaceBitmap.extLength) UDF_SB_PARTFLAGS(sb, i) |=
{ UDF_PART_FLAG_UNALLOC_TABLE;
udf_debug
("unallocSpaceTable (part %d) @ %ld\n",
i,
UDF_SB_PARTMAPS(sb)[i].s_uspace.
s_table->i_ino);
}
if (phd->unallocSpaceBitmap.extLength) {
UDF_SB_ALLOC_BITMAP(sb, i, s_uspace); UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
if (UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap != NULL) if (UDF_SB_PARTMAPS(sb)[i].s_uspace.
{ s_bitmap != NULL) {
UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extLength = UDF_SB_PARTMAPS(sb)[i].s_uspace.
le32_to_cpu(phd->unallocSpaceBitmap.extLength); s_bitmap->s_extLength =
UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition = le32_to_cpu(phd->
le32_to_cpu(phd->unallocSpaceBitmap.extPosition); unallocSpaceBitmap.
UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_BITMAP; extLength);
udf_debug("unallocSpaceBitmap (part %d) @ %d\n", UDF_SB_PARTMAPS(sb)[i].s_uspace.
i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition); s_bitmap->s_extPosition =
le32_to_cpu(phd->
unallocSpaceBitmap.
extPosition);
UDF_SB_PARTFLAGS(sb, i) |=
UDF_PART_FLAG_UNALLOC_BITMAP;
udf_debug
("unallocSpaceBitmap (part %d) @ %d\n",
i,
UDF_SB_PARTMAPS(sb)[i].
s_uspace.s_bitmap->
s_extPosition);
} }
} }
if (phd->partitionIntegrityTable.extLength) if (phd->partitionIntegrityTable.extLength)
udf_debug("partitionIntegrityTable (part %d)\n", i); udf_debug
if (phd->freedSpaceTable.extLength) ("partitionIntegrityTable (part %d)\n",
{ i);
kernel_lb_addr loc = { le32_to_cpu(phd->freedSpaceTable.extPosition), i }; if (phd->freedSpaceTable.extLength) {
kernel_lb_addr loc =
UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table = { le32_to_cpu(phd->freedSpaceTable.
udf_iget(sb, loc); extPosition), i };
UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_TABLE;
udf_debug("freedSpaceTable (part %d) @ %ld\n", UDF_SB_PARTMAPS(sb)[i].s_fspace.
i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table->i_ino); s_table = udf_iget(sb, loc);
} UDF_SB_PARTFLAGS(sb, i) |=
if (phd->freedSpaceBitmap.extLength) UDF_PART_FLAG_FREED_TABLE;
{ udf_debug
("freedSpaceTable (part %d) @ %ld\n",
i,
UDF_SB_PARTMAPS(sb)[i].s_fspace.
s_table->i_ino);
}
if (phd->freedSpaceBitmap.extLength) {
UDF_SB_ALLOC_BITMAP(sb, i, s_fspace); UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
if (UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap != NULL) if (UDF_SB_PARTMAPS(sb)[i].s_fspace.
{ s_bitmap != NULL) {
UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extLength = UDF_SB_PARTMAPS(sb)[i].s_fspace.
le32_to_cpu(phd->freedSpaceBitmap.extLength); s_bitmap->s_extLength =
UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition = le32_to_cpu(phd->
le32_to_cpu(phd->freedSpaceBitmap.extPosition); freedSpaceBitmap.
UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_BITMAP; extLength);
udf_debug("freedSpaceBitmap (part %d) @ %d\n", UDF_SB_PARTMAPS(sb)[i].s_fspace.
i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition); s_bitmap->s_extPosition =
le32_to_cpu(phd->
freedSpaceBitmap.
extPosition);
UDF_SB_PARTFLAGS(sb, i) |=
UDF_PART_FLAG_FREED_BITMAP;
udf_debug
("freedSpaceBitmap (part %d) @ %d\n",
i,
UDF_SB_PARTMAPS(sb)[i].
s_fspace.s_bitmap->
s_extPosition);
} }
} }
} }
break; break;
} }
} }
if (i == UDF_SB_NUMPARTS(sb)) if (i == UDF_SB_NUMPARTS(sb)) {
{ udf_debug("Partition (%d) not found in partition map\n",
udf_debug("Partition (%d) not found in partition map\n", le16_to_cpu(p->partitionNumber)); le16_to_cpu(p->partitionNumber));
} } else {
else udf_debug
{ ("Partition (%d:%d type %x) starts at physical %d, block length %d\n",
udf_debug("Partition (%d:%d type %x) starts at physical %d, block length %d\n", le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb, i),
le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb,i), UDF_SB_PARTROOT(sb, i), UDF_SB_PARTLEN(sb, i));
UDF_SB_PARTROOT(sb,i), UDF_SB_PARTLEN(sb,i));
} }
} }
static int static int
udf_load_logicalvol(struct super_block *sb, struct buffer_head * bh, kernel_lb_addr *fileset) udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
kernel_lb_addr * fileset)
{ {
struct logicalVolDesc *lvd; struct logicalVolDesc *lvd;
int i, j, offset; int i, j, offset;
...@@ -1032,82 +1089,114 @@ udf_load_logicalvol(struct super_block *sb, struct buffer_head * bh, kernel_lb_a ...@@ -1032,82 +1089,114 @@ udf_load_logicalvol(struct super_block *sb, struct buffer_head * bh, kernel_lb_a
UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps)); UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps));
for (i=0,offset=0; for (i = 0, offset = 0;
i<UDF_SB_NUMPARTS(sb) && offset<le32_to_cpu(lvd->mapTableLength); i < UDF_SB_NUMPARTS(sb)
i++,offset+=((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapLength) && offset < le32_to_cpu(lvd->mapTableLength);
{ i++, offset +=
type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType; ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->
if (type == 1) partitionMapLength) {
{ type =
struct genericPartitionMap1 *gpm1 = (struct genericPartitionMap1 *)&(lvd->partitionMaps[offset]); ((struct genericPartitionMap *)
UDF_SB_PARTTYPE(sb,i) = UDF_TYPE1_MAP15; &(lvd->partitionMaps[offset]))->partitionMapType;
UDF_SB_PARTVSN(sb,i) = le16_to_cpu(gpm1->volSeqNum); if (type == 1) {
UDF_SB_PARTNUM(sb,i) = le16_to_cpu(gpm1->partitionNum); struct genericPartitionMap1 *gpm1 =
UDF_SB_PARTFUNC(sb,i) = NULL; (struct genericPartitionMap1 *)&(lvd->
} partitionMaps
else if (type == 2) [offset]);
{ UDF_SB_PARTTYPE(sb, i) = UDF_TYPE1_MAP15;
struct udfPartitionMap2 *upm2 = (struct udfPartitionMap2 *)&(lvd->partitionMaps[offset]); UDF_SB_PARTVSN(sb, i) = le16_to_cpu(gpm1->volSeqNum);
if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL))) UDF_SB_PARTNUM(sb, i) = le16_to_cpu(gpm1->partitionNum);
{ UDF_SB_PARTFUNC(sb, i) = NULL;
if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0150) } else if (type == 2) {
{ struct udfPartitionMap2 *upm2 =
UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP15; (struct udfPartitionMap2 *)&(lvd->
UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt15; partitionMaps[offset]);
} if (!strncmp
else if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0200) (upm2->partIdent.ident, UDF_ID_VIRTUAL,
{ strlen(UDF_ID_VIRTUAL))) {
UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP20; if (le16_to_cpu
UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt20; (((__le16 *) upm2->partIdent.
} identSuffix)[0]) == 0x0150) {
UDF_SB_PARTTYPE(sb, i) =
UDF_VIRTUAL_MAP15;
UDF_SB_PARTFUNC(sb, i) =
udf_get_pblock_virt15;
} else
if (le16_to_cpu
(((__le16 *) upm2->partIdent.
identSuffix)[0]) == 0x0200) {
UDF_SB_PARTTYPE(sb, i) =
UDF_VIRTUAL_MAP20;
UDF_SB_PARTFUNC(sb, i) =
udf_get_pblock_virt20;
} }
else if (!strncmp(upm2->partIdent.ident, UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE))) } else
{ if (!strncmp
(upm2->partIdent.ident, UDF_ID_SPARABLE,
strlen(UDF_ID_SPARABLE))) {
uint32_t loc; uint32_t loc;
uint16_t ident; uint16_t ident;
struct sparingTable *st; struct sparingTable *st;
struct sparablePartitionMap *spm = (struct sparablePartitionMap *)&(lvd->partitionMaps[offset]); struct sparablePartitionMap *spm =
(struct sparablePartitionMap *)&(lvd->
UDF_SB_PARTTYPE(sb,i) = UDF_SPARABLE_MAP15; partitionMaps
UDF_SB_TYPESPAR(sb,i).s_packet_len = le16_to_cpu(spm->packetLength); [offset]);
for (j=0; j<spm->numSparingTables; j++)
{ UDF_SB_PARTTYPE(sb, i) = UDF_SPARABLE_MAP15;
loc = le32_to_cpu(spm->locSparingTable[j]); UDF_SB_TYPESPAR(sb, i).s_packet_len =
UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = le16_to_cpu(spm->packetLength);
udf_read_tagged(sb, loc, loc, &ident); for (j = 0; j < spm->numSparingTables; j++) {
if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) loc =
{ le32_to_cpu(spm->
st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,i).s_spar_map[j]->b_data; locSparingTable[j]);
if (ident != 0 || UDF_SB_TYPESPAR(sb, i).s_spar_map[j] =
strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING))) udf_read_tagged(sb, loc, loc,
{ &ident);
brelse(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]); if (UDF_SB_TYPESPAR(sb, i).
UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL; s_spar_map[j] != NULL) {
} st = (struct sparingTable *)
} UDF_SB_TYPESPAR(sb,
} i).
UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_spar15; s_spar_map[j]->b_data;
} if (ident != 0
else || strncmp(st->sparingIdent.
{ ident,
udf_debug("Unknown ident: %s\n", upm2->partIdent.ident); UDF_ID_SPARING,
strlen
(UDF_ID_SPARING)))
{
brelse(UDF_SB_TYPESPAR
(sb,
i).
s_spar_map[j]);
UDF_SB_TYPESPAR(sb,
i).
s_spar_map[j] =
NULL;
}
}
}
UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_spar15;
} else {
udf_debug("Unknown ident: %s\n",
upm2->partIdent.ident);
continue; continue;
} }
UDF_SB_PARTVSN(sb,i) = le16_to_cpu(upm2->volSeqNum); UDF_SB_PARTVSN(sb, i) = le16_to_cpu(upm2->volSeqNum);
UDF_SB_PARTNUM(sb,i) = le16_to_cpu(upm2->partitionNum); UDF_SB_PARTNUM(sb, i) = le16_to_cpu(upm2->partitionNum);
} }
udf_debug("Partition (%d:%d) type %d on volume %d\n", udf_debug("Partition (%d:%d) type %d on volume %d\n",
i, UDF_SB_PARTNUM(sb,i), type, UDF_SB_PARTVSN(sb,i)); i, UDF_SB_PARTNUM(sb, i), type, UDF_SB_PARTVSN(sb,
i));
} }
if (fileset) if (fileset) {
{ long_ad *la = (long_ad *) & (lvd->logicalVolContentsUse[0]);
long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
*fileset = lelb_to_cpu(la->extLocation); *fileset = lelb_to_cpu(la->extLocation);
udf_debug("FileSet found in LogicalVolDesc at block=%d, partition=%d\n", udf_debug
fileset->logicalBlockNum, ("FileSet found in LogicalVolDesc at block=%d, partition=%d\n",
fileset->partitionReferenceNum); fileset->logicalBlockNum, fileset->partitionReferenceNum);
} }
if (lvd->integritySeqExt.extLength) if (lvd->integritySeqExt.extLength)
udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt)); udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
...@@ -1118,8 +1207,7 @@ udf_load_logicalvol(struct super_block *sb, struct buffer_head * bh, kernel_lb_a ...@@ -1118,8 +1207,7 @@ udf_load_logicalvol(struct super_block *sb, struct buffer_head * bh, kernel_lb_a
* udf_load_logicalvolint * udf_load_logicalvolint
* *
*/ */
static void static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
{ {
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
uint16_t ident; uint16_t ident;
...@@ -1127,17 +1215,18 @@ udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc) ...@@ -1127,17 +1215,18 @@ udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
while (loc.extLength > 0 && while (loc.extLength > 0 &&
(bh = udf_read_tagged(sb, loc.extLocation, (bh = udf_read_tagged(sb, loc.extLocation,
loc.extLocation, &ident)) && loc.extLocation, &ident)) &&
ident == TAG_IDENT_LVID) ident == TAG_IDENT_LVID) {
{
UDF_SB_LVIDBH(sb) = bh; UDF_SB_LVIDBH(sb) = bh;
if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength) if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength)
udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt)); udf_load_logicalvolint(sb,
leea_to_cpu(UDF_SB_LVID(sb)->
nextIntegrityExt));
if (UDF_SB_LVIDBH(sb) != bh) if (UDF_SB_LVIDBH(sb) != bh)
brelse(bh); brelse(bh);
loc.extLength -= sb->s_blocksize; loc.extLength -= sb->s_blocksize;
loc.extLocation ++; loc.extLocation++;
} }
if (UDF_SB_LVIDBH(sb) != bh) if (UDF_SB_LVIDBH(sb) != bh)
brelse(bh); brelse(bh);
...@@ -1159,14 +1248,15 @@ udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc) ...@@ -1159,14 +1248,15 @@ udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
* Written, tested, and released. * Written, tested, and released.
*/ */
static int static int
udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_lb_addr *fileset) udf_process_sequence(struct super_block *sb, long block, long lastblock,
kernel_lb_addr * fileset)
{ {
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
struct udf_vds_record vds[VDS_POS_LENGTH]; struct udf_vds_record vds[VDS_POS_LENGTH];
struct generic_desc *gd; struct generic_desc *gd;
struct volDescPtr *vdp; struct volDescPtr *vdp;
int done=0; int done = 0;
int i,j; int i, j;
uint32_t vdsn; uint32_t vdsn;
uint16_t ident; uint16_t ident;
long next_s = 0, next_e = 0; long next_s = 0, next_e = 0;
...@@ -1174,8 +1264,7 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_ ...@@ -1174,8 +1264,7 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_
memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH); memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);
/* Read the main descriptor sequence */ /* Read the main descriptor sequence */
for (;(!done && block <= lastblock); block++) for (; (!done && block <= lastblock); block++) {
{
bh = udf_read_tagged(sb, block, block, &ident); bh = udf_read_tagged(sb, block, block, &ident);
if (!bh) if (!bh)
...@@ -1184,32 +1273,34 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_ ...@@ -1184,32 +1273,34 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_
/* Process each descriptor (ISO 13346 3/8.3-8.4) */ /* Process each descriptor (ISO 13346 3/8.3-8.4) */
gd = (struct generic_desc *)bh->b_data; gd = (struct generic_desc *)bh->b_data;
vdsn = le32_to_cpu(gd->volDescSeqNum); vdsn = le32_to_cpu(gd->volDescSeqNum);
switch (ident) switch (ident) {
{
case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */ case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
if (vdsn >= vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum) if (vdsn >= vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum) {
{ vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum =
vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum = vdsn; vdsn;
vds[VDS_POS_PRIMARY_VOL_DESC].block = block; vds[VDS_POS_PRIMARY_VOL_DESC].block = block;
} }
break; break;
case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */ case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
if (vdsn >= vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum) if (vdsn >= vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum) {
{
vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum = vdsn; vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum = vdsn;
vds[VDS_POS_VOL_DESC_PTR].block = block; vds[VDS_POS_VOL_DESC_PTR].block = block;
vdp = (struct volDescPtr *)bh->b_data; vdp = (struct volDescPtr *)bh->b_data;
next_s = le32_to_cpu(vdp->nextVolDescSeqExt.extLocation); next_s =
next_e = le32_to_cpu(vdp->nextVolDescSeqExt.extLength); le32_to_cpu(vdp->nextVolDescSeqExt.
extLocation);
next_e =
le32_to_cpu(vdp->nextVolDescSeqExt.
extLength);
next_e = next_e >> sb->s_blocksize_bits; next_e = next_e >> sb->s_blocksize_bits;
next_e += next_s; next_e += next_s;
} }
break; break;
case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */ case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
if (vdsn >= vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum) if (vdsn >= vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum) {
{ vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum =
vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum = vdsn; vdsn;
vds[VDS_POS_IMP_USE_VOL_DESC].block = block; vds[VDS_POS_IMP_USE_VOL_DESC].block = block;
} }
break; break;
...@@ -1218,49 +1309,47 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_ ...@@ -1218,49 +1309,47 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_
vds[VDS_POS_PARTITION_DESC].block = block; vds[VDS_POS_PARTITION_DESC].block = block;
break; break;
case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */ case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
if (vdsn >= vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum) if (vdsn >= vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum) {
{ vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum =
vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum = vdsn; vdsn;
vds[VDS_POS_LOGICAL_VOL_DESC].block = block; vds[VDS_POS_LOGICAL_VOL_DESC].block = block;
} }
break; break;
case TAG_IDENT_USD: /* ISO 13346 3/10.8 */ case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
if (vdsn >= vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum) if (vdsn >=
{ vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum) {
vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum = vdsn; vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum =
vdsn;
vds[VDS_POS_UNALLOC_SPACE_DESC].block = block; vds[VDS_POS_UNALLOC_SPACE_DESC].block = block;
} }
break; break;
case TAG_IDENT_TD: /* ISO 13346 3/10.9 */ case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
vds[VDS_POS_TERMINATING_DESC].block = block; vds[VDS_POS_TERMINATING_DESC].block = block;
if (next_e) if (next_e) {
{
block = next_s; block = next_s;
lastblock = next_e; lastblock = next_e;
next_s = next_e = 0; next_s = next_e = 0;
} } else
else
done = 1; done = 1;
break; break;
} }
brelse(bh); brelse(bh);
} }
for (i=0; i<VDS_POS_LENGTH; i++) for (i = 0; i < VDS_POS_LENGTH; i++) {
{ if (vds[i].block) {
if (vds[i].block) bh = udf_read_tagged(sb, vds[i].block, vds[i].block,
{ &ident);
bh = udf_read_tagged(sb, vds[i].block, vds[i].block, &ident);
if (i == VDS_POS_PRIMARY_VOL_DESC) if (i == VDS_POS_PRIMARY_VOL_DESC)
udf_load_pvoldesc(sb, bh); udf_load_pvoldesc(sb, bh);
else if (i == VDS_POS_LOGICAL_VOL_DESC) else if (i == VDS_POS_LOGICAL_VOL_DESC)
udf_load_logicalvol(sb, bh, fileset); udf_load_logicalvol(sb, bh, fileset);
else if (i == VDS_POS_PARTITION_DESC) else if (i == VDS_POS_PARTITION_DESC) {
{
struct buffer_head *bh2 = NULL; struct buffer_head *bh2 = NULL;
udf_load_partdesc(sb, bh); udf_load_partdesc(sb, bh);
for (j=vds[i].block+1; j<vds[VDS_POS_TERMINATING_DESC].block; j++) for (j = vds[i].block + 1;
{ j < vds[VDS_POS_TERMINATING_DESC].block;
j++) {
bh2 = udf_read_tagged(sb, j, j, &ident); bh2 = udf_read_tagged(sb, j, j, &ident);
gd = (struct generic_desc *)bh2->b_data; gd = (struct generic_desc *)bh2->b_data;
if (ident == TAG_IDENT_PD) if (ident == TAG_IDENT_PD)
...@@ -1278,31 +1367,27 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_ ...@@ -1278,31 +1367,27 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_
/* /*
* udf_check_valid() * udf_check_valid()
*/ */
static int static int udf_check_valid(struct super_block *sb, int novrs, int silent)
udf_check_valid(struct super_block *sb, int novrs, int silent)
{ {
long block; long block;
if (novrs) if (novrs) {
{
udf_debug("Validity check skipped because of novrs option\n"); udf_debug("Validity check skipped because of novrs option\n");
return 0; return 0;
} }
/* Check that it is NSR02 compliant */ /* Check that it is NSR02 compliant */
/* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */ /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
else if ((block = udf_vrs(sb, silent)) == -1) else if ((block = udf_vrs(sb, silent)) == -1) {
{ udf_debug
udf_debug("Failed to read byte 32768. Assuming open disc. Skipping validity check\n"); ("Failed to read byte 32768. Assuming open disc. Skipping validity check\n");
if (!UDF_SB_LASTBLOCK(sb)) if (!UDF_SB_LASTBLOCK(sb))
UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb); UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
return 0; return 0;
} } else
else
return !block; return !block;
} }
static int static int udf_load_partition(struct super_block *sb, kernel_lb_addr * fileset)
udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
{ {
struct anchorVolDescPtr *anchor; struct anchorVolDescPtr *anchor;
uint16_t ident; uint16_t ident;
...@@ -1315,19 +1400,27 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) ...@@ -1315,19 +1400,27 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) { for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
if (UDF_SB_ANCHOR(sb)[i] && (bh = udf_read_tagged(sb, if (UDF_SB_ANCHOR(sb)[i] && (bh = udf_read_tagged(sb,
UDF_SB_ANCHOR(sb)[i], UDF_SB_ANCHOR(sb)[i], &ident))) UDF_SB_ANCHOR
{ (sb)[i],
UDF_SB_ANCHOR
(sb)[i],
&ident))) {
anchor = (struct anchorVolDescPtr *)bh->b_data; anchor = (struct anchorVolDescPtr *)bh->b_data;
/* Locate the main sequence */ /* Locate the main sequence */
main_s = le32_to_cpu( anchor->mainVolDescSeqExt.extLocation ); main_s =
main_e = le32_to_cpu( anchor->mainVolDescSeqExt.extLength ); le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
main_e =
le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
main_e = main_e >> sb->s_blocksize_bits; main_e = main_e >> sb->s_blocksize_bits;
main_e += main_s; main_e += main_s;
/* Locate the reserve sequence */ /* Locate the reserve sequence */
reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation); reserve_s =
reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength); le32_to_cpu(anchor->reserveVolDescSeqExt.
extLocation);
reserve_e =
le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
reserve_e = reserve_e >> sb->s_blocksize_bits; reserve_e = reserve_e >> sb->s_blocksize_bits;
reserve_e += reserve_s; reserve_e += reserve_s;
...@@ -1335,9 +1428,10 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) ...@@ -1335,9 +1428,10 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
/* Process the main & reserve sequences */ /* Process the main & reserve sequences */
/* responsible for finding the PartitionDesc(s) */ /* responsible for finding the PartitionDesc(s) */
if (!(udf_process_sequence(sb, main_s, main_e, fileset) && if (!
udf_process_sequence(sb, reserve_s, reserve_e, fileset))) (udf_process_sequence(sb, main_s, main_e, fileset)
{ && udf_process_sequence(sb, reserve_s, reserve_e,
fileset))) {
break; break;
} }
} }
...@@ -1349,36 +1443,37 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) ...@@ -1349,36 +1443,37 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
} else } else
udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]); udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]);
for (i=0; i<UDF_SB_NUMPARTS(sb); i++) for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
{ switch (UDF_SB_PARTTYPE(sb, i)) {
switch (UDF_SB_PARTTYPE(sb, i))
{
case UDF_VIRTUAL_MAP15: case UDF_VIRTUAL_MAP15:
case UDF_VIRTUAL_MAP20: case UDF_VIRTUAL_MAP20:
{ {
kernel_lb_addr uninitialized_var(ino); kernel_lb_addr uninitialized_var(ino);
if (!UDF_SB_LASTBLOCK(sb)) if (!UDF_SB_LASTBLOCK(sb)) {
{ UDF_SB_LASTBLOCK(sb) =
UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb); udf_get_last_block(sb);
udf_find_anchor(sb); udf_find_anchor(sb);
} }
if (!UDF_SB_LASTBLOCK(sb)) if (!UDF_SB_LASTBLOCK(sb)) {
{ udf_debug
udf_debug("Unable to determine Lastblock (For Virtual Partition)\n"); ("Unable to determine Lastblock (For Virtual Partition)\n");
return 1; return 1;
} }
for (j=0; j<UDF_SB_NUMPARTS(sb); j++) for (j = 0; j < UDF_SB_NUMPARTS(sb); j++) {
{
if (j != i && if (j != i &&
UDF_SB_PARTVSN(sb,i) == UDF_SB_PARTVSN(sb,j) && UDF_SB_PARTVSN(sb,
UDF_SB_PARTNUM(sb,i) == UDF_SB_PARTNUM(sb,j)) i) ==
{ UDF_SB_PARTVSN(sb, j)
&& UDF_SB_PARTNUM(sb,
i) ==
UDF_SB_PARTNUM(sb, j)) {
ino.partitionReferenceNum = j; ino.partitionReferenceNum = j;
ino.logicalBlockNum = UDF_SB_LASTBLOCK(sb) - ino.logicalBlockNum =
UDF_SB_PARTROOT(sb,j); UDF_SB_LASTBLOCK(sb) -
UDF_SB_PARTROOT(sb, j);
break; break;
} }
} }
...@@ -1389,13 +1484,13 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) ...@@ -1389,13 +1484,13 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
if (!(UDF_SB_VAT(sb) = udf_iget(sb, ino))) if (!(UDF_SB_VAT(sb) = udf_iget(sb, ino)))
return 1; return 1;
if (UDF_SB_PARTTYPE(sb,i) == UDF_VIRTUAL_MAP15) if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
{ UDF_SB_TYPEVIRT(sb, i).s_start_offset =
UDF_SB_TYPEVIRT(sb,i).s_start_offset = udf_ext0_offset(UDF_SB_VAT(sb)); udf_ext0_offset(UDF_SB_VAT(sb));
UDF_SB_TYPEVIRT(sb,i).s_num_entries = (UDF_SB_VAT(sb)->i_size - 36) >> 2; UDF_SB_TYPEVIRT(sb, i).s_num_entries =
} (UDF_SB_VAT(sb)->i_size - 36) >> 2;
else if (UDF_SB_PARTTYPE(sb,i) == UDF_VIRTUAL_MAP20) } else if (UDF_SB_PARTTYPE(sb, i) ==
{ UDF_VIRTUAL_MAP20) {
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
uint32_t pos; uint32_t pos;
...@@ -1403,15 +1498,26 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) ...@@ -1403,15 +1498,26 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
bh = sb_bread(sb, pos); bh = sb_bread(sb, pos);
if (!bh) if (!bh)
return 1; return 1;
UDF_SB_TYPEVIRT(sb,i).s_start_offset = UDF_SB_TYPEVIRT(sb, i).s_start_offset =
le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data + udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) + le16_to_cpu(((struct
virtualAllocationTable20
*)bh->b_data +
udf_ext0_offset
(UDF_SB_VAT(sb)))->
lengthHeader) +
udf_ext0_offset(UDF_SB_VAT(sb)); udf_ext0_offset(UDF_SB_VAT(sb));
UDF_SB_TYPEVIRT(sb,i).s_num_entries = (UDF_SB_VAT(sb)->i_size - UDF_SB_TYPEVIRT(sb, i).s_num_entries =
UDF_SB_TYPEVIRT(sb,i).s_start_offset) >> 2; (UDF_SB_VAT(sb)->i_size -
UDF_SB_TYPEVIRT(sb,
i).
s_start_offset) >> 2;
brelse(bh); brelse(bh);
} }
UDF_SB_PARTROOT(sb,i) = udf_get_pblock(sb, 0, i, 0); UDF_SB_PARTROOT(sb, i) =
UDF_SB_PARTLEN(sb,i) = UDF_SB_PARTLEN(sb,ino.partitionReferenceNum); udf_get_pblock(sb, 0, i, 0);
UDF_SB_PARTLEN(sb, i) =
UDF_SB_PARTLEN(sb,
ino.partitionReferenceNum);
} }
} }
} }
...@@ -1420,26 +1526,28 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) ...@@ -1420,26 +1526,28 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
static void udf_open_lvid(struct super_block *sb) static void udf_open_lvid(struct super_block *sb)
{ {
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb)) {
{
int i; int i;
kernel_timestamp cpu_time; kernel_timestamp cpu_time;
UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
if (udf_time_to_stamp(&cpu_time, CURRENT_TIME)) if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time); UDF_SB_LVID(sb)->recordingDateAndTime =
cpu_to_lets(cpu_time);
UDF_SB_LVID(sb)->integrityType = LVID_INTEGRITY_TYPE_OPEN; UDF_SB_LVID(sb)->integrityType = LVID_INTEGRITY_TYPE_OPEN;
UDF_SB_LVID(sb)->descTag.descCRC = UDF_SB_LVID(sb)->descTag.descCRC =
cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag), cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0)); le16_to_cpu(UDF_SB_LVID(sb)->descTag.
descCRCLength), 0));
UDF_SB_LVID(sb)->descTag.tagChecksum = 0; UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
for (i=0; i<16; i++) for (i = 0; i < 16; i++)
if (i != 4) if (i != 4)
UDF_SB_LVID(sb)->descTag.tagChecksum += UDF_SB_LVID(sb)->descTag.tagChecksum +=
((uint8_t *)&(UDF_SB_LVID(sb)->descTag))[i]; ((uint8_t *) &
(UDF_SB_LVID(sb)->descTag))[i];
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); mark_buffer_dirty(UDF_SB_LVIDBH(sb));
} }
...@@ -1448,32 +1556,41 @@ static void udf_open_lvid(struct super_block *sb) ...@@ -1448,32 +1556,41 @@ static void udf_open_lvid(struct super_block *sb)
static void udf_close_lvid(struct super_block *sb) static void udf_close_lvid(struct super_block *sb)
{ {
if (UDF_SB_LVIDBH(sb) && if (UDF_SB_LVIDBH(sb) &&
UDF_SB_LVID(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) UDF_SB_LVID(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
{
int i; int i;
kernel_timestamp cpu_time; kernel_timestamp cpu_time;
UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
if (udf_time_to_stamp(&cpu_time, CURRENT_TIME)) if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time); UDF_SB_LVID(sb)->recordingDateAndTime =
if (UDF_MAX_WRITE_VERSION > le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev)) cpu_to_lets(cpu_time);
UDF_SB_LVIDIU(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION); if (UDF_MAX_WRITE_VERSION >
if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev)) le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
UDF_SB_LVIDIU(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb)); UDF_SB_LVIDIU(sb)->maxUDFWriteRev =
if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev)) cpu_to_le16(UDF_MAX_WRITE_VERSION);
UDF_SB_LVIDIU(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb)); if (UDF_SB_UDFREV(sb) >
UDF_SB_LVID(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE); le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
UDF_SB_LVIDIU(sb)->minUDFReadRev =
cpu_to_le16(UDF_SB_UDFREV(sb));
if (UDF_SB_UDFREV(sb) >
le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
UDF_SB_LVIDIU(sb)->minUDFWriteRev =
cpu_to_le16(UDF_SB_UDFREV(sb));
UDF_SB_LVID(sb)->integrityType =
cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
UDF_SB_LVID(sb)->descTag.descCRC = UDF_SB_LVID(sb)->descTag.descCRC =
cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag), cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0)); le16_to_cpu(UDF_SB_LVID(sb)->descTag.
descCRCLength), 0));
UDF_SB_LVID(sb)->descTag.tagChecksum = 0; UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
for (i=0; i<16; i++) for (i = 0; i < 16; i++)
if (i != 4) if (i != 4)
UDF_SB_LVID(sb)->descTag.tagChecksum += UDF_SB_LVID(sb)->descTag.tagChecksum +=
((uint8_t *)&(UDF_SB_LVID(sb)->descTag))[i]; ((uint8_t *) &
(UDF_SB_LVID(sb)->descTag))[i];
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); mark_buffer_dirty(UDF_SB_LVIDBH(sb));
} }
...@@ -1498,7 +1615,7 @@ static void udf_close_lvid(struct super_block *sb) ...@@ -1498,7 +1615,7 @@ static void udf_close_lvid(struct super_block *sb)
static int udf_fill_super(struct super_block *sb, void *options, int silent) static int udf_fill_super(struct super_block *sb, void *options, int silent)
{ {
int i; int i;
struct inode *inode=NULL; struct inode *inode = NULL;
struct udf_options uopt; struct udf_options uopt;
kernel_lb_addr rootdir, fileset; kernel_lb_addr rootdir, fileset;
struct udf_sb_info *sbi; struct udf_sb_info *sbi;
...@@ -1520,15 +1637,13 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) ...@@ -1520,15 +1637,13 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
goto error_out; goto error_out;
if (uopt.flags & (1 << UDF_FLAG_UTF8) && if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
uopt.flags & (1 << UDF_FLAG_NLS_MAP)) uopt.flags & (1 << UDF_FLAG_NLS_MAP)) {
{
udf_error(sb, "udf_read_super", udf_error(sb, "udf_read_super",
"utf8 cannot be combined with iocharset\n"); "utf8 cannot be combined with iocharset\n");
goto error_out; goto error_out;
} }
#ifdef CONFIG_UDF_NLS #ifdef CONFIG_UDF_NLS
if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) {
{
uopt.nls_map = load_nls_default(); uopt.nls_map = load_nls_default();
if (!uopt.nls_map) if (!uopt.nls_map)
uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP); uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP);
...@@ -1552,7 +1667,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) ...@@ -1552,7 +1667,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
if (!udf_set_blocksize(sb, uopt.blocksize)) if (!udf_set_blocksize(sb, uopt.blocksize))
goto error_out; goto error_out;
if ( uopt.session == 0xFFFFFFFF ) if (uopt.session == 0xFFFFFFFF)
UDF_SB_SESSION(sb) = udf_get_last_session(sb); UDF_SB_SESSION(sb) = udf_get_last_session(sb);
else else
UDF_SB_SESSION(sb) = uopt.session; UDF_SB_SESSION(sb) = uopt.session;
...@@ -1564,8 +1679,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) ...@@ -1564,8 +1679,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
UDF_SB_ANCHOR(sb)[2] = uopt.anchor; UDF_SB_ANCHOR(sb)[2] = uopt.anchor;
UDF_SB_ANCHOR(sb)[3] = 256; UDF_SB_ANCHOR(sb)[3] = 256;
if (udf_check_valid(sb, uopt.novrs, silent)) /* read volume recognition sequences */ if (udf_check_valid(sb, uopt.novrs, silent)) { /* read volume recognition sequences */
{
printk("UDF-fs: No VRS found\n"); printk("UDF-fs: No VRS found\n");
goto error_out; goto error_out;
} }
...@@ -1579,29 +1693,26 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) ...@@ -1579,29 +1693,26 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
sb->s_magic = UDF_SUPER_MAGIC; sb->s_magic = UDF_SUPER_MAGIC;
sb->s_time_gran = 1000; sb->s_time_gran = 1000;
if (udf_load_partition(sb, &fileset)) if (udf_load_partition(sb, &fileset)) {
{
printk("UDF-fs: No partition found (1)\n"); printk("UDF-fs: No partition found (1)\n");
goto error_out; goto error_out;
} }
udf_debug("Lastblock=%d\n", UDF_SB_LASTBLOCK(sb)); udf_debug("Lastblock=%d\n", UDF_SB_LASTBLOCK(sb));
if ( UDF_SB_LVIDBH(sb) ) if (UDF_SB_LVIDBH(sb)) {
{ uint16_t minUDFReadRev =
uint16_t minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev); le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
uint16_t minUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev); uint16_t minUDFWriteRev =
le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
/* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */ /* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */
if (minUDFReadRev > UDF_MAX_READ_VERSION) if (minUDFReadRev > UDF_MAX_READ_VERSION) {
{
printk("UDF-fs: minUDFReadRev=%x (max is %x)\n", printk("UDF-fs: minUDFReadRev=%x (max is %x)\n",
le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev), le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev),
UDF_MAX_READ_VERSION); UDF_MAX_READ_VERSION);
goto error_out; goto error_out;
} } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION) {
else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
{
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
} }
...@@ -1613,31 +1724,30 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) ...@@ -1613,31 +1724,30 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS); UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
} }
if ( !UDF_SB_NUMPARTS(sb) ) if (!UDF_SB_NUMPARTS(sb)) {
{
printk("UDF-fs: No partition found (2)\n"); printk("UDF-fs: No partition found (2)\n");
goto error_out; goto error_out;
} }
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_READ_ONLY) { if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
printk("UDF-fs: Partition marked readonly; forcing readonly mount\n"); UDF_PART_FLAG_READ_ONLY) {
printk
("UDF-fs: Partition marked readonly; forcing readonly mount\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
} }
if ( udf_find_fileset(sb, &fileset, &rootdir) ) if (udf_find_fileset(sb, &fileset, &rootdir)) {
{
printk("UDF-fs: No fileset found\n"); printk("UDF-fs: No fileset found\n");
goto error_out; goto error_out;
} }
if (!silent) if (!silent) {
{
kernel_timestamp ts; kernel_timestamp ts;
udf_time_to_stamp(&ts, UDF_SB_RECORDTIME(sb)); udf_time_to_stamp(&ts, UDF_SB_RECORDTIME(sb));
udf_info("UDF %s (%s) Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)\n", udf_info
UDFFS_VERSION, UDFFS_DATE, ("UDF %s (%s) Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
UDF_SB_VOLIDENT(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute, UDFFS_VERSION, UDFFS_DATE, UDF_SB_VOLIDENT(sb), ts.year,
ts.typeAndTimezone); ts.month, ts.day, ts.hour, ts.minute, ts.typeAndTimezone);
} }
if (!(sb->s_flags & MS_RDONLY)) if (!(sb->s_flags & MS_RDONLY))
udf_open_lvid(sb); udf_open_lvid(sb);
...@@ -1646,8 +1756,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) ...@@ -1646,8 +1756,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
/* assign inodes by physical block number */ /* assign inodes by physical block number */
/* perhaps it's not extensible enough, but for now ... */ /* perhaps it's not extensible enough, but for now ... */
inode = udf_iget(sb, rootdir); inode = udf_iget(sb, rootdir);
if (!inode) if (!inode) {
{
printk("UDF-fs: Error in udf_iget, block=%d, partition=%d\n", printk("UDF-fs: Error in udf_iget, block=%d, partition=%d\n",
rootdir.logicalBlockNum, rootdir.partitionReferenceNum); rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
goto error_out; goto error_out;
...@@ -1655,8 +1764,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) ...@@ -1655,8 +1764,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
/* Allocate a dentry for the root inode */ /* Allocate a dentry for the root inode */
sb->s_root = d_alloc_root(inode); sb->s_root = d_alloc_root(inode);
if (!sb->s_root) if (!sb->s_root) {
{
printk("UDF-fs: Couldn't allocate root dentry\n"); printk("UDF-fs: Couldn't allocate root dentry\n");
iput(inode); iput(inode);
goto error_out; goto error_out;
...@@ -1664,23 +1772,30 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) ...@@ -1664,23 +1772,30 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_maxbytes = MAX_LFS_FILESIZE;
return 0; return 0;
error_out: error_out:
if (UDF_SB_VAT(sb)) if (UDF_SB_VAT(sb))
iput(UDF_SB_VAT(sb)); iput(UDF_SB_VAT(sb));
if (UDF_SB_NUMPARTS(sb)) if (UDF_SB_NUMPARTS(sb)) {
{ if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) UDF_PART_FLAG_UNALLOC_TABLE)
iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table); iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) s_table);
iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table); if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) UDF_PART_FLAG_FREED_TABLE)
UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace); iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) s_table);
UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace); if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) UDF_PART_FLAG_UNALLOC_BITMAP)
{ UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
for (i=0; i<4; i++) if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]); UDF_PART_FLAG_FREED_BITMAP)
UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) ==
UDF_SPARABLE_MAP15) {
for (i = 0; i < 4; i++)
brelse(UDF_SB_TYPESPAR
(sb,
UDF_SB_PARTITION(sb)).s_spar_map[i]);
} }
} }
#ifdef CONFIG_UDF_NLS #ifdef CONFIG_UDF_NLS
...@@ -1701,15 +1816,14 @@ void udf_error(struct super_block *sb, const char *function, ...@@ -1701,15 +1816,14 @@ void udf_error(struct super_block *sb, const char *function,
{ {
va_list args; va_list args;
if (!(sb->s_flags & MS_RDONLY)) if (!(sb->s_flags & MS_RDONLY)) {
{
/* mark sb error */ /* mark sb error */
sb->s_dirt = 1; sb->s_dirt = 1;
} }
va_start(args, fmt); va_start(args, fmt);
vsnprintf(error_buf, sizeof(error_buf), fmt, args); vsnprintf(error_buf, sizeof(error_buf), fmt, args);
va_end(args); va_end(args);
printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n", printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
sb->s_id, function, error_buf); sb->s_id, function, error_buf);
} }
...@@ -1718,7 +1832,7 @@ void udf_warning(struct super_block *sb, const char *function, ...@@ -1718,7 +1832,7 @@ void udf_warning(struct super_block *sb, const char *function,
{ {
va_list args; va_list args;
va_start (args, fmt); va_start(args, fmt);
vsnprintf(error_buf, sizeof(error_buf), fmt, args); vsnprintf(error_buf, sizeof(error_buf), fmt, args);
va_end(args); va_end(args);
printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n", printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
...@@ -1738,27 +1852,33 @@ void udf_warning(struct super_block *sb, const char *function, ...@@ -1738,27 +1852,33 @@ void udf_warning(struct super_block *sb, const char *function,
* July 1, 1997 - Andrew E. Mileski * July 1, 1997 - Andrew E. Mileski
* Written, tested, and released. * Written, tested, and released.
*/ */
static void static void udf_put_super(struct super_block *sb)
udf_put_super(struct super_block *sb)
{ {
int i; int i;
if (UDF_SB_VAT(sb)) if (UDF_SB_VAT(sb))
iput(UDF_SB_VAT(sb)); iput(UDF_SB_VAT(sb));
if (UDF_SB_NUMPARTS(sb)) if (UDF_SB_NUMPARTS(sb)) {
{ if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) UDF_PART_FLAG_UNALLOC_TABLE)
iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table); iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) s_table);
iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table); if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) UDF_PART_FLAG_FREED_TABLE)
UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace); iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.
if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) s_table);
UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace); if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) UDF_PART_FLAG_UNALLOC_BITMAP)
{ UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
for (i=0; i<4; i++) if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]); UDF_PART_FLAG_FREED_BITMAP)
UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) ==
UDF_SPARABLE_MAP15) {
for (i = 0; i < 4; i++)
brelse(UDF_SB_TYPESPAR
(sb,
UDF_SB_PARTITION(sb)).s_spar_map[i]);
} }
} }
#ifdef CONFIG_UDF_NLS #ifdef CONFIG_UDF_NLS
...@@ -1786,8 +1906,7 @@ udf_put_super(struct super_block *sb) ...@@ -1786,8 +1906,7 @@ udf_put_super(struct super_block *sb)
* July 1, 1997 - Andrew E. Mileski * July 1, 1997 - Andrew E. Mileski
* Written, tested, and released. * Written, tested, and released.
*/ */
static int static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
udf_statfs(struct dentry *dentry, struct kstatfs *buf)
{ {
struct super_block *sb = dentry->d_sb; struct super_block *sb = dentry->d_sb;
...@@ -1798,10 +1917,11 @@ udf_statfs(struct dentry *dentry, struct kstatfs *buf) ...@@ -1798,10 +1917,11 @@ udf_statfs(struct dentry *dentry, struct kstatfs *buf)
buf->f_bavail = buf->f_bfree; buf->f_bavail = buf->f_bfree;
buf->f_files = (UDF_SB_LVIDBH(sb) ? buf->f_files = (UDF_SB_LVIDBH(sb) ?
(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) + (le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) +
le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) + buf->f_bfree; le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) +
buf->f_bfree;
buf->f_ffree = buf->f_bfree; buf->f_ffree = buf->f_bfree;
/* __kernel_fsid_t f_fsid */ /* __kernel_fsid_t f_fsid */
buf->f_namelen = UDF_NAME_LEN-2; buf->f_namelen = UDF_NAME_LEN - 2;
return 0; return 0;
} }
...@@ -1830,13 +1950,10 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap) ...@@ -1830,13 +1950,10 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
loc.partitionReferenceNum = UDF_SB_PARTITION(sb); loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
bh = udf_read_ptagged(sb, loc, 0, &ident); bh = udf_read_ptagged(sb, loc, 0, &ident);
if (!bh) if (!bh) {
{
printk(KERN_ERR "udf: udf_count_free failed\n"); printk(KERN_ERR "udf: udf_count_free failed\n");
goto out; goto out;
} } else if (ident != TAG_IDENT_SBD) {
else if (ident != TAG_IDENT_SBD)
{
brelse(bh); brelse(bh);
printk(KERN_ERR "udf: udf_count_free failed\n"); printk(KERN_ERR "udf: udf_count_free failed\n");
goto out; goto out;
...@@ -1845,42 +1962,38 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap) ...@@ -1845,42 +1962,38 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
bm = (struct spaceBitmapDesc *)bh->b_data; bm = (struct spaceBitmapDesc *)bh->b_data;
bytes = le32_to_cpu(bm->numOfBytes); bytes = le32_to_cpu(bm->numOfBytes);
index = sizeof(struct spaceBitmapDesc); /* offset in first block only */ index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
ptr = (uint8_t *)bh->b_data; ptr = (uint8_t *) bh->b_data;
while ( bytes > 0 ) while (bytes > 0) {
{ while ((bytes > 0) && (index < sb->s_blocksize)) {
while ((bytes > 0) && (index < sb->s_blocksize))
{
value = ptr[index]; value = ptr[index];
accum += udf_bitmap_lookup[ value & 0x0f ]; accum += udf_bitmap_lookup[value & 0x0f];
accum += udf_bitmap_lookup[ value >> 4 ]; accum += udf_bitmap_lookup[value >> 4];
index++; index++;
bytes--; bytes--;
} }
if ( bytes ) if (bytes) {
{
brelse(bh); brelse(bh);
newblock = udf_get_lb_pblock(sb, loc, ++block); newblock = udf_get_lb_pblock(sb, loc, ++block);
bh = udf_tread(sb, newblock); bh = udf_tread(sb, newblock);
if (!bh) if (!bh) {
{
udf_debug("read failed\n"); udf_debug("read failed\n");
goto out; goto out;
} }
index = 0; index = 0;
ptr = (uint8_t *)bh->b_data; ptr = (uint8_t *) bh->b_data;
} }
} }
brelse(bh); brelse(bh);
out: out:
unlock_kernel(); unlock_kernel();
return accum; return accum;
} }
static unsigned int static unsigned int
udf_count_free_table(struct super_block *sb, struct inode * table) udf_count_free_table(struct super_block *sb, struct inode *table)
{ {
unsigned int accum = 0; unsigned int accum = 0;
uint32_t elen; uint32_t elen;
...@@ -1903,16 +2016,16 @@ udf_count_free_table(struct super_block *sb, struct inode * table) ...@@ -1903,16 +2016,16 @@ udf_count_free_table(struct super_block *sb, struct inode * table)
return accum; return accum;
} }
static unsigned int static unsigned int udf_count_free(struct super_block *sb)
udf_count_free(struct super_block *sb)
{ {
unsigned int accum = 0; unsigned int accum = 0;
if (UDF_SB_LVIDBH(sb)) if (UDF_SB_LVIDBH(sb)) {
{ if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) >
if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) > UDF_SB_PARTITION(sb)) UDF_SB_PARTITION(sb)) {
{ accum =
accum = le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]); le32_to_cpu(UDF_SB_LVID(sb)->
freeSpaceTable[UDF_SB_PARTITION(sb)]);
if (accum == 0xFFFFFFFF) if (accum == 0xFFFFFFFF)
accum = 0; accum = 0;
...@@ -1922,28 +2035,40 @@ udf_count_free(struct super_block *sb) ...@@ -1922,28 +2035,40 @@ udf_count_free(struct super_block *sb)
if (accum) if (accum)
return accum; return accum;
if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
{ UDF_PART_FLAG_UNALLOC_BITMAP) {
accum += udf_count_free_bitmap(sb, accum +=
UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap); udf_count_free_bitmap(sb,
} UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION
if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) (sb)].s_uspace.
{ s_bitmap);
accum += udf_count_free_bitmap(sb, }
UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap); if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
UDF_PART_FLAG_FREED_BITMAP) {
accum +=
udf_count_free_bitmap(sb,
UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION
(sb)].s_fspace.
s_bitmap);
} }
if (accum) if (accum)
return accum; return accum;
if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
{ UDF_PART_FLAG_UNALLOC_TABLE) {
accum += udf_count_free_table(sb, accum +=
UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table); udf_count_free_table(sb,
} UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION
if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) (sb)].s_uspace.
{ s_table);
accum += udf_count_free_table(sb, }
UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table); if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
UDF_PART_FLAG_FREED_TABLE) {
accum +=
udf_count_free_table(sb,
UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION
(sb)].s_fspace.
s_table);
} }
return accum; return accum;
......
fs/udf/symlink.c
View file @ cb00ea35
...@@ -33,20 +33,18 @@ ...@@ -33,20 +33,18 @@
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include "udf_i.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; struct pathComponent *pc;
int elen = 0; int elen = 0;
char *p = to; char *p = to;
while (elen < fromlen) while (elen < fromlen) {
{
pc = (struct pathComponent *)(from + elen); pc = (struct pathComponent *)(from + elen);
switch (pc->componentType) switch (pc->componentType) {
{
case 1: case 1:
if (pc->lengthComponentIdent == 0) if (pc->lengthComponentIdent == 0) {
{
p = to; p = to;
*p++ = '/'; *p++ = '/';
} }
...@@ -61,13 +59,14 @@ static void udf_pc_to_char(struct super_block *sb, char *from, int fromlen, char ...@@ -61,13 +59,14 @@ static void udf_pc_to_char(struct super_block *sb, char *from, int fromlen, char
/* that would be . - just ignore */ /* that would be . - just ignore */
break; break;
case 5: case 5:
p += udf_get_filename(sb, pc->componentIdent, p, pc->lengthComponentIdent); p += udf_get_filename(sb, pc->componentIdent, p,
pc->lengthComponentIdent);
*p++ = '/'; *p++ = '/';
break; break;
} }
elen += sizeof(struct pathComponent) + pc->lengthComponentIdent; elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;
} }
if (p > to+1) if (p > to + 1)
p[-1] = '\0'; p[-1] = '\0';
else else
p[0] = '\0'; p[0] = '\0';
...@@ -84,8 +83,7 @@ static int udf_symlink_filler(struct file *file, struct page *page) ...@@ -84,8 +83,7 @@ static int udf_symlink_filler(struct file *file, struct page *page)
lock_kernel(); 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); symlink = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
else else {
{
bh = sb_bread(inode->i_sb, udf_block_map(inode, 0)); bh = sb_bread(inode->i_sb, udf_block_map(inode, 0));
if (!bh) if (!bh)
...@@ -102,7 +100,7 @@ static int udf_symlink_filler(struct file *file, struct page *page) ...@@ -102,7 +100,7 @@ static int udf_symlink_filler(struct file *file, struct page *page)
kunmap(page); kunmap(page);
unlock_page(page); unlock_page(page);
return 0; return 0;
out: out:
unlock_kernel(); unlock_kernel();
SetPageError(page); SetPageError(page);
kunmap(page); kunmap(page);
......
fs/udf/truncate.c
View file @ cb00ea35
...@@ -28,35 +28,38 @@ ...@@ -28,35 +28,38 @@
#include "udf_i.h" #include "udf_i.h"
#include "udf_sb.h" #include "udf_sb.h"
static void extent_trunc(struct inode * inode, struct extent_position *epos, 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 eloc, int8_t etype, uint32_t elen,
uint32_t nelen)
{ {
kernel_lb_addr neloc = { 0, 0 }; kernel_lb_addr neloc = { 0, 0 };
int last_block = (elen + inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits; int last_block =
int first_block = (nelen + inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits; (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 (nelen) {
{ if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) udf_free_blocks(inode->i_sb, inode, eloc, 0,
{ last_block);
udf_free_blocks(inode->i_sb, inode, eloc, 0, last_block);
etype = (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30); etype = (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30);
} } else
else
neloc = eloc; neloc = eloc;
nelen = (etype << 30) | nelen; nelen = (etype << 30) | nelen;
} }
if (elen != nelen) if (elen != nelen) {
{
udf_write_aext(inode, epos, neloc, nelen, 0); udf_write_aext(inode, epos, neloc, nelen, 0);
if (last_block - first_block > 0) if (last_block - first_block > 0) {
{
if (etype == (EXT_RECORDED_ALLOCATED >> 30)) if (etype == (EXT_RECORDED_ALLOCATED >> 30))
mark_inode_dirty(inode); mark_inode_dirty(inode);
if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
udf_free_blocks(inode->i_sb, inode, eloc, first_block, last_block - first_block); udf_free_blocks(inode->i_sb, inode, eloc,
first_block,
last_block - first_block);
} }
} }
} }
...@@ -67,7 +70,7 @@ static void extent_trunc(struct inode * inode, struct extent_position *epos, ...@@ -67,7 +70,7 @@ static void extent_trunc(struct inode * inode, struct extent_position *epos,
*/ */
void udf_truncate_tail_extent(struct inode *inode) void udf_truncate_tail_extent(struct inode *inode)
{ {
struct extent_position epos = { NULL, 0, {0, 0}}; struct extent_position epos = { NULL, 0, {0, 0} };
kernel_lb_addr eloc; kernel_lb_addr eloc;
uint32_t elen, nelen; uint32_t elen, nelen;
uint64_t lbcount = 0; uint64_t lbcount = 0;
...@@ -89,8 +92,7 @@ void udf_truncate_tail_extent(struct inode *inode) ...@@ -89,8 +92,7 @@ void udf_truncate_tail_extent(struct inode *inode)
BUG(); BUG();
/* Find the last extent in the file */ /* Find the last extent in the file */
while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
{
etype = netype; etype = netype;
lbcount += elen; lbcount += elen;
if (lbcount > inode->i_size) { if (lbcount > inode->i_size) {
...@@ -123,7 +125,7 @@ void udf_truncate_tail_extent(struct inode *inode) ...@@ -123,7 +125,7 @@ void udf_truncate_tail_extent(struct inode *inode)
void udf_discard_prealloc(struct inode *inode) void udf_discard_prealloc(struct inode *inode)
{ {
struct extent_position epos = { NULL, 0, {0, 0}}; struct extent_position epos = { NULL, 0, {0, 0} };
kernel_lb_addr eloc; kernel_lb_addr eloc;
uint32_t elen; uint32_t elen;
uint64_t lbcount = 0; uint64_t lbcount = 0;
...@@ -153,15 +155,21 @@ void udf_discard_prealloc(struct inode *inode) ...@@ -153,15 +155,21 @@ void udf_discard_prealloc(struct inode *inode)
lbcount -= elen; lbcount -= elen;
extent_trunc(inode, &epos, eloc, etype, elen, 0); extent_trunc(inode, &epos, eloc, etype, elen, 0);
if (!epos.bh) { if (!epos.bh) {
UDF_I_LENALLOC(inode) = epos.offset - udf_file_entry_alloc_offset(inode); UDF_I_LENALLOC(inode) =
epos.offset - udf_file_entry_alloc_offset(inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
} else { } else {
struct allocExtDesc *aed = (struct allocExtDesc *)(epos.bh->b_data); struct allocExtDesc *aed =
aed->lengthAllocDescs = cpu_to_le32(epos.offset - sizeof(struct allocExtDesc)); (struct allocExtDesc *)(epos.bh->b_data);
if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) 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)
udf_update_tag(epos.bh->b_data, epos.offset); udf_update_tag(epos.bh->b_data, epos.offset);
else else
udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc)); udf_update_tag(epos.bh->b_data,
sizeof(struct allocExtDesc));
mark_buffer_dirty_inode(epos.bh, inode); mark_buffer_dirty_inode(epos.bh, inode);
} }
} }
...@@ -171,7 +179,7 @@ void udf_discard_prealloc(struct inode *inode) ...@@ -171,7 +179,7 @@ void udf_discard_prealloc(struct inode *inode)
brelse(epos.bh); brelse(epos.bh);
} }
void udf_truncate_extents(struct inode * inode) void udf_truncate_extents(struct inode *inode)
{ {
struct extent_position epos; struct extent_position epos;
kernel_lb_addr eloc, neloc = { 0, 0 }; kernel_lb_addr eloc, neloc = { 0, 0 };
...@@ -190,9 +198,10 @@ void udf_truncate_extents(struct inode * inode) ...@@ -190,9 +198,10 @@ void udf_truncate_extents(struct inode * inode)
BUG(); BUG();
etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset); 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 =
if (etype != -1) (offset << sb->s_blocksize_bits) +
{ (inode->i_size & (sb->s_blocksize - 1));
if (etype != -1) {
epos.offset -= adsize; epos.offset -= adsize;
extent_trunc(inode, &epos, eloc, etype, elen, byte_offset); extent_trunc(inode, &epos, eloc, etype, elen, byte_offset);
epos.offset += adsize; epos.offset += adsize;
...@@ -206,86 +215,98 @@ void udf_truncate_extents(struct inode * inode) ...@@ -206,86 +215,98 @@ void udf_truncate_extents(struct inode * inode)
else else
lenalloc -= sizeof(struct allocExtDesc); lenalloc -= sizeof(struct allocExtDesc);
while ((etype = udf_current_aext(inode, &epos, &eloc, &elen, 0)) != -1) while ((etype =
{ udf_current_aext(inode, &epos, &eloc, &elen,
if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) 0)) != -1) {
{ if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
udf_write_aext(inode, &epos, neloc, nelen, 0); udf_write_aext(inode, &epos, neloc, nelen, 0);
if (indirect_ext_len) if (indirect_ext_len) {
{
/* We managed to free all extents in the /* We managed to free all extents in the
* indirect extent - free it too */ * indirect extent - free it too */
if (!epos.bh) if (!epos.bh)
BUG(); BUG();
udf_free_blocks(sb, inode, epos.block, 0, indirect_ext_len); udf_free_blocks(sb, inode, epos.block,
} 0, indirect_ext_len);
else } else {
{ if (!epos.bh) {
if (!epos.bh) UDF_I_LENALLOC(inode) =
{ lenalloc;
UDF_I_LENALLOC(inode) = lenalloc;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} } else {
else struct allocExtDesc *aed =
{ (struct allocExtDesc
struct allocExtDesc *aed = (struct allocExtDesc *)(epos.bh->b_data); *)(epos.bh->b_data);
aed->lengthAllocDescs = cpu_to_le32(lenalloc); aed->lengthAllocDescs =
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(sb) >= 0x0201) cpu_to_le32(lenalloc);
udf_update_tag(epos.bh->b_data, lenalloc + if (!UDF_QUERY_FLAG
sizeof(struct allocExtDesc)); (sb, UDF_FLAG_STRICT)
|| UDF_SB_UDFREV(sb) >=
0x0201)
udf_update_tag(epos.bh->
b_data,
lenalloc
+
sizeof
(struct
allocExtDesc));
else else
udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc)); udf_update_tag(epos.bh->
mark_buffer_dirty_inode(epos.bh, inode); b_data,
sizeof
(struct
allocExtDesc));
mark_buffer_dirty_inode(epos.bh,
inode);
} }
} }
brelse(epos.bh); brelse(epos.bh);
epos.offset = sizeof(struct allocExtDesc); epos.offset = sizeof(struct allocExtDesc);
epos.block = eloc; 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) if (elen)
indirect_ext_len = (elen + indirect_ext_len = (elen +
sb->s_blocksize - 1) >> sb->s_blocksize -
sb->s_blocksize_bits; 1) >> sb->
s_blocksize_bits;
else else
indirect_ext_len = 1; indirect_ext_len = 1;
} } else {
else extent_trunc(inode, &epos, eloc, etype, elen,
{ 0);
extent_trunc(inode, &epos, eloc, etype, elen, 0);
epos.offset += adsize; epos.offset += adsize;
} }
} }
if (indirect_ext_len) if (indirect_ext_len) {
{
if (!epos.bh) if (!epos.bh)
BUG(); BUG();
udf_free_blocks(sb, inode, epos.block, 0, indirect_ext_len); udf_free_blocks(sb, inode, epos.block, 0,
} indirect_ext_len);
else } else {
{ if (!epos.bh) {
if (!epos.bh)
{
UDF_I_LENALLOC(inode) = lenalloc; UDF_I_LENALLOC(inode) = lenalloc;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} } else {
else struct allocExtDesc *aed =
{ (struct allocExtDesc *)(epos.bh->b_data);
struct allocExtDesc *aed = (struct allocExtDesc *)(epos.bh->b_data);
aed->lengthAllocDescs = cpu_to_le32(lenalloc); 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_update_tag(epos.bh->b_data, lenalloc + || UDF_SB_UDFREV(sb) >= 0x0201)
sizeof(struct allocExtDesc)); udf_update_tag(epos.bh->b_data,
lenalloc +
sizeof(struct
allocExtDesc));
else else
udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc)); udf_update_tag(epos.bh->b_data,
sizeof(struct
allocExtDesc));
mark_buffer_dirty_inode(epos.bh, inode); mark_buffer_dirty_inode(epos.bh, inode);
} }
} }
} } else if (inode->i_size) {
else if (inode->i_size) if (byte_offset) {
{
if (byte_offset)
{
kernel_long_ad extent; kernel_long_ad extent;
/* /*
...@@ -293,21 +314,33 @@ void udf_truncate_extents(struct inode * inode) ...@@ -293,21 +314,33 @@ void udf_truncate_extents(struct inode * inode)
* no extent above inode->i_size => truncate is * no extent above inode->i_size => truncate is
* extending the file by 'offset' blocks. * extending the file by 'offset' blocks.
*/ */
if ((!epos.bh && epos.offset == udf_file_entry_alloc_offset(inode)) || if ((!epos.bh
(epos.bh && epos.offset == sizeof(struct allocExtDesc))) { && 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 /* File has no extents at all or has empty last
* indirect extent! Create a fake extent... */ * indirect extent! Create a fake extent... */
extent.extLocation.logicalBlockNum = 0; extent.extLocation.logicalBlockNum = 0;
extent.extLocation.partitionReferenceNum = 0; extent.extLocation.partitionReferenceNum = 0;
extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED; extent.extLength =
} EXT_NOT_RECORDED_NOT_ALLOCATED;
else { } else {
epos.offset -= adsize; epos.offset -= adsize;
etype = udf_next_aext(inode, &epos, etype = udf_next_aext(inode, &epos,
&extent.extLocation, &extent.extLength, 0); &extent.extLocation,
&extent.extLength, 0);
extent.extLength |= etype << 30; extent.extLength |= etype << 30;
} }
udf_extend_file(inode, &epos, &extent, offset+((inode->i_size & (sb->s_blocksize-1)) != 0)); udf_extend_file(inode, &epos, &extent,
offset +
((inode->
i_size & (sb->s_blocksize - 1)) !=
0));
} }
} }
UDF_I_LENEXTENTS(inode) = inode->i_size; UDF_I_LENEXTENTS(inode) = inode->i_size;
......
fs/udf/udfdecl.h
View file @ cb00ea35
...@@ -50,30 +50,26 @@ extern const struct address_space_operations udf_aops; ...@@ -50,30 +50,26 @@ extern const struct address_space_operations udf_aops;
extern const struct address_space_operations udf_adinicb_aops; extern const struct address_space_operations udf_adinicb_aops;
extern const struct address_space_operations udf_symlink_aops; extern const struct address_space_operations udf_symlink_aops;
struct udf_fileident_bh struct udf_fileident_bh {
{
struct buffer_head *sbh; struct buffer_head *sbh;
struct buffer_head *ebh; struct buffer_head *ebh;
int soffset; int soffset;
int eoffset; int eoffset;
}; };
struct udf_vds_record struct udf_vds_record {
{
uint32_t block; uint32_t block;
uint32_t volDescSeqNum; uint32_t volDescSeqNum;
}; };
struct generic_desc struct generic_desc {
{
tag descTag; tag descTag;
__le32 volDescSeqNum; __le32 volDescSeqNum;
}; };
struct ustr struct ustr {
{
uint8_t u_cmpID; uint8_t u_cmpID;
uint8_t u_name[UDF_NAME_LEN-2]; uint8_t u_name[UDF_NAME_LEN - 2];
uint8_t u_len; uint8_t u_len;
}; };
...@@ -83,44 +79,58 @@ struct extent_position { ...@@ -83,44 +79,58 @@ struct extent_position {
kernel_lb_addr block; kernel_lb_addr block;
}; };
/* super.c */ /* super.c */
extern void udf_error(struct super_block *, const char *, const char *, ...); extern void udf_error(struct super_block *, const char *, const char *, ...);
extern void udf_warning(struct super_block *, const char *, const char *, ...); extern void udf_warning(struct super_block *, const char *, const char *, ...);
/* namei.c */ /* namei.c */
extern int udf_write_fi(struct inode *inode, struct fileIdentDesc *, struct fileIdentDesc *, struct udf_fileident_bh *, uint8_t *, uint8_t *); extern int udf_write_fi(struct inode *inode, struct fileIdentDesc *,
struct fileIdentDesc *, struct udf_fileident_bh *,
uint8_t *, uint8_t *);
/* file.c */ /* file.c */
extern int udf_ioctl(struct inode *, struct file *, unsigned int, unsigned long); extern int udf_ioctl(struct inode *, struct file *, unsigned int,
unsigned long);
/* inode.c */ /* inode.c */
extern struct inode *udf_iget(struct super_block *, kernel_lb_addr); extern struct inode *udf_iget(struct super_block *, kernel_lb_addr);
extern int udf_sync_inode(struct inode *); extern int udf_sync_inode(struct inode *);
extern void udf_expand_file_adinicb(struct inode *, int, int *); extern void udf_expand_file_adinicb(struct inode *, int, int *);
extern struct buffer_head * udf_expand_dir_adinicb(struct inode *, int *, int *); extern struct buffer_head *udf_expand_dir_adinicb(struct inode *, int *, int *);
extern struct buffer_head * udf_bread(struct inode *, int, int, int *); extern struct buffer_head *udf_bread(struct inode *, int, int, int *);
extern void udf_truncate(struct inode *); extern void udf_truncate(struct inode *);
extern void udf_read_inode(struct inode *); extern void udf_read_inode(struct inode *);
extern void udf_delete_inode(struct inode *); extern void udf_delete_inode(struct inode *);
extern void udf_clear_inode(struct inode *); extern void udf_clear_inode(struct inode *);
extern int udf_write_inode(struct inode *, int); extern int udf_write_inode(struct inode *, int);
extern long udf_block_map(struct inode *, sector_t); extern long udf_block_map(struct inode *, sector_t);
extern int udf_extend_file(struct inode *, struct extent_position *, kernel_long_ad *, sector_t); extern int udf_extend_file(struct inode *, struct extent_position *,
extern int8_t inode_bmap(struct inode *, sector_t, struct extent_position *, kernel_lb_addr *, uint32_t *, sector_t *); kernel_long_ad *, sector_t);
extern int8_t udf_add_aext(struct inode *, struct extent_position *, kernel_lb_addr, uint32_t, int); extern int8_t inode_bmap(struct inode *, sector_t, struct extent_position *,
extern int8_t udf_write_aext(struct inode *, struct extent_position *, kernel_lb_addr, uint32_t, int); kernel_lb_addr *, uint32_t *, sector_t *);
extern int8_t udf_delete_aext(struct inode *, struct extent_position, kernel_lb_addr, uint32_t); extern int8_t udf_add_aext(struct inode *, struct extent_position *,
extern int8_t udf_next_aext(struct inode *, struct extent_position *, kernel_lb_addr *, uint32_t *, int); kernel_lb_addr, uint32_t, int);
extern int8_t udf_current_aext(struct inode *, struct extent_position *, kernel_lb_addr *, uint32_t *, int); extern int8_t udf_write_aext(struct inode *, struct extent_position *,
kernel_lb_addr, uint32_t, int);
extern int8_t udf_delete_aext(struct inode *, struct extent_position,
kernel_lb_addr, uint32_t);
extern int8_t udf_next_aext(struct inode *, struct extent_position *,
kernel_lb_addr *, uint32_t *, int);
extern int8_t udf_current_aext(struct inode *, struct extent_position *,
kernel_lb_addr *, uint32_t *, int);
/* misc.c */ /* misc.c */
extern struct buffer_head *udf_tgetblk(struct super_block *, int); extern struct buffer_head *udf_tgetblk(struct super_block *, int);
extern struct buffer_head *udf_tread(struct super_block *, int); extern struct buffer_head *udf_tread(struct super_block *, int);
extern struct genericFormat *udf_add_extendedattr(struct inode *, uint32_t, uint32_t, uint8_t); extern struct genericFormat *udf_add_extendedattr(struct inode *, uint32_t,
extern struct genericFormat *udf_get_extendedattr(struct inode *, uint32_t, uint8_t); uint32_t, uint8_t);
extern struct buffer_head *udf_read_tagged(struct super_block *, uint32_t, uint32_t, uint16_t *); extern struct genericFormat *udf_get_extendedattr(struct inode *, uint32_t,
extern struct buffer_head *udf_read_ptagged(struct super_block *, kernel_lb_addr, uint32_t, uint16_t *); uint8_t);
extern struct buffer_head *udf_read_tagged(struct super_block *, uint32_t,
uint32_t, uint16_t *);
extern struct buffer_head *udf_read_ptagged(struct super_block *,
kernel_lb_addr, uint32_t,
uint16_t *);
extern void udf_update_tag(char *, int); extern void udf_update_tag(char *, int);
extern void udf_new_tag(char *, uint16_t, uint16_t, uint16_t, uint32_t, int); extern void udf_new_tag(char *, uint16_t, uint16_t, uint16_t, uint32_t, int);
...@@ -129,21 +139,26 @@ extern unsigned int udf_get_last_session(struct super_block *); ...@@ -129,21 +139,26 @@ extern unsigned int udf_get_last_session(struct super_block *);
extern unsigned long udf_get_last_block(struct super_block *); extern unsigned long udf_get_last_block(struct super_block *);
/* partition.c */ /* partition.c */
extern uint32_t udf_get_pblock(struct super_block *, uint32_t, uint16_t, uint32_t); extern uint32_t udf_get_pblock(struct super_block *, uint32_t, uint16_t,
extern uint32_t udf_get_pblock_virt15(struct super_block *, uint32_t, uint16_t, uint32_t); uint32_t);
extern uint32_t udf_get_pblock_virt20(struct super_block *, uint32_t, uint16_t, uint32_t); extern uint32_t udf_get_pblock_virt15(struct super_block *, uint32_t, uint16_t,
extern uint32_t udf_get_pblock_spar15(struct super_block *, uint32_t, uint16_t, uint32_t); uint32_t);
extern uint32_t udf_get_pblock_virt20(struct super_block *, uint32_t, uint16_t,
uint32_t);
extern uint32_t udf_get_pblock_spar15(struct super_block *, uint32_t, uint16_t,
uint32_t);
extern int udf_relocate_blocks(struct super_block *, long, long *); extern int udf_relocate_blocks(struct super_block *, long, long *);
/* unicode.c */ /* unicode.c */
extern int udf_get_filename(struct super_block *, uint8_t *, uint8_t *, int); extern int udf_get_filename(struct super_block *, uint8_t *, uint8_t *, int);
extern int udf_put_filename(struct super_block *, const uint8_t *, uint8_t *, int); extern int udf_put_filename(struct super_block *, const uint8_t *, uint8_t *,
int);
extern int udf_build_ustr(struct ustr *, dstring *, int); extern int udf_build_ustr(struct ustr *, dstring *, int);
extern int udf_CS0toUTF8(struct ustr *, struct ustr *); extern int udf_CS0toUTF8(struct ustr *, struct ustr *);
/* ialloc.c */ /* ialloc.c */
extern void udf_free_inode(struct inode *); extern void udf_free_inode(struct inode *);
extern struct inode * udf_new_inode (struct inode *, int, int *); extern struct inode *udf_new_inode(struct inode *, int, int *);
/* truncate.c */ /* truncate.c */
extern void udf_truncate_tail_extent(struct inode *); extern void udf_truncate_tail_extent(struct inode *);
...@@ -151,18 +166,27 @@ extern void udf_discard_prealloc(struct inode *); ...@@ -151,18 +166,27 @@ extern void udf_discard_prealloc(struct inode *);
extern void udf_truncate_extents(struct inode *); extern void udf_truncate_extents(struct inode *);
/* balloc.c */ /* balloc.c */
extern void udf_free_blocks(struct super_block *, struct inode *, kernel_lb_addr, uint32_t, uint32_t); extern void udf_free_blocks(struct super_block *, struct inode *,
extern int udf_prealloc_blocks(struct super_block *, struct inode *, uint16_t, uint32_t, uint32_t); kernel_lb_addr, uint32_t, uint32_t);
extern int udf_new_block(struct super_block *, struct inode *, uint16_t, uint32_t, int *); extern int udf_prealloc_blocks(struct super_block *, struct inode *, uint16_t,
uint32_t, uint32_t);
extern int udf_new_block(struct super_block *, struct inode *, uint16_t,
uint32_t, int *);
/* fsync.c */ /* fsync.c */
extern int udf_fsync_file(struct file *, struct dentry *, int); extern int udf_fsync_file(struct file *, struct dentry *, int);
/* directory.c */ /* directory.c */
extern struct fileIdentDesc * udf_fileident_read(struct inode *, loff_t *, struct udf_fileident_bh *, struct fileIdentDesc *, struct extent_position *, kernel_lb_addr *, uint32_t *, sector_t *); extern struct fileIdentDesc *udf_fileident_read(struct inode *, loff_t *,
extern struct fileIdentDesc * udf_get_fileident(void * buffer, int bufsize, int * offset); struct udf_fileident_bh *,
extern long_ad * udf_get_filelongad(uint8_t *, int, int *, int); struct fileIdentDesc *,
extern short_ad * udf_get_fileshortad(uint8_t *, int, int *, int); struct extent_position *,
kernel_lb_addr *, uint32_t *,
sector_t *);
extern struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize,
int *offset);
extern long_ad *udf_get_filelongad(uint8_t *, int, int *, int);
extern short_ad *udf_get_fileshortad(uint8_t *, int, int *, int);
/* crc.c */ /* crc.c */
extern uint16_t udf_crc(uint8_t *, uint32_t, uint16_t); extern uint16_t udf_crc(uint8_t *, uint32_t, uint16_t);
......
fs/udf/udftime.c
View file @ cb00ea35
...@@ -46,37 +46,36 @@ ...@@ -46,37 +46,36 @@
#endif #endif
/* How many days come before each month (0-12). */ /* How many days come before each month (0-12). */
static const unsigned short int __mon_yday[2][13] = static const unsigned short int __mon_yday[2][13] = {
{
/* Normal years. */ /* Normal years. */
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }, {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
/* Leap years. */ /* Leap years. */
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 } {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}
}; };
#define MAX_YEAR_SECONDS 69 #define MAX_YEAR_SECONDS 69
#define SPD 0x15180 /*3600*24*/ #define SPD 0x15180 /*3600*24 */
#define SPY(y,l,s) (SPD * (365*y+l)+s) #define SPY(y,l,s) (SPD * (365*y+l)+s)
static time_t year_seconds[MAX_YEAR_SECONDS]= { 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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*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), /*2034*/ SPY(64, 16, 0), SPY(65, 16, 0), SPY(66, 16, 0), SPY(67, 17, 0),
/*2038*/ SPY(68,17,0) /*2038*/ SPY(68, 17, 0)
}; };
extern struct timezone sys_tz; extern struct timezone sys_tz;
...@@ -84,27 +83,23 @@ extern struct timezone sys_tz; ...@@ -84,27 +83,23 @@ extern struct timezone sys_tz;
#define SECS_PER_HOUR (60 * 60) #define SECS_PER_HOUR (60 * 60)
#define SECS_PER_DAY (SECS_PER_HOUR * 24) #define SECS_PER_DAY (SECS_PER_HOUR * 24)
time_t * time_t *udf_stamp_to_time(time_t * dest, long *dest_usec, kernel_timestamp src)
udf_stamp_to_time(time_t *dest, long *dest_usec, kernel_timestamp src)
{ {
int yday; int yday;
uint8_t type = src.typeAndTimezone >> 12; uint8_t type = src.typeAndTimezone >> 12;
int16_t offset; int16_t offset;
if (type == 1) if (type == 1) {
{
offset = src.typeAndTimezone << 4; offset = src.typeAndTimezone << 4;
/* sign extent offset */ /* sign extent offset */
offset = (offset >> 4); offset = (offset >> 4);
if (offset == -2047) /* unspecified offset */ if (offset == -2047) /* unspecified offset */
offset = 0; offset = 0;
} } else
else
offset = 0; offset = 0;
if ((src.year < EPOCH_YEAR) || if ((src.year < EPOCH_YEAR) ||
(src.year >= EPOCH_YEAR+MAX_YEAR_SECONDS)) (src.year >= EPOCH_YEAR + MAX_YEAR_SECONDS)) {
{
*dest = -1; *dest = -1;
*dest_usec = -1; *dest_usec = -1;
return NULL; return NULL;
...@@ -112,16 +107,16 @@ udf_stamp_to_time(time_t *dest, long *dest_usec, kernel_timestamp src) ...@@ -112,16 +107,16 @@ udf_stamp_to_time(time_t *dest, long *dest_usec, kernel_timestamp src)
*dest = year_seconds[src.year - EPOCH_YEAR]; *dest = year_seconds[src.year - EPOCH_YEAR];
*dest -= offset * 60; *dest -= offset * 60;
yday = ((__mon_yday[__isleap (src.year)] yday = ((__mon_yday[__isleap(src.year)]
[src.month-1]) + (src.day-1)); [src.month - 1]) + (src.day - 1));
*dest += ( ( (yday* 24) + src.hour ) * 60 + src.minute ) * 60 + src.second; *dest += (((yday * 24) + src.hour) * 60 + src.minute) * 60 + src.second;
*dest_usec = src.centiseconds * 10000 + src.hundredsOfMicroseconds * 100 + src.microseconds; *dest_usec =
src.centiseconds * 10000 + src.hundredsOfMicroseconds * 100 +
src.microseconds;
return dest; return dest;
} }
kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
kernel_timestamp *
udf_time_to_stamp(kernel_timestamp *dest, struct timespec ts)
{ {
long int days, rem, y; long int days, rem, y;
const unsigned short int *ip; const unsigned short int *ip;
...@@ -146,27 +141,27 @@ udf_time_to_stamp(kernel_timestamp *dest, struct timespec ts) ...@@ -146,27 +141,27 @@ udf_time_to_stamp(kernel_timestamp *dest, struct timespec ts)
#define DIV(a,b) ((a) / (b) - ((a) % (b) < 0)) #define DIV(a,b) ((a) / (b) - ((a) % (b) < 0))
#define LEAPS_THRU_END_OF(y) (DIV (y, 4) - DIV (y, 100) + DIV (y, 400)) #define LEAPS_THRU_END_OF(y) (DIV (y, 4) - DIV (y, 100) + DIV (y, 400))
while (days < 0 || days >= (__isleap(y) ? 366 : 365)) while (days < 0 || days >= (__isleap(y) ? 366 : 365)) {
{
long int yg = y + days / 365 - (days % 365 < 0); long int yg = y + days / 365 - (days % 365 < 0);
/* Adjust DAYS and Y to match the guessed year. */ /* Adjust DAYS and Y to match the guessed year. */
days -= ((yg - y) * 365 days -= ((yg - y) * 365 + LEAPS_THRU_END_OF(yg - 1)
+ LEAPS_THRU_END_OF (yg - 1) - LEAPS_THRU_END_OF(y - 1));
- LEAPS_THRU_END_OF (y - 1));
y = yg; y = yg;
} }
dest->year = y; dest->year = y;
ip = __mon_yday[__isleap(y)]; ip = __mon_yday[__isleap(y)];
for (y = 11; days < (long int) ip[y]; --y) for (y = 11; days < (long int)ip[y]; --y)
continue; continue;
days -= ip[y]; days -= ip[y];
dest->month = y + 1; dest->month = y + 1;
dest->day = days + 1; dest->day = days + 1;
dest->centiseconds = ts.tv_nsec / 10000000; dest->centiseconds = ts.tv_nsec / 10000000;
dest->hundredsOfMicroseconds = (ts.tv_nsec / 1000 - dest->centiseconds * 10000) / 100; dest->hundredsOfMicroseconds =
dest->microseconds = (ts.tv_nsec / 1000 - dest->centiseconds * 10000 - (ts.tv_nsec / 1000 - dest->centiseconds * 10000) / 100;
dest->microseconds =
(ts.tv_nsec / 1000 - dest->centiseconds * 10000 -
dest->hundredsOfMicroseconds * 100); dest->hundredsOfMicroseconds * 100);
return dest; return dest;
} }
......
fs/udf/unicode.c
View file @ cb00ea35
...@@ -29,9 +29,9 @@ ...@@ -29,9 +29,9 @@
static int udf_translate_to_linux(uint8_t *, uint8_t *, int, uint8_t *, int); 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) ) if ((!dest) || (!src) || (!strlen) || (strlen > UDF_NAME_LEN - 2))
return 0; return 0;
memset(dest, 0, sizeof(struct ustr)); memset(dest, 0, sizeof(struct ustr));
memcpy(dest->u_name, src, strlen); memcpy(dest->u_name, src, strlen);
...@@ -43,33 +43,33 @@ static int udf_char_to_ustr(struct ustr *dest, const uint8_t *src, int strlen) ...@@ -43,33 +43,33 @@ static int udf_char_to_ustr(struct ustr *dest, const uint8_t *src, int strlen)
/* /*
* udf_build_ustr * 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; int usesize;
if ( (!dest) || (!ptr) || (!size) ) if ((!dest) || (!ptr) || (!size))
return -1; return -1;
memset(dest, 0, sizeof(struct ustr)); memset(dest, 0, sizeof(struct ustr));
usesize= (size > UDF_NAME_LEN) ? UDF_NAME_LEN : size; usesize = (size > UDF_NAME_LEN) ? UDF_NAME_LEN : size;
dest->u_cmpID=ptr[0]; dest->u_cmpID = ptr[0];
dest->u_len=ptr[size-1]; dest->u_len = ptr[size - 1];
memcpy(dest->u_name, ptr+1, usesize-1); memcpy(dest->u_name, ptr + 1, usesize - 1);
return 0; return 0;
} }
/* /*
* udf_build_ustr_exact * 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) ) if ((!dest) || (!ptr) || (!exactsize))
return -1; return -1;
memset(dest, 0, sizeof(struct ustr)); memset(dest, 0, sizeof(struct ustr));
dest->u_cmpID=ptr[0]; dest->u_cmpID = ptr[0];
dest->u_len=exactsize-1; dest->u_len = exactsize - 1;
memcpy(dest->u_name, ptr+1, exactsize-1); memcpy(dest->u_name, ptr + 1, exactsize - 1);
return 0; return 0;
} }
...@@ -108,22 +108,20 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i) ...@@ -108,22 +108,20 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
cmp_id = ocu_i->u_cmpID; cmp_id = ocu_i->u_cmpID;
utf_o->u_len = 0; utf_o->u_len = 0;
if (ocu_len == 0) if (ocu_len == 0) {
{
memset(utf_o, 0, sizeof(struct ustr)); memset(utf_o, 0, sizeof(struct ustr));
utf_o->u_cmpID = 0; utf_o->u_cmpID = 0;
utf_o->u_len = 0; utf_o->u_len = 0;
return 0; return 0;
} }
if ((cmp_id != 8) && (cmp_id != 16)) if ((cmp_id != 8) && (cmp_id != 16)) {
{ printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n",
printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n", cmp_id, ocu_i->u_name); cmp_id, ocu_i->u_name);
return 0; return 0;
} }
for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN-3)) ;) for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) {
{
/* Expand OSTA compressed Unicode to Unicode */ /* Expand OSTA compressed Unicode to Unicode */
c = ocu[i++]; c = ocu[i++];
...@@ -132,20 +130,22 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i) ...@@ -132,20 +130,22 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
/* Compress Unicode to UTF-8 */ /* Compress Unicode to UTF-8 */
if (c < 0x80U) if (c < 0x80U)
utf_o->u_name[utf_o->u_len++] = (uint8_t)c; utf_o->u_name[utf_o->u_len++] = (uint8_t) c;
else if (c < 0x800U) else if (c < 0x800U) {
{ utf_o->u_name[utf_o->u_len++] =
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xc0 | (c >> 6)); (uint8_t) (0xc0 | (c >> 6));
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f)); utf_o->u_name[utf_o->u_len++] =
} (uint8_t) (0x80 | (c & 0x3f));
else } else {
{ utf_o->u_name[utf_o->u_len++] =
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xe0 | (c >> 12)); (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++] =
utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f)); (uint8_t) (0x80 | ((c >> 6) & 0x3f));
} utf_o->u_name[utf_o->u_len++] =
} (uint8_t) (0x80 | (c & 0x3f));
utf_o->u_cmpID=8; }
}
utf_o->u_cmpID = 8;
return utf_o->u_len; return utf_o->u_len;
} }
...@@ -173,7 +173,7 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i) ...@@ -173,7 +173,7 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
* November 12, 1997 - Andrew E. Mileski * November 12, 1997 - Andrew E. Mileski
* Written, tested, and released. * 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; unsigned c, i, max_val, utf_char;
int utf_cnt, u_len; int utf_cnt, u_len;
...@@ -182,53 +182,38 @@ static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length) ...@@ -182,53 +182,38 @@ static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length)
ocu[0] = 8; ocu[0] = 8;
max_val = 0xffU; max_val = 0xffU;
try_again: try_again:
u_len = 0U; u_len = 0U;
utf_char = 0U; utf_char = 0U;
utf_cnt = 0U; utf_cnt = 0U;
for (i = 0U; i < utf->u_len; i++) 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 */ /* Complete a multi-byte UTF-8 character */
if (utf_cnt) if (utf_cnt) {
{
utf_char = (utf_char << 6) | (c & 0x3fU); utf_char = (utf_char << 6) | (c & 0x3fU);
if (--utf_cnt) if (--utf_cnt)
continue; continue;
} } else {
else
{
/* Check for a multi-byte UTF-8 character */ /* Check for a multi-byte UTF-8 character */
if (c & 0x80U) if (c & 0x80U) {
{
/* Start a multi-byte UTF-8 character */ /* Start a multi-byte UTF-8 character */
if ((c & 0xe0U) == 0xc0U) if ((c & 0xe0U) == 0xc0U) {
{
utf_char = c & 0x1fU; utf_char = c & 0x1fU;
utf_cnt = 1; utf_cnt = 1;
} } else if ((c & 0xf0U) == 0xe0U) {
else if ((c & 0xf0U) == 0xe0U)
{
utf_char = c & 0x0fU; utf_char = c & 0x0fU;
utf_cnt = 2; utf_cnt = 2;
} } else if ((c & 0xf8U) == 0xf0U) {
else if ((c & 0xf8U) == 0xf0U)
{
utf_char = c & 0x07U; utf_char = c & 0x07U;
utf_cnt = 3; utf_cnt = 3;
} } else if ((c & 0xfcU) == 0xf8U) {
else if ((c & 0xfcU) == 0xf8U)
{
utf_char = c & 0x03U; utf_char = c & 0x03U;
utf_cnt = 4; utf_cnt = 4;
} } else if ((c & 0xfeU) == 0xfcU) {
else if ((c & 0xfeU) == 0xfcU)
{
utf_char = c & 0x01U; utf_char = c & 0x01U;
utf_cnt = 5; utf_cnt = 5;
} } else
else
goto error_out; goto error_out;
continue; continue;
} else } else
...@@ -237,37 +222,33 @@ static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length) ...@@ -237,37 +222,33 @@ static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length)
} }
/* Choose no compression if necessary */ /* Choose no compression if necessary */
if (utf_char > max_val) if (utf_char > max_val) {
{ if (0xffU == max_val) {
if ( 0xffU == max_val )
{
max_val = 0xffffU; max_val = 0xffffU;
ocu[0] = (uint8_t)0x10U; ocu[0] = (uint8_t) 0x10U;
goto try_again; goto try_again;
} }
goto error_out; goto error_out;
} }
if (max_val == 0xffffU) 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) {
if (utf_cnt) error_out:
{
error_out:
ocu[++u_len] = '?'; ocu[++u_len] = '?';
printk(KERN_DEBUG "udf: bad UTF-8 character\n"); 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; return u_len + 1;
} }
static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, struct ustr *ocu_i) static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o,
struct ustr *ocu_i)
{ {
uint8_t *ocu; uint8_t *ocu;
uint32_t c; uint32_t c;
...@@ -280,22 +261,20 @@ static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, struct ustr * ...@@ -280,22 +261,20 @@ static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, struct ustr *
cmp_id = ocu_i->u_cmpID; cmp_id = ocu_i->u_cmpID;
utf_o->u_len = 0; utf_o->u_len = 0;
if (ocu_len == 0) if (ocu_len == 0) {
{
memset(utf_o, 0, sizeof(struct ustr)); memset(utf_o, 0, sizeof(struct ustr));
utf_o->u_cmpID = 0; utf_o->u_cmpID = 0;
utf_o->u_len = 0; utf_o->u_len = 0;
return 0; return 0;
} }
if ((cmp_id != 8) && (cmp_id != 16)) if ((cmp_id != 8) && (cmp_id != 16)) {
{ printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n",
printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n", cmp_id, ocu_i->u_name); cmp_id, ocu_i->u_name);
return 0; return 0;
} }
for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN-3)) ;) for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) {
{
/* Expand OSTA compressed Unicode to Unicode */ /* Expand OSTA compressed Unicode to Unicode */
c = ocu[i++]; c = ocu[i++];
if (cmp_id == 16) if (cmp_id == 16)
...@@ -304,12 +283,13 @@ static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, struct ustr * ...@@ -304,12 +283,13 @@ static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, struct ustr *
utf_o->u_len += nls->uni2char(c, &utf_o->u_name[utf_o->u_len], utf_o->u_len += nls->uni2char(c, &utf_o->u_name[utf_o->u_len],
UDF_NAME_LEN - utf_o->u_len); UDF_NAME_LEN - utf_o->u_len);
} }
utf_o->u_cmpID=8; utf_o->u_cmpID = 8;
return utf_o->u_len; return utf_o->u_len;
} }
static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni, int length) static int udf_NLStoCS0(struct nls_table *nls, dstring * ocu, struct ustr *uni,
int length)
{ {
unsigned len, i, max_val; unsigned len, i, max_val;
uint16_t uni_char; uint16_t uni_char;
...@@ -319,93 +299,87 @@ static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni, i ...@@ -319,93 +299,87 @@ static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni, i
ocu[0] = 8; ocu[0] = 8;
max_val = 0xffU; max_val = 0xffU;
try_again: try_again:
u_len = 0U; u_len = 0U;
for (i = 0U; i < uni->u_len; i++) for (i = 0U; i < uni->u_len; i++) {
{ len = nls->char2uni(&uni->u_name[i], uni->u_len - i, &uni_char);
len = nls->char2uni(&uni->u_name[i], uni->u_len-i, &uni_char);
if (len <= 0) if (len <= 0)
continue; continue;
if (uni_char > max_val) if (uni_char > max_val) {
{
max_val = 0xffffU; max_val = 0xffffU;
ocu[0] = (uint8_t)0x10U; ocu[0] = (uint8_t) 0x10U;
goto try_again; goto try_again;
} }
if (max_val == 0xffffU) if (max_val == 0xffffU)
ocu[++u_len] = (uint8_t)(uni_char >> 8); ocu[++u_len] = (uint8_t) (uni_char >> 8);
ocu[++u_len] = (uint8_t)(uni_char & 0xffU); ocu[++u_len] = (uint8_t) (uni_char & 0xffU);
i += len - 1; i += len - 1;
} }
ocu[length - 1] = (uint8_t)u_len + 1; ocu[length - 1] = (uint8_t) u_len + 1;
return u_len + 1; return u_len + 1;
} }
int udf_get_filename(struct super_block *sb, uint8_t *sname, uint8_t *dname, int flen) int udf_get_filename(struct super_block *sb, uint8_t * sname, uint8_t * dname,
int flen)
{ {
struct ustr filename, unifilename; struct ustr filename, unifilename;
int len; int len;
if (udf_build_ustr_exact(&unifilename, sname, flen)) if (udf_build_ustr_exact(&unifilename, sname, flen)) {
{
return 0; return 0;
} }
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
{ if (!udf_CS0toUTF8(&filename, &unifilename)) {
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; return 0;
} }
} } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) if (!udf_CS0toNLS
{ (UDF_SB(sb)->s_nls_map, &filename, &unifilename)) {
if (!udf_CS0toNLS(UDF_SB(sb)->s_nls_map, &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; return 0;
} }
} } else
else
return 0; return 0;
if ((len = udf_translate_to_linux(dname, filename.u_name, filename.u_len, if ((len =
unifilename.u_name, unifilename.u_len))) udf_translate_to_linux(dname, filename.u_name, filename.u_len,
{ unifilename.u_name, unifilename.u_len))) {
return len; return len;
} }
return 0; 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; struct ustr unifilename;
int namelen; int namelen;
if ( !(udf_char_to_ustr(&unifilename, sname, flen)) ) if (!(udf_char_to_ustr(&unifilename, sname, flen))) {
{
return 0; return 0;
} }
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
{ if (!
if ( !(namelen = udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN)) ) (namelen =
{ udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN))) {
return 0; return 0;
} }
} } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) if (!
{ (namelen =
if ( !(namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename, UDF_NAME_LEN)) ) udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename,
{ UDF_NAME_LEN))) {
return 0; return 0;
} }
} } else
else
return 0; return 0;
return namelen; return namelen;
...@@ -416,7 +390,8 @@ int udf_put_filename(struct super_block *sb, const uint8_t *sname, uint8_t *dnam ...@@ -416,7 +390,8 @@ int udf_put_filename(struct super_block *sb, const uint8_t *sname, uint8_t *dnam
#define CRC_MARK '#' #define CRC_MARK '#'
#define EXT_SIZE 5 #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 index, newIndex = 0, needsCRC = 0;
int extIndex = 0, newExtIndex = 0, hasExt = 0; int extIndex = 0, newExtIndex = 0, hasExt = 0;
...@@ -425,31 +400,26 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen ...@@ -425,31 +400,26 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
const uint8_t hexChar[] = "0123456789ABCDEF"; const uint8_t hexChar[] = "0123456789ABCDEF";
if (udfName[0] == '.' && (udfLen == 1 || if (udfName[0] == '.' && (udfLen == 1 ||
(udfLen == 2 && udfName[1] == '.'))) (udfLen == 2 && udfName[1] == '.'))) {
{
needsCRC = 1; needsCRC = 1;
newIndex = udfLen; newIndex = udfLen;
memcpy(newName, udfName, udfLen); memcpy(newName, udfName, udfLen);
} } else {
else for (index = 0; index < udfLen; index++) {
{
for (index = 0; index < udfLen; index++)
{
curr = udfName[index]; curr = udfName[index];
if (curr == '/' || curr == 0) if (curr == '/' || curr == 0) {
{
needsCRC = 1; needsCRC = 1;
curr = ILLEGAL_CHAR_MARK; curr = ILLEGAL_CHAR_MARK;
while (index+1 < udfLen && (udfName[index+1] == '/' || while (index + 1 < udfLen
udfName[index+1] == 0)) && (udfName[index + 1] == '/'
|| udfName[index + 1] == 0))
index++; index++;
} }
if (curr == EXT_MARK && (udfLen - index - 1) <= EXT_SIZE) if (curr == EXT_MARK
{ && (udfLen - index - 1) <= EXT_SIZE) {
if (udfLen == index + 1) if (udfLen == index + 1)
hasExt = 0; hasExt = 0;
else else {
{
hasExt = 1; hasExt = 1;
extIndex = index; extIndex = index;
newExtIndex = newIndex; newExtIndex = newIndex;
...@@ -461,26 +431,29 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen ...@@ -461,26 +431,29 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
needsCRC = 1; needsCRC = 1;
} }
} }
if (needsCRC) if (needsCRC) {
{
uint8_t ext[EXT_SIZE]; uint8_t ext[EXT_SIZE];
int localExtIndex = 0; int localExtIndex = 0;
if (hasExt) if (hasExt) {
{
int maxFilenameLen; int maxFilenameLen;
for(index = 0; index<EXT_SIZE && extIndex + index +1 < udfLen; for (index = 0;
index++ ) index < EXT_SIZE && extIndex + index + 1 < udfLen;
{ index++) {
curr = udfName[extIndex + index + 1]; curr = udfName[extIndex + index + 1];
if (curr == '/' || curr == 0) if (curr == '/' || curr == 0) {
{
needsCRC = 1; needsCRC = 1;
curr = ILLEGAL_CHAR_MARK; curr = ILLEGAL_CHAR_MARK;
while(extIndex + index + 2 < udfLen && (index + 1 < EXT_SIZE while (extIndex + index + 2 < udfLen
&& (udfName[extIndex + index + 2] == '/' || && (index + 1 < EXT_SIZE
udfName[extIndex + index + 2] == 0))) &&
(udfName
[extIndex + index + 2] ==
'/'
|| udfName[extIndex +
index + 2] ==
0)))
index++; index++;
} }
ext[localExtIndex++] = curr; ext[localExtIndex++] = curr;
...@@ -490,8 +463,7 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen ...@@ -490,8 +463,7 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
newIndex = maxFilenameLen; newIndex = maxFilenameLen;
else else
newIndex = newExtIndex; newIndex = newExtIndex;
} } else if (newIndex > 250)
else if (newIndex > 250)
newIndex = 250; newIndex = 250;
newName[newIndex++] = CRC_MARK; newName[newIndex++] = CRC_MARK;
valueCRC = udf_crc(fidName, fidNameLen, 0); valueCRC = udf_crc(fidName, fidNameLen, 0);
...@@ -500,10 +472,9 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen ...@@ -500,10 +472,9 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4]; newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4];
newName[newIndex++] = hexChar[(valueCRC & 0x000f)]; newName[newIndex++] = hexChar[(valueCRC & 0x000f)];
if (hasExt) if (hasExt) {
{
newName[newIndex++] = EXT_MARK; newName[newIndex++] = EXT_MARK;
for (index = 0;index < localExtIndex ;index++ ) for (index = 0; index < localExtIndex; index++)
newName[newIndex++] = ext[index]; newName[newIndex++] = ext[index];
} }
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7