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

udf: remove UDF_I_* macros and open code them 



Signed-off-by: default avatarMarcin Slusarz <marcin.slusarz@gmail.com>
Acked-by: default avatarJan Kara <jack@suse.cz>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 5e0f0017

fs/udf/balloc.c

+16 −14
Original line number Diff line number Diff line
@@ -460,7 +460,7 @@ static void udf_table_free_blocks(struct super_block *sb, 


	epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);

	elen = 0;

	epos.block = oepos.block = UDF_I_LOCATION(table);

	epos.block = oepos.block = UDF_I(table)->i_location;

	epos.bh = oepos.bh = NULL;



	while (count &&
@@ -539,9 +539,9 @@ static void udf_table_free_blocks(struct super_block *sb, 
		elen = EXT_RECORDED_ALLOCATED |

			(count << sb->s_blocksize_bits);



		if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT) {

		if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT) {

			adsize = sizeof(short_ad);

		} else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG) {

		} else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG) {

			adsize = sizeof(long_ad);

		} else {

			brelse(oepos.bh);
@@ -573,7 +573,8 @@ static void udf_table_free_blocks(struct super_block *sb, 
			if (epos.offset + adsize > sb->s_blocksize) {

				loffset = epos.offset;

				aed->lengthAllocDescs = cpu_to_le32(adsize);

				sptr = UDF_I_DATA(table) + epos.offset - adsize;

				sptr = UDF_I(table)->i_ext.i_data + epos.offset

								- adsize;

				dptr = epos.bh->b_data +

					sizeof(struct allocExtDesc);

				memcpy(dptr, sptr, adsize);
@@ -591,8 +592,9 @@ static void udf_table_free_blocks(struct super_block *sb, 
							aed->lengthAllocDescs) +

								adsize);

				} else {

					sptr = UDF_I_DATA(table) + epos.offset;

					UDF_I_LENALLOC(table) += adsize;

					sptr = UDF_I(table)->i_ext.i_data +

								epos.offset;

					UDF_I(table)->i_lenAlloc += adsize;

					mark_inode_dirty(table);

				}

				epos.offset = sizeof(struct allocExtDesc);
@@ -606,7 +608,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
					    2, 1, epos.block.logicalBlockNum,

					    sizeof(tag));



			switch (UDF_I_ALLOCTYPE(table)) {

			switch (UDF_I(table)->i_alloc_type) {

			case ICBTAG_FLAG_AD_SHORT:

				sad = (short_ad *)sptr;

				sad->extLength = cpu_to_le32(
@@ -637,7 +639,7 @@ static void udf_table_free_blocks(struct super_block *sb, 
			udf_write_aext(table, &epos, eloc, elen, 1);



			if (!epos.bh) {

				UDF_I_LENALLOC(table) += adsize;

				UDF_I(table)->i_lenAlloc += adsize;

				mark_inode_dirty(table);

			} else {

				aed = (struct allocExtDesc *)epos.bh->b_data;
@@ -675,16 +677,16 @@ static int udf_table_prealloc_blocks(struct super_block *sb, 
		first_block >= sbi->s_partmaps[partition].s_partition_len)

		return 0;



	if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)

	if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

		adsize = sizeof(short_ad);

	else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)

	else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG)

		adsize = sizeof(long_ad);

	else

		return 0;



	mutex_lock(&sbi->s_alloc_mutex);

	epos.offset = sizeof(struct unallocSpaceEntry);

	epos.block = UDF_I_LOCATION(table);

	epos.block = UDF_I(table)->i_location;

	epos.bh = NULL;

	eloc.logicalBlockNum = 0xFFFFFFFF;
@@ -740,9 +742,9 @@ static int udf_table_new_block(struct super_block *sb, 


	*err = -ENOSPC;



	if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)

	if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

		adsize = sizeof(short_ad);

	else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)

	else if (UDF_I(table)->i_alloc_type == ICBTAG_FLAG_AD_LONG)

		adsize = sizeof(long_ad);

	else

		return newblock;
@@ -757,7 +759,7 @@ static int udf_table_new_block(struct super_block *sb, 
	   of the current closest match and use that when we are done.

	 */

	epos.offset = sizeof(struct unallocSpaceEntry);

	epos.block = UDF_I_LOCATION(table);

	epos.block = UDF_I(table)->i_location;

	epos.bh = goal_epos.bh = NULL;



	while (spread &&

fs/udf/dir.c

+4 −3
Original line number Diff line number Diff line
@@ -125,15 +125,16 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir, 
		nf_pos = (udf_ext0_offset(dir) >> 2);



	fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;

	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {

	if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

		fibh.sbh = fibh.ebh = NULL;

	} else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),

			      &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {

		block = udf_get_lb_pblock(dir->i_sb, eloc, offset);

		if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {

			if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)

			if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)

				epos.offset -= sizeof(short_ad);

			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)

			else if (UDF_I(dir)->i_alloc_type ==

					ICBTAG_FLAG_AD_LONG)

				epos.offset -= sizeof(long_ad);

		} else {

			offset = 0;

fs/udf/directory.c

+3 −3
Original line number Diff line number Diff line
@@ -84,9 +84,9 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos, 


	fibh->soffset = fibh->eoffset;



	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {

		fi = udf_get_fileident(UDF_I_DATA(dir) -

				       (UDF_I_EFE(dir) ?

	if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

		fi = udf_get_fileident(UDF_I(dir)->i_ext.i_data -

				       (UDF_I(dir)->i_efe ?

					sizeof(struct extendedFileEntry) :

					sizeof(struct fileEntry)),

				       dir->i_sb->s_blocksize,

fs/udf/file.c

+14 −10
Original line number Diff line number Diff line
@@ -50,7 +50,8 @@ static int udf_adinicb_readpage(struct file *file, struct page *page) 


	kaddr = kmap(page);

	memset(kaddr, 0, PAGE_CACHE_SIZE);

	memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), inode->i_size);

	memcpy(kaddr, UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr,

								inode->i_size);

	flush_dcache_page(page);

	SetPageUptodate(page);

	kunmap(page);
@@ -68,7 +69,8 @@ static int udf_adinicb_writepage(struct page *page, 
	BUG_ON(!PageLocked(page));



	kaddr = kmap(page);

	memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), kaddr, inode->i_size);

	memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr, kaddr,

								inode->i_size);

	mark_inode_dirty(inode);

	SetPageUptodate(page);

	kunmap(page);
@@ -87,7 +89,7 @@ static int udf_adinicb_write_end(struct file *file, 
	char *kaddr;



	kaddr = kmap_atomic(page, KM_USER0);

	memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset,

	memcpy(UDF_I(inode)->i_ext.i_data + UDF_I(inode)->i_lenEAttr + offset,

		kaddr + offset, copied);

	kunmap_atomic(kaddr, KM_USER0);
@@ -111,7 +113,7 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov, 
	int err, pos;

	size_t count = iocb->ki_left;



	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {

	if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

		if (file->f_flags & O_APPEND)

			pos = inode->i_size;

		else
@@ -121,15 +123,16 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov, 
				(udf_file_entry_alloc_offset(inode) +

						pos + count)) {

			udf_expand_file_adinicb(inode, pos + count, &err);

			if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {

			if (UDF_I(inode)->i_alloc_type ==

							ICBTAG_FLAG_AD_IN_ICB) {

				udf_debug("udf_expand_adinicb: err=%d\n", err);

				return err;

			}

		} else {

			if (pos + count > inode->i_size)

				UDF_I_LENALLOC(inode) = pos + count;

				UDF_I(inode)->i_lenAlloc = pos + count;

			else

				UDF_I_LENALLOC(inode) = inode->i_size;

				UDF_I(inode)->i_lenAlloc = inode->i_size;

		}

	}
@@ -209,11 +212,12 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, 
			result = put_user(new_block, (long __user *)arg);

		return result;

	case UDF_GETEASIZE:

		result = put_user(UDF_I_LENEATTR(inode), (int __user *)arg);

		result = put_user(UDF_I(inode)->i_lenEAttr, (int __user *)arg);

		break;

	case UDF_GETEABLOCK:

		result = copy_to_user((char __user *)arg, UDF_I_DATA(inode),

				      UDF_I_LENEATTR(inode)) ? -EFAULT : 0;

		result = copy_to_user((char __user *)arg,

				      UDF_I(inode)->i_ext.i_data,

				      UDF_I(inode)->i_lenEAttr) ? -EFAULT : 0;

		break;

	}

fs/udf/ialloc.c

+25 −25
Original line number Diff line number Diff line
@@ -57,7 +57,7 @@ void udf_free_inode(struct inode *inode) 
	}

	mutex_unlock(&sbi->s_alloc_mutex);



	udf_free_blocks(sb, NULL, UDF_I_LOCATION(inode), 0, 1);

	udf_free_blocks(sb, NULL, UDF_I(inode)->i_location, 0, 1);

}



struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
@@ -66,7 +66,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
	struct udf_sb_info *sbi = UDF_SB(sb);

	struct inode *inode;

	int block;

	uint32_t start = UDF_I_LOCATION(dir).logicalBlockNum;

	uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;



	inode = new_inode(sb);
@@ -76,14 +76,14 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
	}

	*err = -ENOSPC;



	UDF_I_UNIQUE(inode) = 0;

	UDF_I_LENEXTENTS(inode) = 0;

	UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;

	UDF_I_NEXT_ALLOC_GOAL(inode) = 0;

	UDF_I_STRAT4096(inode) = 0;

	UDF_I(inode)->i_unique = 0;

	UDF_I(inode)->i_lenExtents = 0;

	UDF_I(inode)->i_next_alloc_block = 0;

	UDF_I(inode)->i_next_alloc_goal = 0;

	UDF_I(inode)->i_strat4096 = 0;



	block = udf_new_block(dir->i_sb, NULL,

			      UDF_I_LOCATION(dir).partitionReferenceNum,

			      UDF_I(dir)->i_location.partitionReferenceNum,

			      start, err);

	if (*err) {

		iput(inode);
@@ -107,7 +107,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
		else

			lvidiu->numFiles =

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

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

		UDF_I(inode)->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID);

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

			uniqueID += 16;

		lvhd->uniqueID = cpu_to_le64(uniqueID);
