Commit 6d3d5e86 authored by Jan Kara's avatar Jan Kara
Browse files

udf: Make udf_read_inode() and udf_iget() return error 



Currently __udf_read_inode() wasn't returning anything and we found out
whether we succeeded reading inode by checking whether inode is bad or
not. udf_iget() returned NULL on failure and inode pointer otherwise.
Make these two functions properly propagate errors up the call stack and
use the return value in callers.

Signed-off-by: default avatarJan Kara <jack@suse.cz>
parent c03aa9f6

fs/udf/inode.c

+46 −53
Original line number Diff line number Diff line
@@ -1277,7 +1277,7 @@ update_time: 
 */

#define UDF_MAX_ICB_NESTING 1024



static void __udf_read_inode(struct inode *inode)

static int udf_read_inode(struct inode *inode)

{

	struct buffer_head *bh = NULL;

	struct fileEntry *fe;
@@ -1285,10 +1285,19 @@ static void __udf_read_inode(struct inode *inode) 
	uint16_t ident;

	struct udf_inode_info *iinfo = UDF_I(inode);

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

	struct kernel_lb_addr *iloc = &iinfo->i_location;

	unsigned int link_count;

	unsigned int indirections = 0;

	int ret = -EIO;



reread:

	if (iloc->logicalBlockNum >=

	    sbi->s_partmaps[iloc->partitionReferenceNum].s_partition_len) {

		udf_debug("block=%d, partition=%d out of range\n",

			  iloc->logicalBlockNum, iloc->partitionReferenceNum);

		return -EIO;

	}



	/*

	 * Set defaults, but the inode is still incomplete!

	 * Note: get_new_inode() sets the following on a new inode:
@@ -1301,20 +1310,17 @@ reread: 
	 *      i_nlink = 1

	 *      i_op = NULL;

	 */

	bh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 0, &ident);

	bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident);

	if (!bh) {

		udf_err(inode->i_sb, "(ino %ld) failed !bh\n", inode->i_ino);

		make_bad_inode(inode);

		return;

		return -EIO;

	}



	if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&

	    ident != TAG_IDENT_USE) {

		udf_err(inode->i_sb, "(ino %ld) failed ident=%d\n",

			inode->i_ino, ident);

		brelse(bh);

		make_bad_inode(inode);

		return;

		goto out;

	}



	fe = (struct fileEntry *)bh->b_data;
@@ -1323,8 +1329,7 @@ reread: 
	if (fe->icbTag.strategyType == cpu_to_le16(4096)) {

		struct buffer_head *ibh;



		ibh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 1,

					&ident);

		ibh = udf_read_ptagged(inode->i_sb, iloc, 1, &ident);

		if (ident == TAG_IDENT_IE && ibh) {

			struct kernel_lb_addr loc;

			struct indirectEntry *ie;
@@ -1333,7 +1338,6 @@ reread: 
			loc = lelb_to_cpu(ie->indirectICB.extLocation);



			if (ie->indirectICB.extLength) {

				brelse(bh);

				brelse(ibh);

				memcpy(&iinfo->i_location, &loc,

				       sizeof(struct kernel_lb_addr));
@@ -1342,9 +1346,9 @@ reread: 
						"too many ICBs in ICB hierarchy"

						" (max %d supported)\n",

						UDF_MAX_ICB_NESTING);

					make_bad_inode(inode);

					return;

					goto out;

				}

				brelse(bh);

				goto reread;

			}

		}
@@ -1352,9 +1356,7 @@ reread: 
	} else if (fe->icbTag.strategyType != cpu_to_le16(4)) {

		udf_err(inode->i_sb, "unsupported strategy type: %d\n",

			le16_to_cpu(fe->icbTag.strategyType));

		brelse(bh);

		make_bad_inode(inode);

		return;

		goto out;

	}

	if (fe->icbTag.strategyType == cpu_to_le16(4))

		iinfo->i_strat4096 = 0;
