Commit 6c79e987 authored by Marcin Slusarz's avatar Marcin Slusarz Committed by Linus Torvalds
Browse files

udf: remove some ugly macros 



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: default avatarMarcin Slusarz <marcin.slusarz@gmail.com>
Cc: Ben Fennema <bfennema@falcon.csc.calpoly.edu>
Cc: Jan Kara <jack@suse.cz>
Acked-by: default avatarChristoph Hellwig <hch@infradead.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 3a71fc5d

fs/udf/balloc.c

+74 −62
Original line number Diff line number Diff line
@@ -88,7 +88,7 @@ static int read_block_bitmap(struct super_block *sb, 
	kernel_lb_addr loc;



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

	if (!bh) {
@@ -155,10 +155,10 @@ static void udf_bitmap_free_blocks(struct super_block *sb, 


	mutex_lock(&sbi->s_alloc_mutex);

	if (bloc.logicalBlockNum < 0 ||

	    (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {

	    (bloc.logicalBlockNum + count) > sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {

		udf_debug("%d < %d || %d + %d > %d\n",

			  bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,

			  UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));

			  sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len);

		goto error_return;

	}
@@ -188,9 +188,10 @@ do_more: 
		} else {

			if (inode)

				DQUOT_FREE_BLOCK(inode, 1);

			if (UDF_SB_LVIDBH(sb)) {

				UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =

					cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + 1);

			if (sbi->s_lvid_bh) {

				struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;

				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:

	sb->s_dirt = 1;

	if (UDF_SB_LVIDBH(sb))

		mark_buffer_dirty(UDF_SB_LVIDBH(sb));

	if (sbi->s_lvid_bh)

		mark_buffer_dirty(sbi->s_lvid_bh);

	mutex_unlock(&sbi->s_alloc_mutex);

	return;

}
@@ -219,16 +220,18 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb, 
	int bit, block, block_group, group_start;

	int nr_groups, bitmap_nr;

	struct buffer_head *bh;

	__u32 part_len;



	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;



	if (first_block + block_count > UDF_SB_PARTLEN(sb, partition))

		block_count = UDF_SB_PARTLEN(sb, partition) - first_block;

	if (first_block + block_count > part_len)

		block_count = part_len - first_block;



repeat:

	nr_groups = (UDF_SB_PARTLEN(sb, partition) +

	nr_groups = (sbi->s_partmaps[partition].s_partition_len +

		     (sizeof(struct spaceBitmapDesc) << 3) +

		     (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);

	block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
@@ -261,10 +264,11 @@ repeat: 
	if (block_count > 0)

		goto repeat;

out:

	if (UDF_SB_LVIDBH(sb)) {

		UDF_SB_LVID(sb)->freeSpaceTable[partition] =

			cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);

		mark_buffer_dirty(UDF_SB_LVIDBH(sb));

	if (sbi->s_lvid_bh) {

		struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;

		lvid->freeSpaceTable[partition] =

			cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - alloc_count);

		mark_buffer_dirty(sbi->s_lvid_bh);

	}

	sb->s_dirt = 1;

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



repeat:

	if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))

	if (goal < 0 || goal >= sbi->s_partmaps[partition].s_partition_len)

		goal = 0;



	nr_groups = bitmap->s_nr_groups;
@@ -389,10 +393,11 @@ got_block: 


	mark_buffer_dirty(bh);



	if (UDF_SB_LVIDBH(sb)) {

		UDF_SB_LVID(sb)->freeSpaceTable[partition] =

			cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);

		mark_buffer_dirty(UDF_SB_LVIDBH(sb));

	if (sbi->s_lvid_bh) {

		struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;

		lvid->freeSpaceTable[partition] =

			cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - 1);

		mark_buffer_dirty(sbi->s_lvid_bh);

	}

	sb->s_dirt = 1;

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

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

			  bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,

			  UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));

			  sbi->s_partmaps[bloc.partitionReferenceNum]->s_partition_len);

		goto error_return;

	}
