redonkable/remarkable-linux
redonkable/remarkable-linux
1
0
Fork 0
Code Releases Activity

udf: remove some ugly macros

Browse source 
remove macros:
- UDF_SB_PARTMAPS
- UDF_SB_PARTTYPE
- UDF_SB_PARTROOT
- UDF_SB_PARTLEN
- UDF_SB_PARTVSN
- UDF_SB_PARTNUM
- UDF_SB_TYPESPAR
- UDF_SB_TYPEVIRT
- UDF_SB_PARTFUNC
- UDF_SB_PARTFLAGS
- UDF_SB_VOLIDENT
- UDF_SB_NUMPARTS
- UDF_SB_PARTITION
- UDF_SB_SESSION
- UDF_SB_ANCHOR
- UDF_SB_LASTBLOCK
- UDF_SB_LVIDBH
- UDF_SB_LVID
- UDF_SB_UMASK
- UDF_SB_GID
- UDF_SB_UID
- UDF_SB_RECORDTIME
- UDF_SB_SERIALNUM
- UDF_SB_UDFREV
- UDF_SB_FLAGS
- UDF_SB_VAT
- UDF_UPDATE_UDFREV
- UDF_SB_FREE
and open code them

convert UDF_SB_LVIDIU macro to udf_sb_lvidiu function

rename some struct udf_sb_info fields:
- s_volident to s_volume_ident
- s_lastblock to s_last_block
- s_lvidbh to s_lvid_bh
- s_recordtime to s_record_time
- s_serialnum to s_serial_number;
- s_vat to s_vat_inode;

Signed-off-by: Marcin Slusarz <marcin.slusarz@gmail.com>
Cc: Ben Fennema <bfennema@falcon.csc.calpoly.edu>
Cc: Jan Kara <jack@suse.cz>
Acked-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Marcin Slusarz 2008-02-08 04:20:30 -08:00 committed by Linus Torvalds
parent 3a71fc5de5
commit 6c79e987d6
11 changed files with 507 additions and 440 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

136
fs/udf/balloc.c
View file