@@ -1372,11 +1374,10 @@ reread: 
	if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {

		iinfo->i_efe = 1;

		iinfo->i_use = 0;

		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -

					sizeof(struct extendedFileEntry))) {

			make_bad_inode(inode);

			return;

		}

		ret = udf_alloc_i_data(inode, inode->i_sb->s_blocksize -

					sizeof(struct extendedFileEntry));

		if (ret)

			goto out;

		memcpy(iinfo->i_ext.i_data,

		       bh->b_data + sizeof(struct extendedFileEntry),

		       inode->i_sb->s_blocksize -
@@ -1384,11 +1385,10 @@ reread: 
	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {

		iinfo->i_efe = 0;

		iinfo->i_use = 0;

		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -

						sizeof(struct fileEntry))) {

			make_bad_inode(inode);

			return;

		}

		ret = udf_alloc_i_data(inode, inode->i_sb->s_blocksize -

						sizeof(struct fileEntry));

		if (ret)

			goto out;

		memcpy(iinfo->i_ext.i_data,

		       bh->b_data + sizeof(struct fileEntry),

		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));
@@ -1398,18 +1398,18 @@ reread: 
		iinfo->i_lenAlloc = le32_to_cpu(

				((struct unallocSpaceEntry *)bh->b_data)->

				 lengthAllocDescs);

		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -

					sizeof(struct unallocSpaceEntry))) {

			make_bad_inode(inode);

			return;

		}

		ret = udf_alloc_i_data(inode, inode->i_sb->s_blocksize -

					sizeof(struct unallocSpaceEntry));

		if (ret)

			goto out;

		memcpy(iinfo->i_ext.i_data,

		       bh->b_data + sizeof(struct unallocSpaceEntry),

		       inode->i_sb->s_blocksize -

					sizeof(struct unallocSpaceEntry));

		return;

		return 0;

	}



	ret = -EIO;

	read_lock(&sbi->s_cred_lock);

	i_uid_write(inode, le32_to_cpu(fe->uid));

	if (!uid_valid(inode->i_uid) ||
@@ -1531,8 +1531,7 @@ reread: 
	default:

		udf_err(inode->i_sb, "(ino %ld) failed unknown file type=%d\n",

			inode->i_ino, fe->icbTag.fileType);

		make_bad_inode(inode);

		return;

		goto out;

	}

	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {

		struct deviceSpec *dsea =
@@ -1543,9 +1542,12 @@ reread: 
				      le32_to_cpu(dsea->minorDeviceIdent)));

			/* Developer ID ??? */

		} else

			make_bad_inode(inode);

			goto out;

	}

	ret = 0;

out:

	brelse(bh);

	return ret;

}



static int udf_alloc_i_data(struct inode *inode, size_t size)
@@ -1825,32 +1827,23 @@ struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr *ino) 
{

	unsigned long block = udf_get_lb_pblock(sb, ino, 0);

	struct inode *inode = iget_locked(sb, block);

	int err;



	if (!inode)

		return NULL;



	if (inode->i_state & I_NEW) {

		memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));

		__udf_read_inode(inode);

		unlock_new_inode(inode);

	}

		return ERR_PTR(-ENOMEM);



	if (is_bad_inode(inode))

		goto out_iput;

	if (!(inode->i_state & I_NEW))

		return inode;



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

		goto out_iput;

	memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));

	err = udf_read_inode(inode);

	if (err < 0) {

		iget_failed(inode);

		return ERR_PTR(err);

	}

	unlock_new_inode(inode);



	return inode;



 out_iput:

	iput(inode);

	return NULL;

}



int udf_add_aext(struct inode *inode, struct extent_position *epos,

fs/udf/namei.c

+9 −13
Original line number Diff line number Diff line
@@ -270,9 +270,8 @@ static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry, 
						NULL, 0),

		};

		inode = udf_iget(dir->i_sb, lb);

		if (!inode) {

			return ERR_PTR(-EACCES);

		}

		if (IS_ERR(inode))

			return inode;

	} else

#endif /* UDF_RECOVERY */
@@ -285,9 +284,8 @@ static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry, 


		loc = lelb_to_cpu(cfi.icb.extLocation);

		inode = udf_iget(dir->i_sb, &loc);

		if (!inode) {

			return ERR_PTR(-EACCES);

		}

		if (IS_ERR(inode))

			return ERR_CAST(inode);

	}



	return d_splice_alias(inode, dentry);