@@ -432,10 +437,11 @@ static void udf_table_free_blocks(struct super_block *sb, 
	   but.. oh well */

	if (inode)

		DQUOT_FREE_BLOCK(inode, count);

	if (UDF_SB_LVIDBH(sb)) {

		UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =

			cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + count);

		mark_buffer_dirty(UDF_SB_LVIDBH(sb));

	if (sbi->s_lvid_bh) {

		struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;

		lvid->freeSpaceTable[sbi->s_partition] =

			cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[sbi->s_partition]) + count);

		mark_buffer_dirty(sbi->s_lvid_bh);

	}



	start = bloc.logicalBlockNum + offset;
@@ -559,7 +565,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
				}

				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,

					    epos.block.logicalBlockNum, sizeof(tag));

			else
@@ -627,7 +633,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb, 
	struct extent_position epos;

	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;



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



	if (alloc_count && UDF_SB_LVIDBH(sb)) {

		UDF_SB_LVID(sb)->freeSpaceTable[partition] =

			cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);

		mark_buffer_dirty(UDF_SB_LVIDBH(sb));

	if (alloc_count && sbi->s_lvid_bh) {

		struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;

		lvid->freeSpaceTable[partition] =

			cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - alloc_count);

		mark_buffer_dirty(sbi->s_lvid_bh);

		sb->s_dirt = 1;

	}

	mutex_unlock(&sbi->s_alloc_mutex);
@@ -703,7 +710,7 @@ static int udf_table_new_block(struct super_block *sb, 
		return newblock;



	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;



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

	brelse(goal_epos.bh);



	if (UDF_SB_LVIDBH(sb)) {

		UDF_SB_LVID(sb)->freeSpaceTable[partition] =

			cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);

		mark_buffer_dirty(UDF_SB_LVIDBH(sb));

	if (sbi->s_lvid_bh) {

		struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;

		lvid->freeSpaceTable[partition] =

			cpu_to_le32(le32_to_cpu(lvid->freeSpaceTable[partition]) - 1);

		mark_buffer_dirty(sbi->s_lvid_bh);

	}



	sb->s_dirt = 1;
@@ -789,22 +797,23 @@ inline void udf_free_blocks(struct super_block *sb, 
			    uint32_t count)

{

	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,

					      UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,

					      map->s_uspace.s_bitmap,

					      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,

					     UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,

					     map->s_uspace.s_table,

					     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,

					      UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,

					      map->s_fspace.s_bitmap,

					      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,

					     UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,

					     map->s_fspace.s_table,

					     bloc, offset, count);

	} else {

		return;
@@ -816,21 +825,23 @@ inline int udf_prealloc_blocks(struct super_block *sb, 
			       uint16_t partition, uint32_t first_block,

			       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,

						  UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,

						  map->s_uspace.s_bitmap,

						  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,

						 UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,

						 map->s_uspace.s_table,

						 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,

						  UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,

						  map->s_fspace.s_bitmap,

						  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,

						 UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,

						 map->s_fspace.s_table,

						 partition, first_block, block_count);

	} else {

		return 0;
@@ -842,23 +853,24 @@ inline int udf_new_block(struct super_block *sb, 
			 uint16_t partition, uint32_t goal, int *err)

{

	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,

					   UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,

					   map->s_uspace.s_bitmap,

					   partition, goal, err);

		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,

					   UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,

					   map->s_uspace.s_table,

					   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,

					    UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,

					    map->s_fspace.s_bitmap,

					    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,

					   UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,

					   map->s_fspace.s_table,

					   partition, goal, err);

	} else {

		*err = -EIO;

fs/udf/file.c

+1 −1
Original line number Diff line number Diff line
@@ -192,7 +192,7 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, 
	switch (cmd) {

	case UDF_GETVOLIDENT:

		return copy_to_user((char __user *)arg,

				    UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;

				    UDF_SB(inode->i_sb)->s_volume_ident, 32) ? -EFAULT : 0;

	case UDF_RELOCATE_BLOCKS:

		if (!capable(CAP_SYS_ADMIN))

			return -EACCES;

fs/udf/ialloc.c

+19 −14
Original line number Diff line number Diff line
@@ -43,15 +43,17 @@ void udf_free_inode(struct inode *inode) 
	clear_inode(inode);



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

			UDF_SB_LVIDIU(sb)->numDirs =

				cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) - 1);

			lvidiu->numDirs =

				cpu_to_le32(le32_to_cpu(lvidiu->numDirs) - 1);

		else

			UDF_SB_LVIDIU(sb)->numFiles =

				cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) - 1);

			lvidiu->numFiles =

				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);