@ -88,7 +88,7 @@ static int read_block_bitmap(struct super_block *sb,
kernel_lb_addr loc; kernel_lb_addr loc;
loc.logicalBlockNum = bitmap->s_extPosition; loc.logicalBlockNum = bitmap->s_extPosition;
loc.partitionReferenceNum = UDF_SB_PARTITION(sb); loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
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) {
@ -155,10 +155,10 @@ 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) > sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {
udf_debug("%d < %d || %d + %d > %d\n", udf_debug("%d < %d || %d + %d > %d\n",
bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count, bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)); sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len);
goto error_return; goto error_return;
} }
@ -188,9 +188,10 @@ do_more:
} else { } else {
if (inode) if (inode)
DQUOT_FREE_BLOCK(inode, 1); DQUOT_FREE_BLOCK(inode, 1);
if (UDF_SB_LVIDBH(sb)) { if (sbi->s_lvid_bh) {
UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] = struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + 1); lvid->freeSpaceTable[sbi->s_partition] =
cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[sbi->s_partition]) + 1);
} }
} }
} }
@ -202,8 +203,8 @@ do_more:
} }
error_return: error_return:
sb->s_dirt = 1; sb->s_dirt = 1;
if (UDF_SB_LVIDBH(sb)) if (sbi->s_lvid_bh)
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); mark_buffer_dirty(sbi->s_lvid_bh);
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
return; return;
} }
@ -219,16 +220,18 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
int bit, block, block_group, group_start; int bit, block, block_group, group_start;
int nr_groups, bitmap_nr; int nr_groups, bitmap_nr;
struct buffer_head *bh; struct buffer_head *bh;
__u32 part_len;
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition)) part_len = sbi->s_partmaps[partition].s_partition_len;
if (first_block < 0 || first_block >= part_len)
goto out; goto out;
if (first_block + block_count > UDF_SB_PARTLEN(sb, partition)) if (first_block + block_count > part_len)
block_count = UDF_SB_PARTLEN(sb, partition) - first_block; block_count = part_len - first_block;
repeat: repeat:
nr_groups = (UDF_SB_PARTLEN(sb, partition) + nr_groups = (sbi->s_partmaps[partition].s_partition_len +
(sizeof(struct spaceBitmapDesc) << 3) + (sizeof(struct spaceBitmapDesc) << 3) +
(sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8); (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
block = first_block + (sizeof(struct spaceBitmapDesc) << 3); block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
@ -261,10 +264,11 @@ repeat:
if (block_count > 0) if (block_count > 0)
goto repeat; goto repeat;
out: out:
if (UDF_SB_LVIDBH(sb)) { if (sbi->s_lvid_bh) {
UDF_SB_LVID(sb)->freeSpaceTable[partition] = struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count); lvid->freeSpaceTable[partition] =
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - alloc_count);
mark_buffer_dirty(sbi->s_lvid_bh);
} }
sb->s_dirt = 1; sb->s_dirt = 1;
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
@ -287,7 +291,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
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 >= sbi->s_partmaps[partition].s_partition_len)
goal = 0; goal = 0;
nr_groups = bitmap->s_nr_groups; nr_groups = bitmap->s_nr_groups;
@ -389,10 +393,11 @@ got_block:
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
if (UDF_SB_LVIDBH(sb)) { if (sbi->s_lvid_bh) {
UDF_SB_LVID(sb)->freeSpaceTable[partition] = struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1); lvid->freeSpaceTable[partition] =
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - 1);
mark_buffer_dirty(sbi->s_lvid_bh);
} }
sb->s_dirt = 1; sb->s_dirt = 1;
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
@ -421,10 +426,10 @@ 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) > sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {
udf_debug("%d < %d || %d + %d > %d\n", udf_debug("%d < %d || %d + %d > %d\n",
bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count, bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)); sbi->s_partmaps[bloc.partitionReferenceNum]->s_partition_len);
goto error_return; goto error_return;
} }
@ -432,10 +437,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 (sbi->s_lvid_bh) {
UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] = struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + count); lvid->freeSpaceTable[sbi->s_partition] =
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[sbi->s_partition]) + count);
mark_buffer_dirty(sbi->s_lvid_bh);
} }
start = bloc.logicalBlockNum + offset; start = bloc.logicalBlockNum + offset;
@ -559,7 +565,7 @@ static void udf_table_free_blocks(struct super_block *sb,
} }
epos.offset = sizeof(struct allocExtDesc); epos.offset = sizeof(struct allocExtDesc);
} }
if (UDF_SB_UDFREV(sb) >= 0x0200) if (sbi->s_udfrev >= 0x0200)
udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1, udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
epos.block.logicalBlockNum, sizeof(tag)); epos.block.logicalBlockNum, sizeof(tag));
else else
@ -627,7 +633,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
struct extent_position epos; struct extent_position epos;
int8_t etype = -1; int8_t etype = -1;
if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition)) if (first_block < 0 || first_block >= sbi->s_partmaps[partition].s_partition_len)
return 0; return 0;
if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT) if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
@ -670,10 +676,11 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
brelse(epos.bh); brelse(epos.bh);
if (alloc_count && UDF_SB_LVIDBH(sb)) { if (alloc_count && sbi->s_lvid_bh) {
UDF_SB_LVID(sb)->freeSpaceTable[partition] = struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count); lvid->freeSpaceTable[partition] =
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - alloc_count);
mark_buffer_dirty(sbi->s_lvid_bh);
sb->s_dirt = 1; sb->s_dirt = 1;
} }
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
@ -703,7 +710,7 @@ static int udf_table_new_block(struct super_block *sb,
return newblock; return newblock;
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition)) if (goal < 0 || goal >= sbi->s_partmaps[partition].s_partition_len)
goal = 0; goal = 0;
/* We search for the closest matching block to goal. If we find a exact hit, /* We search for the closest matching block to goal. If we find a exact hit,
@ -771,10 +778,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 (sbi->s_lvid_bh) {
UDF_SB_LVID(sb)->freeSpaceTable[partition] = struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1); lvid->freeSpaceTable[partition] =
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - 1);
mark_buffer_dirty(sbi->s_lvid_bh);
} }
sb->s_dirt = 1; sb->s_dirt = 1;
@ -789,22 +797,23 @@ inline void udf_free_blocks(struct super_block *sb,
uint32_t count) uint32_t count)
{ {
uint16_t partition = bloc.partitionReferenceNum; uint16_t partition = bloc.partitionReferenceNum;
struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) { if (map->s_partition_flags & 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, map->s_uspace.s_bitmap,
bloc, offset, count); bloc, offset, count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) { } else if (map->s_partition_flags & 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, map->s_uspace.s_table,
bloc, offset, count); bloc, offset, count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) { } else if (map->s_partition_flags & 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, map->s_fspace.s_bitmap,
bloc, offset, count); bloc, offset, count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) { } else if (map->s_partition_flags & 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, map->s_fspace.s_table,
bloc, offset, count); bloc, offset, count);
} else { } else {
return; return;
@ -816,21 +825,23 @@ inline int udf_prealloc_blocks(struct super_block *sb,
uint16_t partition, uint32_t first_block, uint16_t partition, uint32_t first_block,
uint32_t block_count) uint32_t block_count)
{ {
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) { struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
if (map->s_partition_flags & 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, map->s_uspace.s_bitmap,
partition, first_block, block_count); partition, first_block, block_count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) { } else if (map->s_partition_flags & 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, map->s_uspace.s_table,
partition, first_block, block_count); partition, first_block, block_count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) { } else if (map->s_partition_flags & 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, map->s_fspace.s_bitmap,
partition, first_block, block_count); partition, first_block, block_count);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) { } else if (map->s_partition_flags & 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, map->s_fspace.s_table,
partition, first_block, block_count); partition, first_block, block_count);
} else { } else {
return 0; return 0;
@ -842,23 +853,24 @@ inline int udf_new_block(struct super_block *sb,
uint16_t partition, uint32_t goal, int *err) uint16_t partition, uint32_t goal, int *err)
{ {
int ret; int ret;
struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) { if (map->s_partition_flags & 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, map->s_uspace.s_bitmap,
partition, goal, err); partition, goal, err);
return ret; return ret;
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) { } else if (map->s_partition_flags & 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, map->s_uspace.s_table,
partition, goal, err); partition, goal, err);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) { } else if (map->s_partition_flags & 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, map->s_fspace.s_bitmap,
partition, goal, err); partition, goal, err);
} else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) { } else if (map->s_partition_flags & 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, map->s_fspace.s_table,
partition, goal, err); partition, goal, err);
} else { } else {
*err = -EIO; *err = -EIO;

2
fs/udf/file.c
View file

@ -192,7 +192,7 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
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(inode->i_sb)->s_volume_ident, 32) ? -EFAULT : 0;
case UDF_RELOCATE_BLOCKS: case UDF_RELOCATE_BLOCKS:
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EACCES; return -EACCES;

33
fs/udf/ialloc.c
View file

@ -43,15 +43,17 @@ void udf_free_inode(struct inode *inode)
clear_inode(inode); clear_inode(inode);
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
if (sbi->s_lvidbh) { if (sbi->s_lvid_bh) {
struct logicalVolIntegrityDescImpUse *lvidiu =
udf_sb_lvidiu(sbi);
if (S_ISDIR(inode->i_mode)) if (S_ISDIR(inode->i_mode))
UDF_SB_LVIDIU(sb)->numDirs = lvidiu->numDirs =
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) - 1); cpu_to_le32(le32_to_cpu(lvidiu->numDirs) - 1);
else else
UDF_SB_LVIDIU(sb)->numFiles = lvidiu->numFiles =
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) - 1); cpu_to_le32(le32_to_cpu(lvidiu->numFiles) - 1);
mark_buffer_dirty(sbi->s_lvidbh); mark_buffer_dirty(sbi->s_lvid_bh);
} }
mutex_unlock(&sbi->s_alloc_mutex); mutex_unlock(&sbi->s_alloc_mutex);
@ -88,21 +90,23 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
} }
mutex_lock(&sbi->s_alloc_mutex); mutex_lock(&sbi->s_alloc_mutex);
if (UDF_SB_LVIDBH(sb)) { if (sbi->s_lvid_bh) {
struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
struct logicalVolIntegrityDescImpUse *lvidiu = udf_sb_lvidiu(sbi);
struct logicalVolHeaderDesc *lvhd; struct logicalVolHeaderDesc *lvhd;
uint64_t uniqueID; uint64_t uniqueID;
lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->logicalVolContentsUse); lvhd = (struct logicalVolHeaderDesc *)(lvid->logicalVolContentsUse);
if (S_ISDIR(mode)) if (S_ISDIR(mode))
UDF_SB_LVIDIU(sb)->numDirs = lvidiu->numDirs =
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) + 1); cpu_to_le32(le32_to_cpu(lvidiu->numDirs) + 1);
else else
UDF_SB_LVIDIU(sb)->numFiles = lvidiu->numFiles =
cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) + 1); cpu_to_le32(le32_to_cpu(lvidiu->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;
lvhd->uniqueID = cpu_to_le64(uniqueID); lvhd->uniqueID = cpu_to_le64(uniqueID);
mark_buffer_dirty(UDF_SB_LVIDBH(sb)); mark_buffer_dirty(sbi->s_lvid_bh);
} }
inode->i_mode = mode; inode->i_mode = mode;
inode->i_uid = current->fsuid; inode->i_uid = current->fsuid;
@ -123,7 +127,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
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); if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)
sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE;
UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL); UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
} else { } else {
UDF_I_EFE(inode) = 0; UDF_I_EFE(inode) = 0;

34
fs/udf/inode.c
View file

@ -1081,6 +1081,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
time_t convtime; time_t convtime;
long convtime_usec; long convtime_usec;
int offset; int offset;
struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
fe = (struct fileEntry *)bh->b_data; fe = (struct fileEntry *)bh->b_data;
efe = (struct extendedFileEntry *)bh->b_data; efe = (struct extendedFileEntry *)bh->b_data;
@ -1160,7 +1161,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
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 = sbi->s_record_time;
} }
if (udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
@ -1168,7 +1169,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
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 = sbi->s_record_time;
} }
if (udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
@ -1176,7 +1177,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
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 = sbi->s_record_time;
} }
UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID); UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID);
@ -1192,7 +1193,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
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 = sbi->s_record_time;
} }
if (udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
@ -1200,7 +1201,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
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 = sbi->s_record_time;
} }
if (udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
@ -1208,7 +1209,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
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) = sbi->s_record_time;
} }
if (udf_stamp_to_time(&convtime, &convtime_usec, if (udf_stamp_to_time(&convtime, &convtime_usec,
@ -1216,7 +1217,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
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 = sbi->s_record_time;
} }
UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID); UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
@ -1353,6 +1354,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
int i; int i;
kernel_timestamp cpu_time; kernel_timestamp cpu_time;
int err = 0; int err = 0;
struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0)); bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0));
if (!bh) { if (!bh) {
@ -1537,11 +1539,11 @@ static int udf_update_inode(struct inode *inode, int do_sync)
ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY)); ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
fe->icbTag.flags = cpu_to_le16(icbflags); fe->icbTag.flags = cpu_to_le16(icbflags);
if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200) if (sbi->s_udfrev >= 0x0200)
fe->descTag.descVersion = cpu_to_le16(3); fe->descTag.descVersion = cpu_to_le16(3);
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(sbi->s_serial_number);
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);
@ -1585,7 +1587,7 @@ struct inode *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(sb)->s_partmaps[ino.partitionReferenceNum].s_partition_len) {
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);
@ -1667,7 +1669,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
mark_inode_dirty(inode); mark_inode_dirty(inode);
} }
} }
if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200) if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200)
udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1, udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
epos->block.logicalBlockNum, sizeof(tag)); epos->block.logicalBlockNum, sizeof(tag));
else else
@ -1690,7 +1692,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
} }
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(inode->i_sb)->s_udfrev >= 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));
@ -1711,7 +1713,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
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_SB(inode->i_sb)->s_udfrev >= 0x0201)
udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize)); 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));
@ -1754,7 +1756,7 @@ int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,
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(inode->i_sb)->s_udfrev >= 0x0201) {
struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data; struct allocExtDesc *aed = (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));
@ -1907,7 +1909,7 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
aed->lengthAllocDescs = aed->lengthAllocDescs =
cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2 * adsize)); cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2 * adsize));
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(inode->i_sb)->s_udfrev >= 0x0201)
udf_update_tag(oepos.bh->b_data, oepos.offset - (2 * adsize)); 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));
@ -1923,7 +1925,7 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
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) || if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
UDF_SB_UDFREV(inode->i_sb) >= 0x0201) UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
udf_update_tag(oepos.bh->b_data, epos.offset - adsize); 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));

15
fs/udf/misc.c
View file

@ -81,14 +81,16 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
return NULL; return NULL;
} }
} else { } else {
struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
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 (sbi->s_udfrev >= 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 = cpu_to_le16(sbi->s_serial_number);
eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum); 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);
@ -192,15 +194,16 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
register uint8_t checksum; register uint8_t checksum;
register int i; register int i;
struct udf_sb_info *sbi = UDF_SB(sb);
/* Read the block */ /* Read the block */
if (block == 0xFFFFFFFF) if (block == 0xFFFFFFFF)
return NULL; return NULL;
bh = udf_tread(sb, block + UDF_SB_SESSION(sb)); bh = udf_tread(sb, block + sbi->s_session);
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 + sbi->s_session, location);
return NULL; return NULL;
} }
@ -210,7 +213,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
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 + sbi->s_session, le32_to_cpu(tag_p->tagLocation), location);
goto error_out; goto error_out;
} }
@ -240,7 +243,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
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), block + sbi->s_session, le16_to_cpu(tag_p->descCRC),
le16_to_cpu(tag_p->descCRCLength)); le16_to_cpu(tag_p->descCRCLength));
error_out: error_out:

24
fs/udf/namei.c
View file

@ -325,7 +325,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
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 = dir->i_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;
@ -342,8 +342,6 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
sector_t offset; sector_t offset;
struct extent_position epos = {}; struct extent_position epos = {};
sb = dir->i_sb;
if (dentry) { if (dentry) {
if (!dentry->d_name.len) { if (!dentry->d_name.len) {
*err = -EINVAL; *err = -EINVAL;
@ -535,7 +533,7 @@ add:
} }
memset(cfi, 0, sizeof(struct fileIdentDesc)); memset(cfi, 0, sizeof(struct fileIdentDesc));
if (UDF_SB_UDFREV(sb) >= 0x0200) if (UDF_SB(sb)->s_udfrev >= 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));
@ -901,6 +899,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
int block; int block;
char name[UDF_NAME_LEN]; char name[UDF_NAME_LEN];
int namelen; int namelen;
struct buffer_head *bh;
lock_kernel(); lock_kernel();
if (!(inode = udf_new_inode(dir, S_IFLNK, &err))) if (!(inode = udf_new_inode(dir, S_IFLNK, &err)))
@ -1014,17 +1013,19 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
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)) { bh = UDF_SB(inode->i_sb)->s_lvid_bh;
if (bh) {
struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
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 *)(lvid->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;
lvhd->uniqueID = cpu_to_le64(uniqueID); lvhd->uniqueID = cpu_to_le64(uniqueID);
mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb)); mark_buffer_dirty(bh);
} }
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) { if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
@ -1053,6 +1054,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
struct udf_fileident_bh fibh; struct udf_fileident_bh fibh;
struct fileIdentDesc cfi, *fi; struct fileIdentDesc cfi, *fi;
int err; int err;
struct buffer_head *bh;
lock_kernel(); lock_kernel();
if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) { if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) {
@ -1066,17 +1068,19 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
} }
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)) { bh = UDF_SB(inode->i_sb)->s_lvid_bh;
if (bh) {
struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
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 *)(lvid->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;
lvhd->uniqueID = cpu_to_le64(uniqueID); lvhd->uniqueID = cpu_to_le64(uniqueID);
mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb)); mark_buffer_dirty(bh);
} }
udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) { if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {

67
fs/udf/partition.c
View file

@ -31,15 +31,18 @@
inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block, inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
uint16_t partition, uint32_t offset) uint16_t partition, uint32_t offset)
{ {
if (partition >= UDF_SB_NUMPARTS(sb)) { struct udf_sb_info *sbi = UDF_SB(sb);
struct udf_part_map *map;
if (partition >= sbi->s_partitions) {
udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n", udf_debug("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)) map = &sbi->s_partmaps[partition];
return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset); if (map->s_partition_func)
return map->s_partition_func(sb, block, partition, offset);
else else
return UDF_SB_PARTROOT(sb, partition) + block + offset; return map->s_partition_root + block + offset;
} }
uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
@ -49,12 +52,15 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
uint32_t newblock; uint32_t newblock;
uint32_t index; uint32_t index;
uint32_t loc; uint32_t loc;
struct udf_sb_info *sbi = UDF_SB(sb);
struct udf_part_map *map;
index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t); map = &sbi->s_partmaps[partition];
index = (sb->s_blocksize - map->s_type_specific.s_virtual.s_start_offset) / sizeof(uint32_t);
if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) { if (block > map->s_type_specific.s_virtual.s_num_entries) {
udf_debug("Trying to access block beyond end of VAT (%d max %d)\n", udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries); block, map->s_type_specific.s_virtual.s_num_entries);
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
@ -64,10 +70,10 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
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 = map->s_type_specific.s_virtual.s_start_offset / sizeof(uint32_t) + block;
} }
loc = udf_block_map(UDF_SB_VAT(sb), newblock); loc = udf_block_map(sbi->s_vat_inode, 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",
@ -79,13 +85,13 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
brelse(bh); brelse(bh);
if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition) { if (UDF_I_LOCATION(sbi->s_vat_inode).partitionReferenceNum == partition) {
udf_debug("recursive call to udf_get_pblock!\n"); udf_debug("recursive call to udf_get_pblock!\n");
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
return udf_get_pblock(sb, loc, return udf_get_pblock(sb, loc,
UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum, UDF_I_LOCATION(sbi->s_vat_inode).partitionReferenceNum,
offset); offset);
} }
@ -95,16 +101,21 @@ inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
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, uint32_t udf_get_pblock_spar15(struct super_block *sb, uint32_t block,
uint16_t partition, uint32_t offset) 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); struct udf_sb_info *sbi = UDF_SB(sb);
struct udf_part_map *map;
uint32_t packet;
map = &sbi->s_partmaps[partition];
packet = (block + offset) & ~(map->s_type_specific.s_sparing.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 (map->s_type_specific.s_sparing.s_spar_map[i] != NULL) {
st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data; st = (struct sparingTable *)map->s_type_specific.s_sparing.s_spar_map[i]->b_data;
break; break;
} }
} }
@ -115,14 +126,14 @@ uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
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].mappedLocation) +
((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1)); ((block + offset) & (map->s_type_specific.s_sparing.s_packet_len - 1));
} else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) { } else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
break; break;
} }
} }
} }
return UDF_SB_PARTROOT(sb,partition) + block + offset; return map->s_partition_root + 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)
@ -132,15 +143,17 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
struct sparingEntry mapEntry; struct sparingEntry mapEntry;
uint32_t packet; uint32_t packet;
int i, j, k, l; int i, j, k, l;
struct udf_sb_info *sbi = UDF_SB(sb);
for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) { for (i = 0; i < sbi->s_partitions; i++) {
if (old_block > UDF_SB_PARTROOT(sb,i) && struct udf_part_map *map = &sbi->s_partmaps[i];
old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) { if (old_block > map->s_partition_root &&
sdata = &UDF_SB_TYPESPAR(sb,i); old_block < map->s_partition_root + map->s_partition_len) {
packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1); sdata = &map->s_type_specific.s_sparing;
packet = (old_block - map->s_partition_root) & ~(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] != NULL) { if (map->s_type_specific.s_sparing.s_spar_map[j] != NULL) {
st = (struct sparingTable *)sdata->s_spar_map[j]->b_data; st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
break; break;
} }
@ -160,11 +173,11 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
} }
} }
*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) + *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1)); ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
return 0; return 0;
} else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) { } else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) + *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1)); ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
return 0; return 0;
} else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) { } else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
break; break;
@ -185,7 +198,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
} }
} }
*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) + *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1)); ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
return 0; return 0;
} }
} }
@ -194,7 +207,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
} /* if old_block */ } /* if old_block */
} }
if (i == UDF_SB_NUMPARTS(sb)) { if (i == sbi->s_partitions) {
/* outside of partitions */ /* outside of partitions */
/* for now, fail =) */ /* for now, fail =) */
return 1; return 1;

542
fs/udf/super.c
View file

File diff suppressed because it is too large Load diff

7
fs/udf/truncate.c
View file

@ -163,7 +163,7 @@ void udf_discard_prealloc(struct inode *inode)
cpu_to_le32(epos.offset - cpu_to_le32(epos.offset -
sizeof(struct allocExtDesc)); sizeof(struct allocExtDesc));
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(inode->i_sb)->s_udfrev >= 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, udf_update_tag(epos.bh->b_data,
@ -184,6 +184,7 @@ void udf_truncate_extents(struct inode *inode)
uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc; uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc;
int8_t etype; int8_t etype;
struct super_block *sb = inode->i_sb; struct super_block *sb = inode->i_sb;
struct udf_sb_info *sbi = UDF_SB(sb);
sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset; sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;
loff_t byte_offset; loff_t byte_offset;
int adsize; int adsize;
@ -232,7 +233,7 @@ void udf_truncate_extents(struct inode *inode)
aed->lengthAllocDescs = aed->lengthAllocDescs =
cpu_to_le32(lenalloc); cpu_to_le32(lenalloc);
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) || if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
UDF_SB_UDFREV(sb) >= 0x0201) sbi->s_udfrev >= 0x0201)
udf_update_tag(epos.bh->b_data, udf_update_tag(epos.bh->b_data,
lenalloc + lenalloc +
sizeof(struct allocExtDesc)); sizeof(struct allocExtDesc));
@ -271,7 +272,7 @@ void udf_truncate_extents(struct inode *inode)
(struct allocExtDesc *)(epos.bh->b_data); (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) || if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
UDF_SB_UDFREV(sb) >= 0x0201) sbi->s_udfrev >= 0x0201)
udf_update_tag(epos.bh->b_data, udf_update_tag(epos.bh->b_data,
lenalloc + sizeof(struct allocExtDesc)); lenalloc + sizeof(struct allocExtDesc));
else else

