Merge tag 'fs_for_v6.12-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs (4770119d) · Commits · git / linux-nf

fs/udf/balloc.c

+25 −13

Original line number	Diff line number	Diff line
		@@ -370,6 +370,7 @@ static void udf_table_free_blocks(struct super_block *sb,
		struct extent_position oepos, epos;
		int8_t etype;
		struct udf_inode_info *iinfo;
		int ret = 0;

		mutex_lock(&sbi->s_alloc_mutex);
		iinfo = UDF_I(table);
		@@ -383,8 +384,12 @@ static void udf_table_free_blocks(struct super_block *sb,
		epos.block = oepos.block = iinfo->i_location;
		epos.bh = oepos.bh = NULL;

		while (count &&
		(etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
		while (count) {
		ret = udf_next_aext(table, &epos, &eloc, &elen, &etype, 1);
		if (ret < 0)
		goto error_return;
		if (ret == 0)
		break;
		if (((eloc.logicalBlockNum +
		(elen >> sb->s_blocksize_bits)) == start)) {
		if ((0x3FFFFFFF - elen) <
		@@ -459,11 +464,8 @@ static void udf_table_free_blocks(struct super_block *sb,
		adsize = sizeof(struct short_ad);
		else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
		adsize = sizeof(struct long_ad);
		else {
		brelse(oepos.bh);
		brelse(epos.bh);
		else
		goto error_return;
		}

		if (epos.offset + (2 * adsize) > sb->s_blocksize) {
		/* Steal a block from the extent being free'd */
		@@ -479,10 +481,10 @@ static void udf_table_free_blocks(struct super_block *sb,
		__udf_add_aext(table, &epos, &eloc, elen, 1);
		}

		error_return:
		brelse(epos.bh);
		brelse(oepos.bh);

		error_return:
		mutex_unlock(&sbi->s_alloc_mutex);
		return;
		}
		@@ -498,6 +500,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
		struct extent_position epos;
		int8_t etype = -1;
		struct udf_inode_info *iinfo;
		int ret = 0;

		if (first_block >= sbi->s_partmaps[partition].s_partition_len)
		return 0;
		@@ -516,11 +519,14 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
		epos.bh = NULL;
		eloc.logicalBlockNum = 0xFFFFFFFF;

		while (first_block != eloc.logicalBlockNum &&
		(etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
		while (first_block != eloc.logicalBlockNum) {
		ret = udf_next_aext(table, &epos, &eloc, &elen, &etype, 1);
		if (ret < 0)
		goto err_out;
		if (ret == 0)
		break;
		udf_debug("eloc=%u, elen=%u, first_block=%u\n",
		eloc.logicalBlockNum, elen, first_block);
		; /* empty loop body */
		}

		if (first_block == eloc.logicalBlockNum) {
		@@ -539,6 +545,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
		alloc_count = 0;
		}

		err_out:
		brelse(epos.bh);

		if (alloc_count)
		@@ -560,6 +567,7 @@ static udf_pblk_t udf_table_new_block(struct super_block *sb,
		struct extent_position epos, goal_epos;
		int8_t etype;
		struct udf_inode_info *iinfo = UDF_I(table);
		int ret = 0;

		*err = -ENOSPC;

		@@ -583,8 +591,10 @@ static udf_pblk_t udf_table_new_block(struct super_block *sb,
		epos.block = iinfo->i_location;
		epos.bh = goal_epos.bh = NULL;

		while (spread &&
		(etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
		while (spread) {
		ret = udf_next_aext(table, &epos, &eloc, &elen, &etype, 1);
		if (ret <= 0)
		break;
		if (goal >= eloc.logicalBlockNum) {
		if (goal < eloc.logicalBlockNum +
		(elen >> sb->s_blocksize_bits))
		@@ -612,9 +622,11 @@ static udf_pblk_t udf_table_new_block(struct super_block *sb,

		brelse(epos.bh);

		if (spread == 0xFFFFFFFF) {
		if (ret < 0 \|\| spread == 0xFFFFFFFF) {
		brelse(goal_epos.bh);
		mutex_unlock(&sbi->s_alloc_mutex);
		if (ret < 0)
		*err = ret;
		return 0;
		}

fs/udf/directory.c

+16 −7

Original line number	Diff line number	Diff line
		@@ -166,13 +166,19 @@ static struct buffer_head udf_fiiter_bread_blk(struct udf_fileident_iter iter)
		*/
		static int udf_fiiter_advance_blk(struct udf_fileident_iter *iter)
		{
		int8_t etype = -1;
		int err = 0;

		iter->loffset++;
		if (iter->loffset < DIV_ROUND_UP(iter->elen, 1<<iter->dir->i_blkbits))
		return 0;

		iter->loffset = 0;
		if (udf_next_aext(iter->dir, &iter->epos, &iter->eloc, &iter->elen, 1)
		!= (EXT_RECORDED_ALLOCATED >> 30)) {
		err = udf_next_aext(iter->dir, &iter->epos, &iter->eloc,
		&iter->elen, &etype, 1);
		if (err < 0)
		return err;
		else if (err == 0 \|\| etype != (EXT_RECORDED_ALLOCATED >> 30)) {
		if (iter->pos == iter->dir->i_size) {
		iter->elen = 0;
		return 0;
		@@ -240,6 +246,7 @@ int udf_fiiter_init(struct udf_fileident_iter iter, struct inode dir,
		{
		struct udf_inode_info *iinfo = UDF_I(dir);
		int err = 0;
		int8_t etype;

		iter->dir = dir;
		iter->bh[0] = iter->bh[1] = NULL;
		@@ -259,9 +266,9 @@ int udf_fiiter_init(struct udf_fileident_iter iter, struct inode dir,
		goto out;
		}

		if (inode_bmap(dir, iter->pos >> dir->i_blkbits, &iter->epos,
		&iter->eloc, &iter->elen, &iter->loffset) !=
		(EXT_RECORDED_ALLOCATED >> 30)) {
		err = inode_bmap(dir, iter->pos >> dir->i_blkbits, &iter->epos,
		&iter->eloc, &iter->elen, &iter->loffset, &etype);
		if (err <= 0 \|\| etype != (EXT_RECORDED_ALLOCATED >> 30)) {
		if (pos == dir->i_size)
		return 0;
		udf_err(dir->i_sb,
		@@ -457,6 +464,7 @@ int udf_fiiter_append_blk(struct udf_fileident_iter *iter)
		sector_t block;
		uint32_t old_elen = iter->elen;
		int err;
		int8_t etype;

		if (WARN_ON_ONCE(iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB))
		return -EINVAL;
		@@ -471,8 +479,9 @@ int udf_fiiter_append_blk(struct udf_fileident_iter *iter)
		udf_fiiter_update_elen(iter, old_elen);
		return err;
		}
		if (inode_bmap(iter->dir, block, &iter->epos, &iter->eloc, &iter->elen,
		&iter->loffset) != (EXT_RECORDED_ALLOCATED >> 30)) {
		err = inode_bmap(iter->dir, block, &iter->epos, &iter->eloc, &iter->elen,
		&iter->loffset, &etype);
		if (err <= 0 \|\| etype != (EXT_RECORDED_ALLOCATED >> 30)) {
		udf_err(iter->dir->i_sb,
		"block %llu not allocated in directory (ino %lu)\n",
		(unsigned long long)block, iter->dir->i_ino);

fs/udf/inode.c

+134 −68

Original line number	Diff line number	Diff line
		@@ -404,7 +404,7 @@ struct udf_map_rq {

		static int udf_map_block(struct inode inode, struct udf_map_rq map)
		{
		int err;
		int ret;
		struct udf_inode_info *iinfo = UDF_I(inode);

		if (WARN_ON_ONCE(iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB))
		@@ -416,18 +416,24 @@ static int udf_map_block(struct inode inode, struct udf_map_rq map)
		uint32_t elen;
		sector_t offset;
		struct extent_position epos = {};
		int8_t etype;

		down_read(&iinfo->i_data_sem);
		if (inode_bmap(inode, map->lblk, &epos, &eloc, &elen, &offset)
		== (EXT_RECORDED_ALLOCATED >> 30)) {
		ret = inode_bmap(inode, map->lblk, &epos, &eloc, &elen, &offset,
		&etype);
		if (ret < 0)
		goto out_read;
		if (ret > 0 && etype == (EXT_RECORDED_ALLOCATED >> 30)) {
		map->pblk = udf_get_lb_pblock(inode->i_sb, &eloc,
		offset);
		map->oflags \|= UDF_BLK_MAPPED;
		ret = 0;
		}
		out_read:
		up_read(&iinfo->i_data_sem);
		brelse(epos.bh);

		return 0;
		return ret;
		}

		down_write(&iinfo->i_data_sem);
		@@ -438,9 +444,9 @@ static int udf_map_block(struct inode inode, struct udf_map_rq map)
		if (((loff_t)map->lblk) << inode->i_blkbits >= iinfo->i_lenExtents)
		udf_discard_prealloc(inode);
		udf_clear_extent_cache(inode);
		err = inode_getblk(inode, map);
		ret = inode_getblk(inode, map);
		up_write(&iinfo->i_data_sem);
		return err;
		return ret;
		}

		static int __udf_get_block(struct inode *inode, sector_t block,
		@@ -543,6 +549,7 @@ static int udf_do_extend_file(struct inode *inode,
		} else {
		struct kernel_lb_addr tmploc;
		uint32_t tmplen;
		int8_t tmptype;

		udf_write_aext(inode, last_pos, &last_ext->extLocation,
		last_ext->extLength, 1);
		@@ -552,8 +559,12 @@ static int udf_do_extend_file(struct inode *inode,
		* more extents, we may need to enter possible following
		* empty indirect extent.
		*/
		if (new_block_bytes)
		udf_next_aext(inode, last_pos, &tmploc, &tmplen, 0);
		if (new_block_bytes) {
		err = udf_next_aext(inode, last_pos, &tmploc, &tmplen,
		&tmptype, 0);
		if (err < 0)
		goto out_err;
		}
		}
		iinfo->i_lenExtents += add;

		@@ -657,8 +668,10 @@ static int udf_extend_file(struct inode *inode, loff_t newsize)
		*/
		udf_discard_prealloc(inode);

		etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
		within_last_ext = (etype != -1);
		err = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset, &etype);
		if (err < 0)
		goto out;
		within_last_ext = (err == 1);
		/* We don't expect extents past EOF... */
		WARN_ON_ONCE(within_last_ext &&
		elen > ((loff_t)offset + 1) << inode->i_blkbits);
		@@ -672,8 +685,10 @@ static int udf_extend_file(struct inode *inode, loff_t newsize)
		extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
		} else {
		epos.offset -= adsize;
		etype = udf_next_aext(inode, &epos, &extent.extLocation,
		&extent.extLength, 0);
		err = udf_next_aext(inode, &epos, &extent.extLocation,
		&extent.extLength, &etype, 0);
		if (err <= 0)
		goto out;
		extent.extLength \|= etype << 30;
		}

		@@ -710,11 +725,11 @@ static int inode_getblk(struct inode inode, struct udf_map_rq map)
		loff_t lbcount = 0, b_off = 0;
		udf_pblk_t newblocknum;
		sector_t offset = 0;
		int8_t etype;
		int8_t etype, tmpetype;
		struct udf_inode_info *iinfo = UDF_I(inode);
		udf_pblk_t goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
		int lastblock = 0;
		bool isBeyondEOF;
		bool isBeyondEOF = false;
		int ret = 0;

		prev_epos.offset = udf_file_entry_alloc_offset(inode);
		@@ -746,9 +761,13 @@ static int inode_getblk(struct inode inode, struct udf_map_rq map)
		prev_epos.offset = cur_epos.offset;
		cur_epos.offset = next_epos.offset;

		etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
		if (etype == -1)
		ret = udf_next_aext(inode, &next_epos, &eloc, &elen, &etype, 1);
		if (ret < 0) {
		goto out_free;
		} else if (ret == 0) {
		isBeyondEOF = true;
		break;
		}

		c = !c;

		@@ -769,13 +788,17 @@ static int inode_getblk(struct inode inode, struct udf_map_rq map)
		* Move prev_epos and cur_epos into indirect extent if we are at
		* the pointer to it
		*/
		udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0);
		udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0);
		ret = udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, &tmpetype, 0);
		if (ret < 0)
		goto out_free;
		ret = udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, &tmpetype, 0);
		if (ret < 0)
		goto out_free;

		/* if the extent is allocated and recorded, return the block
		if the extent is not a multiple of the blocksize, round up */

		if (etype == (EXT_RECORDED_ALLOCATED >> 30)) {
		if (!isBeyondEOF && etype == (EXT_RECORDED_ALLOCATED >> 30)) {
		if (elen & (inode->i_sb->s_blocksize - 1)) {
		elen = EXT_RECORDED_ALLOCATED \|
		((elen + inode->i_sb->s_blocksize - 1) &
		@@ -791,10 +814,9 @@ static int inode_getblk(struct inode inode, struct udf_map_rq map)
		}

		/* Are we beyond EOF and preallocated extent? */
		if (etype == -1) {
		if (isBeyondEOF) {
		loff_t hole_len;

		isBeyondEOF = true;
		if (count) {
		if (c)
		laarr[0] = laarr[1];
		@@ -830,7 +852,6 @@ static int inode_getblk(struct inode inode, struct udf_map_rq map)
		endnum = c + 1;
		lastblock = 1;
		} else {
		isBeyondEOF = false;
		endnum = startnum = ((count > 2) ? 2 : count);

		/* if the current extent is in position 0,
		@@ -844,15 +865,17 @@ static int inode_getblk(struct inode inode, struct udf_map_rq map)

		/* if the current block is located in an extent,
		read the next extent */
		etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0);
		if (etype != -1) {
		ret = udf_next_aext(inode, &next_epos, &eloc, &elen, &etype, 0);
		if (ret > 0) {
		laarr[c + 1].extLength = (etype << 30) \| elen;
		laarr[c + 1].extLocation = eloc;
		count++;
		startnum++;
		endnum++;
		} else
		} else if (ret == 0)
		lastblock = 1;
		else
		goto out_free;
		}

		/* if the current extent is not recorded but allocated, get the
		@@ -1170,6 +1193,7 @@ static int udf_update_extents(struct inode inode, struct kernel_long_ad laarr,
		int start = 0, i;
		struct kernel_lb_addr tmploc;
		uint32_t tmplen;
		int8_t tmpetype;
		int err;

		if (startnum > endnum) {
		@@ -1187,14 +1211,19 @@ static int udf_update_extents(struct inode inode, struct kernel_long_ad laarr,
		*/
		if (err < 0)
		return err;
		udf_next_aext(inode, epos, &laarr[i].extLocation,
		&laarr[i].extLength, 1);
		err = udf_next_aext(inode, epos, &laarr[i].extLocation,
		&laarr[i].extLength, &tmpetype, 1);
		if (err < 0)
		return err;
		start++;
		}
		}

		for (i = start; i < endnum; i++) {
		udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
		err = udf_next_aext(inode, epos, &tmploc, &tmplen, &tmpetype, 0);
		if (err < 0)
		return err;

		udf_write_aext(inode, epos, &laarr[i].extLocation,
		laarr[i].extLength, 1);
		}
		@@ -1953,6 +1982,7 @@ int udf_setup_indirect_aext(struct inode *inode, udf_pblk_t block,
		struct extent_position nepos;
		struct kernel_lb_addr neloc;
		int ver, adsize;
		int err = 0;

		if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
		adsize = sizeof(struct short_ad);
		@@ -1997,10 +2027,12 @@ int udf_setup_indirect_aext(struct inode *inode, udf_pblk_t block,
		if (epos->offset + adsize > sb->s_blocksize) {
		struct kernel_lb_addr cp_loc;
		uint32_t cp_len;
		int cp_type;
		int8_t cp_type;

		epos->offset -= adsize;
		cp_type = udf_current_aext(inode, epos, &cp_loc, &cp_len, 0);
		err = udf_current_aext(inode, epos, &cp_loc, &cp_len, &cp_type, 0);
		if (err <= 0)
		goto err_out;
		cp_len \|= ((uint32_t)cp_type) << 30;

		__udf_add_aext(inode, &nepos, &cp_loc, cp_len, 1);
		@@ -2015,6 +2047,9 @@ int udf_setup_indirect_aext(struct inode *inode, udf_pblk_t block,
		*epos = nepos;

		return 0;
		err_out:
		brelse(bh);
		return err;
		}

		/*
		@@ -2160,21 +2195,30 @@ void udf_write_aext(struct inode inode, struct extent_position epos,
		*/
		#define UDF_MAX_INDIR_EXTS 16

		int8_t udf_next_aext(struct inode inode, struct extent_position epos,
		struct kernel_lb_addr eloc, uint32_t elen, int inc)
		/*
		* Returns 1 on success, -errno on error, 0 on hit EOF.
		*/
		int udf_next_aext(struct inode inode, struct extent_position epos,
		struct kernel_lb_addr eloc, uint32_t elen, int8_t *etype,
		int inc)
		{
		int8_t etype;
		unsigned int indirections = 0;

		while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
		(EXT_NEXT_EXTENT_ALLOCDESCS >> 30)) {
		int ret = 0;
		udf_pblk_t block;

		while (1) {
		ret = udf_current_aext(inode, epos, eloc, elen,
		etype, inc);
		if (ret <= 0)
		return ret;
		if (*etype != (EXT_NEXT_EXTENT_ALLOCDESCS >> 30))
		return ret;

		if (++indirections > UDF_MAX_INDIR_EXTS) {
		udf_err(inode->i_sb,
		"too many indirect extents in inode %lu\n",
		inode->i_ino);
		return -1;
		return -EFSCORRUPTED;
		}

		epos->block = *eloc;
		@@ -2184,18 +2228,19 @@ int8_t udf_next_aext(struct inode inode, struct extent_position epos,
		epos->bh = sb_bread(inode->i_sb, block);
		if (!epos->bh) {
		udf_debug("reading block %u failed!\n", block);
		return -1;
		return -EIO;
		}
		}

		return etype;
		}

		int8_t udf_current_aext(struct inode inode, struct extent_position epos,
		struct kernel_lb_addr eloc, uint32_t elen, int inc)
		/*
		* Returns 1 on success, -errno on error, 0 on hit EOF.
		*/
		int udf_current_aext(struct inode inode, struct extent_position epos,
		struct kernel_lb_addr eloc, uint32_t elen, int8_t *etype,
		int inc)
		{
		int alen;
		int8_t etype;
		uint8_t *ptr;
		struct short_ad *sad;
		struct long_ad *lad;
		@@ -2210,20 +2255,23 @@ int8_t udf_current_aext(struct inode inode, struct extent_position epos,
		alen = udf_file_entry_alloc_offset(inode) +
		iinfo->i_lenAlloc;
		} else {
		struct allocExtDesc *header =
		(struct allocExtDesc *)epos->bh->b_data;

		if (!epos->offset)
		epos->offset = sizeof(struct allocExtDesc);
		ptr = epos->bh->b_data + epos->offset;
		alen = sizeof(struct allocExtDesc) +
		le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
		lengthAllocDescs);
		if (check_add_overflow(sizeof(struct allocExtDesc),
		le32_to_cpu(header->lengthAllocDescs), &alen))
		return -1;
		}

		switch (iinfo->i_alloc_type) {
		case ICBTAG_FLAG_AD_SHORT:
		sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
		if (!sad)
		return -1;
		etype = le32_to_cpu(sad->extLength) >> 30;
		return 0;
		*etype = le32_to_cpu(sad->extLength) >> 30;
		eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
		eloc->partitionReferenceNum =
		iinfo->i_location.partitionReferenceNum;
		@@ -2232,17 +2280,17 @@ int8_t udf_current_aext(struct inode inode, struct extent_position epos,
		case ICBTAG_FLAG_AD_LONG:
		lad = udf_get_filelongad(ptr, alen, &epos->offset, inc);
		if (!lad)
		return -1;
		etype = le32_to_cpu(lad->extLength) >> 30;
		return 0;
		*etype = le32_to_cpu(lad->extLength) >> 30;
		*eloc = lelb_to_cpu(lad->extLocation);
		*elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
		break;
		default:
		udf_debug("alloc_type = %u unsupported\n", iinfo->i_alloc_type);
		return -1;
		return -EINVAL;
		}

		return etype;
		return 1;
		}

		static int udf_insert_aext(struct inode *inode, struct extent_position epos,
		@@ -2251,20 +2299,24 @@ static int udf_insert_aext(struct inode *inode, struct extent_position epos,
		struct kernel_lb_addr oeloc;
		uint32_t oelen;
		int8_t etype;
		int err;
		int ret;

		if (epos.bh)
		get_bh(epos.bh);

		while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
		while (1) {
		ret = udf_next_aext(inode, &epos, &oeloc, &oelen, &etype, 0);
		if (ret <= 0)
		break;
		udf_write_aext(inode, &epos, &neloc, nelen, 1);
		neloc = oeloc;
		nelen = (etype << 30) \| oelen;
		}
		err = udf_add_aext(inode, &epos, &neloc, nelen, 1);
		if (ret == 0)
		ret = udf_add_aext(inode, &epos, &neloc, nelen, 1);
		brelse(epos.bh);

		return err;
		return ret;
		}

		int8_t udf_delete_aext(struct inode *inode, struct extent_position epos)
		@@ -2276,6 +2328,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos)
		struct udf_inode_info *iinfo;
		struct kernel_lb_addr eloc;
		uint32_t elen;
		int ret;

		if (epos.bh) {
		get_bh(epos.bh);
		@@ -2291,10 +2344,18 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos)
		adsize = 0;

		oepos = epos;
		if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
		if (udf_next_aext(inode, &epos, &eloc, &elen, &etype, 1) <= 0)
		return -1;

		while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
		while (1) {
		ret = udf_next_aext(inode, &epos, &eloc, &elen, &etype, 1);
		if (ret < 0) {
		brelse(epos.bh);
		brelse(oepos.bh);
		return -1;
		}
		if (ret == 0)
		break;
		udf_write_aext(inode, &oepos, &eloc, (etype << 30) \| elen, 1);
		if (oepos.bh != epos.bh) {
		oepos.block = epos.block;
		@@ -2351,14 +2412,17 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos)
		return (elen >> 30);
		}

		int8_t inode_bmap(struct inode *inode, sector_t block,
		struct extent_position pos, struct kernel_lb_addr eloc,
		uint32_t elen, sector_t offset)
		/*
		* Returns 1 on success, -errno on error, 0 on hit EOF.
		*/
		int inode_bmap(struct inode inode, sector_t block, struct extent_position pos,
		struct kernel_lb_addr eloc, uint32_t elen, sector_t *offset,
		int8_t *etype)
		{
		unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
		loff_t lbcount = 0, bcount = (loff_t) block << blocksize_bits;
		int8_t etype;
		struct udf_inode_info *iinfo;
		int err = 0;

		iinfo = UDF_I(inode);
		if (!udf_read_extent_cache(inode, bcount, &lbcount, pos)) {
		@@ -2368,11 +2432,13 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
		}
		*elen = 0;
		do {
		etype = udf_next_aext(inode, pos, eloc, elen, 1);
		if (etype == -1) {
		err = udf_next_aext(inode, pos, eloc, elen, etype, 1);
		if (err <= 0) {
		if (err == 0) {
		*offset = (bcount - lbcount) >> blocksize_bits;
		iinfo->i_lenExtents = lbcount;
		return -1;
		}
		return err;
		}
		lbcount += *elen;
		} while (lbcount <= bcount);
		@@ -2380,5 +2446,5 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
		udf_update_extent_cache(inode, lbcount - *elen, pos);
		offset = (bcount + elen - lbcount) >> blocksize_bits;

		return etype;
		return 1;
		}

fs/udf/partition.c

+4 −2

Original line number	Diff line number	Diff line
		@@ -282,9 +282,11 @@ static uint32_t udf_try_read_meta(struct inode *inode, uint32_t block,
		sector_t ext_offset;
		struct extent_position epos = {};
		uint32_t phyblock;
		int8_t etype;
		int err = 0;

		if (inode_bmap(inode, block, &epos, &eloc, &elen, &ext_offset) !=
		(EXT_RECORDED_ALLOCATED >> 30))
		err = inode_bmap(inode, block, &epos, &eloc, &elen, &ext_offset, &etype);
		if (err <= 0 \|\| etype != (EXT_RECORDED_ALLOCATED >> 30))
		phyblock = 0xFFFFFFFF;
		else {
		map = &UDF_SB(sb)->s_partmaps[partition];

fs/udf/super.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -2482,13 +2482,14 @@ static unsigned int udf_count_free_table(struct super_block *sb,
		uint32_t elen;
		struct kernel_lb_addr eloc;
		struct extent_position epos;
		int8_t etype;

		mutex_lock(&UDF_SB(sb)->s_alloc_mutex);
		epos.block = UDF_I(table)->i_location;
		epos.offset = sizeof(struct unallocSpaceEntry);
		epos.bh = NULL;

		while (udf_next_aext(table, &epos, &eloc, &elen, 1) != -1)
		while (udf_next_aext(table, &epos, &eloc, &elen, &etype, 1) > 0)
		accum += (elen >> table->i_sb->s_blocksize_bits);

		brelse(epos.bh);