@@ -88,21 +90,23 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
	}



	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;

		uint64_t uniqueID;

		lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->logicalVolContentsUse);

		lvhd = (struct logicalVolHeaderDesc *)(lvid->logicalVolContentsUse);

		if (S_ISDIR(mode))

			UDF_SB_LVIDIU(sb)->numDirs =

				cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) + 1);

			lvidiu->numDirs =

				cpu_to_le32(le32_to_cpu(lvidiu->numDirs) + 1);

		else

			UDF_SB_LVIDIU(sb)->numFiles =

				cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) + 1);

			lvidiu->numFiles =

				cpu_to_le32(le32_to_cpu(lvidiu->numFiles) + 1);

		UDF_I_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);

		if (!(++uniqueID & 0x00000000FFFFFFFFUL))

			uniqueID += 16;

		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_uid = current->fsuid;
@@ -123,7 +127,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
	UDF_I_USE(inode) = 0;

	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {

		UDF_I_EFE(inode) = 1;

		UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);

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

	} else {

		UDF_I_EFE(inode) = 0;

fs/udf/inode.c

+18 −16
Original line number Diff line number Diff line
@@ -1081,6 +1081,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) 
	time_t convtime;

	long convtime_usec;

	int offset;

	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);



	fe = (struct fileEntry *)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_nsec = convtime_usec * 1000;

		} 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,
@@ -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_nsec = convtime_usec * 1000;

		} 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,
@@ -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_nsec = convtime_usec * 1000;

		} 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);
@@ -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_nsec = convtime_usec * 1000;

		} 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,
@@ -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_nsec = convtime_usec * 1000;

		} 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,
@@ -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_nsec = convtime_usec * 1000;

		} 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,
@@ -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_nsec = convtime_usec * 1000;

		} 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);
@@ -1353,6 +1354,7 @@ static int udf_update_inode(struct inode *inode, int do_sync) 
	int i;

	kernel_timestamp cpu_time;

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

	if (!bh) {
@@ -1537,11 +1539,11 @@ static int udf_update_inode(struct inode *inode, int do_sync) 
				ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));



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

	else

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

	crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);

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

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

			  ino.logicalBlockNum, ino.partitionReferenceNum);

		make_bad_inode(inode);
@@ -1667,7 +1669,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos, 
				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,

				    epos->block.logicalBlockNum, sizeof(tag));

		else
@@ -1690,7 +1692,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos, 
		}

		if (epos->bh) {

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

			else

				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->lengthAllocDescs =

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

		else

			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 (!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;

			udf_update_tag(epos->bh->b_data,

				       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 =

				cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2 * adsize));

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

			else

				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 =

				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)

			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)

				udf_update_tag(oepos.bh->b_data, epos.offset - adsize);

			else

				udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));

fs/udf/misc.c

+9 −6
Original line number Diff line number Diff line
@@ -81,14 +81,16 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size, 
				return NULL;

			}

		} else {

			struct udf_sb_info *sbi = UDF_SB(inode->i_sb);



			size -= sizeof(struct extendedAttrHeaderDesc);

			UDF_I_LENEATTR(inode) += sizeof(struct extendedAttrHeaderDesc);

			eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);

			if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)

			if (sbi->s_udfrev >= 0x0200)

				eahd->descTag.descVersion = cpu_to_le16(3);

			else

				eahd->descTag.descVersion = cpu_to_le16(2);

			eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));

			eahd->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);

			eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);

			eahd->impAttrLocation = 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;

	register uint8_t checksum;

	register int i;

	struct udf_sb_info *sbi = UDF_SB(sb);



	/* Read the block */

	if (block == 0xFFFFFFFF)

		return NULL;



	bh = udf_tread(sb, block + UDF_SB_SESSION(sb));

	bh = udf_tread(sb, block + sbi->s_session);

	if (!bh) {

		udf_debug("block=%d, location=%d: read failed\n",

			  block + UDF_SB_SESSION(sb), location);

			  block + sbi->s_session, location);

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

		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;

	}
@@ -240,7 +243,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block, 
		return bh;

	}

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



error_out:

CRA Git | Maintained and supported by SUSTech CRA and CCSE