75
fs/udf/udf_sb.h
View file

@ -41,40 +41,36 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
return sb->s_fs_info; return sb->s_fs_info;
} }
#define UDF_SB_FREE(X)\ struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi);
{\
if (UDF_SB(X)) {\
kfree(UDF_SB_PARTMAPS(X));\
UDF_SB_PARTMAPS(X) = NULL;\
}\
}
#define UDF_SB_ALLOC_PARTMAPS(X,Y)\ #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
{\ {\
UDF_SB_PARTMAPS(X) = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\ struct udf_sb_info *sbi = UDF_SB(X);\
if (UDF_SB_PARTMAPS(X) != NULL) {\ sbi->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
UDF_SB_NUMPARTS(X) = Y;\ if (sbi->s_partmaps != NULL) {\
memset(UDF_SB_PARTMAPS(X), 0x00, sizeof(struct udf_part_map) * Y);\ sbi->s_partitions = Y;\
memset(sbi->s_partmaps, 0x00, sizeof(struct udf_part_map) * Y);\
} else {\ } else {\
UDF_SB_NUMPARTS(X) = 0;\ sbi->s_partitions = 0;\
udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\ udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\
}\ }\
} }
#define UDF_SB_ALLOC_BITMAP(X,Y,Z)\ #define UDF_SB_ALLOC_BITMAP(X,Y,Z)\
{\ {\
int nr_groups = ((UDF_SB_PARTLEN((X),(Y)) + (sizeof(struct spaceBitmapDesc) << 3) +\ struct udf_sb_info *sbi = UDF_SB(X);\
int nr_groups = ((sbi->s_partmaps[(Y)].s_partition_len + (sizeof(struct spaceBitmapDesc) << 3) +\
((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\ ((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\
int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\ int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
if (size <= PAGE_SIZE)\ if (size <= PAGE_SIZE)\
UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\ sbi->s_partmaps[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
else\ else\
UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = vmalloc(size);\ sbi->s_partmaps[(Y)].Z.s_bitmap = vmalloc(size);\
if (UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap != NULL) {\ if (sbi->s_partmaps[(Y)].Z.s_bitmap != NULL) {\
memset(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap, 0x00, size);\ memset(sbi->s_partmaps[(Y)].Z.s_bitmap, 0x00, size);\
UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap =\ sbi->s_partmaps[(Y)].Z.s_bitmap->s_block_bitmap =\
(struct buffer_head **)(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap + 1);\ (struct buffer_head **)(sbi->s_partmaps[(Y)].Z.s_bitmap + 1);\
UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\ sbi->s_partmaps[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
} else {\ } else {\
udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\ udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\
}\ }\
@ -90,47 +86,16 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
brelse(UDF_SB_BITMAP(X,Y,Z,i));\ brelse(UDF_SB_BITMAP(X,Y,Z,i));\
}\ }\
if (size <= PAGE_SIZE)\ if (size <= PAGE_SIZE)\
kfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\ kfree(UDF_SB(X)->s_partmaps[Y].Z.s_bitmap);\
else\ else\
vfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\ vfree(UDF_SB(X)->s_partmaps[Y].Z.s_bitmap);\
} }
#define UDF_QUERY_FLAG(X,Y) ( UDF_SB(X)->s_flags & ( 1 << (Y) ) ) #define UDF_QUERY_FLAG(X,Y) ( UDF_SB(X)->s_flags & ( 1 << (Y) ) )
#define UDF_SET_FLAG(X,Y) ( UDF_SB(X)->s_flags |= ( 1 << (Y) ) ) #define UDF_SET_FLAG(X,Y) ( UDF_SB(X)->s_flags |= ( 1 << (Y) ) )
#define UDF_CLEAR_FLAG(X,Y) ( UDF_SB(X)->s_flags &= ~( 1 << (Y) ) ) #define UDF_CLEAR_FLAG(X,Y) ( UDF_SB(X)->s_flags &= ~( 1 << (Y) ) )
#define UDF_UPDATE_UDFREV(X,Y) ( ((Y) > UDF_SB_UDFREV(X)) ? UDF_SB_UDFREV(X) = (Y) : UDF_SB_UDFREV(X) ) #define UDF_SB_BITMAP(X,Y,Z,I) ( UDF_SB(X)->s_partmaps[(Y)].Z.s_bitmap->s_block_bitmap[I] )
#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( UDF_SB(X)->s_partmaps[(Y)].Z.s_bitmap->s_nr_groups )
#define UDF_SB_PARTMAPS(X) ( UDF_SB(X)->s_partmaps )
#define UDF_SB_PARTTYPE(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_type )
#define UDF_SB_PARTROOT(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_root )
#define UDF_SB_PARTLEN(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_len )
#define UDF_SB_PARTVSN(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_volumeseqnum )
#define UDF_SB_PARTNUM(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_num )
#define UDF_SB_TYPESPAR(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_type_specific.s_sparing )
#define UDF_SB_TYPEVIRT(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_type_specific.s_virtual )
#define UDF_SB_PARTFUNC(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_func )
#define UDF_SB_PARTFLAGS(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_flags )
#define UDF_SB_BITMAP(X,Y,Z,I) ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups )
#define UDF_SB_VOLIDENT(X) ( UDF_SB(X)->s_volident )
#define UDF_SB_NUMPARTS(X) ( UDF_SB(X)->s_partitions )
#define UDF_SB_PARTITION(X) ( UDF_SB(X)->s_partition )
#define UDF_SB_SESSION(X) ( UDF_SB(X)->s_session )
#define UDF_SB_ANCHOR(X) ( UDF_SB(X)->s_anchor )
#define UDF_SB_LASTBLOCK(X) ( UDF_SB(X)->s_lastblock )
#define UDF_SB_LVIDBH(X) ( UDF_SB(X)->s_lvidbh )
#define UDF_SB_LVID(X) ( (struct logicalVolIntegrityDesc *)UDF_SB_LVIDBH(X)->b_data )
#define UDF_SB_LVIDIU(X) ( (struct logicalVolIntegrityDescImpUse *)&(UDF_SB_LVID(X)->impUse[le32_to_cpu(UDF_SB_LVID(X)->numOfPartitions) * 2 * sizeof(uint32_t)/sizeof(uint8_t)]) )
#define UDF_SB_UMASK(X) ( UDF_SB(X)->s_umask )
#define UDF_SB_GID(X) ( UDF_SB(X)->s_gid )
#define UDF_SB_UID(X) ( UDF_SB(X)->s_uid )
#define UDF_SB_RECORDTIME(X) ( UDF_SB(X)->s_recordtime )
#define UDF_SB_SERIALNUM(X) ( UDF_SB(X)->s_serialnum )
#define UDF_SB_UDFREV(X) ( UDF_SB(X)->s_udfrev )
#define UDF_SB_FLAGS(X) ( UDF_SB(X)->s_flags )
#define UDF_SB_VAT(X) ( UDF_SB(X)->s_vat )
#endif /* __LINUX_UDF_SB_H */ #endif /* __LINUX_UDF_SB_H */

12
include/linux/udf_fs_sb.h
View file

@ -75,7 +75,7 @@ struct udf_part_map
struct udf_sb_info struct udf_sb_info
{ {
struct udf_part_map *s_partmaps; struct udf_part_map *s_partmaps;
__u8 s_volident[32]; __u8 s_volume_ident[32];
/* Overall info */ /* Overall info */
__u16 s_partitions; __u16 s_partitions;
@ -84,9 +84,9 @@ struct udf_sb_info
/* Sector headers */ /* Sector headers */
__s32 s_session; __s32 s_session;
__u32 s_anchor[4]; __u32 s_anchor[4];
__u32 s_lastblock; __u32 s_last_block;
struct buffer_head *s_lvidbh; struct buffer_head *s_lvid_bh;
/* Default permissions */ /* Default permissions */
mode_t s_umask; mode_t s_umask;
@ -94,10 +94,10 @@ struct udf_sb_info
uid_t s_uid; uid_t s_uid;
/* Root Info */ /* Root Info */
struct timespec s_recordtime; struct timespec s_record_time;
/* Fileset Info */ /* Fileset Info */
__u16 s_serialnum; __u16 s_serial_number;
/* highest UDF revision we have recorded to this media */ /* highest UDF revision we have recorded to this media */
__u16 s_udfrev; __u16 s_udfrev;
@ -109,7 +109,7 @@ struct udf_sb_info
struct nls_table *s_nls_map; struct nls_table *s_nls_map;
/* VAT inode */ /* VAT inode */
struct inode *s_vat; struct inode *s_vat_inode;
struct mutex s_alloc_mutex; struct mutex s_alloc_mutex;
}; };