@@ -123,41 +123,41 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) 
		inode->i_gid = current->fsgid;

	}



	UDF_I_LOCATION(inode).logicalBlockNum = block;

	UDF_I_LOCATION(inode).partitionReferenceNum =

				UDF_I_LOCATION(dir).partitionReferenceNum;

	inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);

	UDF_I(inode)->i_location.logicalBlockNum = block;

	UDF_I(inode)->i_location.partitionReferenceNum =

				UDF_I(dir)->i_location.partitionReferenceNum;

	inode->i_ino = udf_get_lb_pblock(sb, UDF_I(inode)->i_location, 0);

	inode->i_blocks = 0;

	UDF_I_LENEATTR(inode) = 0;

	UDF_I_LENALLOC(inode) = 0;

	UDF_I_USE(inode) = 0;

	UDF_I(inode)->i_lenEAttr = 0;

	UDF_I(inode)->i_lenAlloc = 0;

	UDF_I(inode)->i_use = 0;

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

		UDF_I_EFE(inode) = 1;

		UDF_I(inode)->i_efe = 1;

		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 -

		UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -

					    sizeof(struct extendedFileEntry),

					    GFP_KERNEL);

	} else {

		UDF_I_EFE(inode) = 0;

		UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize -

		UDF_I(inode)->i_efe = 0;

		UDF_I(inode)->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -

					    sizeof(struct fileEntry),

					    GFP_KERNEL);

	}

	if (!UDF_I_DATA(inode)) {

	if (!UDF_I(inode)->i_ext.i_data) {

		iput(inode);

		*err = -ENOMEM;

		mutex_unlock(&sbi->s_alloc_mutex);

		return NULL;

	}

	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))

		UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;

		UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;

	else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))

		UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;

		UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_SHORT;

	else

		UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;

		UDF_I(inode)->i_alloc_type = ICBTAG_FLAG_AD_LONG;

	inode->i_mtime = inode->i_atime = inode->i_ctime =

		UDF_I_CRTIME(inode) = current_fs_time(inode->i_sb);

		UDF_I(inode)->i_crtime = current_fs_time(inode->i_sb);

	insert_inode_hash(inode);

	mark_inode_dirty(inode);

	mutex_unlock(&sbi->s_alloc_mutex);