@@ -1222,7 +1220,7 @@ static struct dentry *udf_get_parent(struct dentry *child) 
	struct udf_fileident_bh fibh;



	if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi))

		goto out_unlock;

		return ERR_PTR(-EACCES);



	if (fibh.sbh != fibh.ebh)

		brelse(fibh.ebh);
@@ -1230,12 +1228,10 @@ static struct dentry *udf_get_parent(struct dentry *child) 


	tloc = lelb_to_cpu(cfi.icb.extLocation);

	inode = udf_iget(child->d_inode->i_sb, &tloc);

	if (!inode)

		goto out_unlock;

	if (IS_ERR(inode))

		return ERR_CAST(inode);



	return d_obtain_alias(inode);

out_unlock:

	return ERR_PTR(-EACCES);

}
@@ -1252,8 +1248,8 @@ static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block, 
	loc.partitionReferenceNum = partref;

	inode = udf_iget(sb, &loc);



	if (inode == NULL)

		return ERR_PTR(-ENOMEM);

	if (IS_ERR(inode))

		return ERR_CAST(inode);



	if (generation && inode->i_generation != generation) {

		iput(inode);

fs/udf/super.c

+41 −28
Original line number Diff line number Diff line
@@ -961,12 +961,14 @@ struct inode *udf_find_metadata_inode_efe(struct super_block *sb, 


	metadata_fe = udf_iget(sb, &addr);



	if (metadata_fe == NULL)

	if (IS_ERR(metadata_fe)) {

		udf_warn(sb, "metadata inode efe not found\n");

	else if (UDF_I(metadata_fe)->i_alloc_type != ICBTAG_FLAG_AD_SHORT) {

		return metadata_fe;

	}

	if (UDF_I(metadata_fe)->i_alloc_type != ICBTAG_FLAG_AD_SHORT) {

		udf_warn(sb, "metadata inode efe does not have short allocation descriptors!\n");

		iput(metadata_fe);

		metadata_fe = NULL;

		return ERR_PTR(-EIO);

	}



	return metadata_fe;
@@ -978,6 +980,7 @@ static int udf_load_metadata_files(struct super_block *sb, int partition) 
	struct udf_part_map *map;

	struct udf_meta_data *mdata;

	struct kernel_lb_addr addr;

	struct inode *fe;



	map = &sbi->s_partmaps[partition];

	mdata = &map->s_type_specific.s_metadata;
@@ -986,22 +989,24 @@ static int udf_load_metadata_files(struct super_block *sb, int partition) 
	udf_debug("Metadata file location: block = %d part = %d\n",

		  mdata->s_meta_file_loc, map->s_partition_num);



	mdata->s_metadata_fe = udf_find_metadata_inode_efe(sb,

		mdata->s_meta_file_loc, map->s_partition_num);



	if (mdata->s_metadata_fe == NULL) {

	fe = udf_find_metadata_inode_efe(sb, mdata->s_meta_file_loc,

					 map->s_partition_num);

	if (IS_ERR(fe)) {

		/* mirror file entry */

		udf_debug("Mirror metadata file location: block = %d part = %d\n",

			  mdata->s_mirror_file_loc, map->s_partition_num);



		mdata->s_mirror_fe = udf_find_metadata_inode_efe(sb,

			mdata->s_mirror_file_loc, map->s_partition_num);

		fe = udf_find_metadata_inode_efe(sb, mdata->s_mirror_file_loc,

						 map->s_partition_num);



		if (mdata->s_mirror_fe == NULL) {

		if (IS_ERR(fe)) {

			udf_err(sb, "Both metadata and mirror metadata inode efe can not found\n");

			return -EIO;

		}

			return PTR_ERR(fe);

		}

		mdata->s_mirror_fe = fe;

	} else

		mdata->s_metadata_fe = fe;





	/*

	 * bitmap file entry
@@ -1015,15 +1020,16 @@ static int udf_load_metadata_files(struct super_block *sb, int partition) 
		udf_debug("Bitmap file location: block = %d part = %d\n",

			  addr.logicalBlockNum, addr.partitionReferenceNum);



		mdata->s_bitmap_fe = udf_iget(sb, &addr);

		if (mdata->s_bitmap_fe == NULL) {

		fe = udf_iget(sb, &addr);

		if (IS_ERR(fe)) {

			if (sb->s_flags & MS_RDONLY)

				udf_warn(sb, "bitmap inode efe not found but it's ok since the disc is mounted read-only\n");

			else {

				udf_err(sb, "bitmap inode efe not found and attempted read-write mount\n");

				return -EIO;

			}

				return PTR_ERR(fe);

			}

		} else

			mdata->s_bitmap_fe = fe;

	}



	udf_debug("udf_load_metadata_files Ok\n");
@@ -1111,13 +1117,15 @@ static int udf_fill_partdesc_info(struct super_block *sb, 
				phd->unallocSpaceTable.extPosition),

			.partitionReferenceNum = p_index,

		};

		struct inode *inode;



		map->s_uspace.s_table = udf_iget(sb, &loc);

		if (!map->s_uspace.s_table) {

		inode = udf_iget(sb, &loc);

		if (IS_ERR(inode)) {

			udf_debug("cannot load unallocSpaceTable (part %d)\n",

				  p_index);

			return -EIO;

			return PTR_ERR(inode);

		}

		map->s_uspace.s_table = inode;

		map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;

		udf_debug("unallocSpaceTable (part %d) @ %ld\n",

			  p_index, map->s_uspace.s_table->i_ino);
@@ -1144,14 +1152,15 @@ static int udf_fill_partdesc_info(struct super_block *sb, 
				phd->freedSpaceTable.extPosition),

			.partitionReferenceNum = p_index,

		};

		struct inode *inode;



		map->s_fspace.s_table = udf_iget(sb, &loc);

		if (!map->s_fspace.s_table) {

		inode = udf_iget(sb, &loc);

		if (IS_ERR(inode)) {

			udf_debug("cannot load freedSpaceTable (part %d)\n",

				  p_index);

			return -EIO;

			return PTR_ERR(inode);

		}



		map->s_fspace.s_table = inode;

		map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;

		udf_debug("freedSpaceTable (part %d) @ %ld\n",

			  p_index, map->s_fspace.s_table->i_ino);
@@ -1178,6 +1187,7 @@ static void udf_find_vat_block(struct super_block *sb, int p_index, 
	struct udf_part_map *map = &sbi->s_partmaps[p_index];

	sector_t vat_block;

	struct kernel_lb_addr ino;

	struct inode *inode;



	/*

	 * VAT file entry is in the last recorded block. Some broken disks have
@@ -1186,10 +1196,13 @@ static void udf_find_vat_block(struct super_block *sb, int p_index, 
	ino.partitionReferenceNum = type1_index;

	for (vat_block = start_block;

	     vat_block >= map->s_partition_root &&

	     vat_block >= start_block - 3 &&

	     !sbi->s_vat_inode; vat_block--) {

	     vat_block >= start_block - 3; vat_block--) {

		ino.logicalBlockNum = vat_block - map->s_partition_root;

		sbi->s_vat_inode = udf_iget(sb, &ino);

		inode = udf_iget(sb, &ino);

		if (!IS_ERR(inode)) {

			sbi->s_vat_inode = inode;

			break;

		}

	}

}
@@ -2205,10 +2218,10 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) 
	/* assign inodes by physical block number */

	/* perhaps it's not extensible enough, but for now ... */

	inode = udf_iget(sb, &rootdir);

	if (!inode) {

	if (IS_ERR(inode)) {

		udf_err(sb, "Error in udf_iget, block=%d, partition=%d\n",

		       rootdir.logicalBlockNum, rootdir.partitionReferenceNum);

		ret = -EIO;

		ret = PTR_ERR(inode);

		goto error_out;

	}

fs/udf/udfdecl.h

+0 −1
Original line number Diff line number Diff line
@@ -143,7 +143,6 @@ extern int udf_expand_file_adinicb(struct inode *); 
extern struct buffer_head *udf_expand_dir_adinicb(struct inode *, int *, int *);

extern struct buffer_head *udf_bread(struct inode *, int, int, int *);

extern int udf_setsize(struct inode *, loff_t);

extern void udf_read_inode(struct inode *);

extern void udf_evict_inode(struct inode *);

extern int udf_write_inode(struct inode *, struct writeback_control *wbc);

extern long udf_block_map(struct inode *, sector_t);

CRA Git | Maintained and supported by SUSTech CRA and CCSE