lists.openwall.net   lists  /  announce  owl-users  owl-dev  john-users  john-dev  passwdqc-users  yescrypt  popa3d-users  /  oss-security  kernel-hardening  musl  sabotage  tlsify  passwords  /  crypt-dev  xvendor  /  Bugtraq  Full-Disclosure  linux-kernel  linux-netdev  linux-ext4  linux-hardening  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Date:	Sun, 23 Jun 2013 13:30:22 +0400
From:	Dmitry Monakhov <dmonakhov@...nvz.org>
To:	Namjae Jeon <linkinjeon@...il.com>, tytso@....edu,
	adilger.kernel@...ger.ca
Cc:	linux-fsdevel@...r.kernel.org, linux-kernel@...r.kernel.org,
	linux-ext4@...r.kernel.org, a.sangwan@...sung.com,
	Namjae Jeon <linkinjeon@...il.com>,
	Namjae Jeon <namjae.jeon@...sung.com>
Subject: Re: [PATCH 1/3] ext4: Add EXT4_IOC_TRUNCATE_BLOCK_RANGE ioctl

On Sun, 23 Jun 2013 15:07:36 +0900, Namjae Jeon <linkinjeon@...il.com> wrote:
> From: Namjae Jeon <namjae.jeon@...sung.com>
What is the difference between this ioctl and generic punch_hole?
> 
> The EXT4_IOC_TRUNCATE_BLOCK_RANGE removes the data blocks lying
> between [start, "start + length") and updates the logical block numbers
> of data blocks starting from "start + length" block to last block of file.
> This will maintain contiguous nature of logical block numbers
> after block removal.
> Both the inode's disksize and logical size are updated after block
> removal
> 
> Signed-off-by: Namjae Jeon <namjae.jeon@...sung.com>
> Signed-off-by: Ashish Sangwan <a.sangwan@...sung.com>
> ---
>  fs/ext4/ext4.h         |    8 ++
>  fs/ext4/ext4_extents.h |    3 +
>  fs/ext4/extents.c      |  245 ++++++++++++++++++++++++++++++++++++++++++++++++
>  fs/ext4/ioctl.c        |   62 ++++++++++++
>  4 files changed, 318 insertions(+)
> 
> diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
> index 6ed348d..df2c411 100644
> --- a/fs/ext4/ext4.h
> +++ b/fs/ext4/ext4.h
> @@ -590,6 +590,7 @@ enum {
>  #define EXT4_IOC_MOVE_EXT		_IOWR('f', 15, struct move_extent)
>  #define EXT4_IOC_RESIZE_FS		_IOW('f', 16, __u64)
>  #define EXT4_IOC_SWAP_BOOT		_IO('f', 17)
> +#define EXT4_IOC_TRUNCATE_BLOCK_RANGE	_IOW('f', 18, struct truncate_range)
>  
>  #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
>  /*
> @@ -682,6 +683,11 @@ struct move_extent {
>  	__u64 moved_len;	/* moved block length */
>  };
>  
> +struct truncate_range {
> +	__u32 start_block;
> +	__u32 length;
> +};
> +
>  #define EXT4_EPOCH_BITS 2
>  #define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
>  #define EXT4_NSEC_MASK  (~0UL << EXT4_EPOCH_BITS)
> @@ -2692,6 +2698,8 @@ extern int ext4_find_delalloc_range(struct inode *inode,
>  extern int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk);
>  extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
>  			__u64 start, __u64 len);
> +extern int ext4_ext_truncate_range(struct inode *inode, ext4_lblk_t start,
> +				   ext4_lblk_t end, ext4_lblk_t last_block);
>  
>  
>  /* move_extent.c */
> diff --git a/fs/ext4/ext4_extents.h b/fs/ext4/ext4_extents.h
> index 51bc821..cc113cc 100644
> --- a/fs/ext4/ext4_extents.h
> +++ b/fs/ext4/ext4_extents.h
> @@ -178,6 +178,9 @@ struct ext4_ext_path {
>  #define EXT_MAX_INDEX(__hdr__) \
>  	(EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
>  
> +#define EXTENT_START_FLAG	0x1
> +#define INDEX_START_FLAG	0x2
> +
>  static inline struct ext4_extent_header *ext_inode_hdr(struct inode *inode)
>  {
>  	return (struct ext4_extent_header *) EXT4_I(inode)->i_data;
> diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
> index 937593e..ed85e34 100644
> --- a/fs/ext4/extents.c
> +++ b/fs/ext4/extents.c
> @@ -4757,3 +4757,248 @@ int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
>  
>  	return error;
>  }
> +
> +/*
> + * ext4_trange_dirty_path: Function to mark the path buffer dirty.
> + * It also checks if there are sufficient credits left in the
> + * journal to update metadata. If the number of credits are less
> + * restart the handle with additional credits.
> + *
> + * @handle: journal handle
> + * @inode: file inode
> + * @path: pointer to path
> + * @num: number of inodes to be updated
> + *
> + * Returns: 0 on success or negative value on error
> + */
> +int ext4_trange_dirty_path(handle_t *handle, struct inode *inode,
> +			   struct ext4_ext_path *path,
> +			   int num, ...)
> +{
> +	int credits, err, i;
> +	struct inode *iptr;
> +	va_list args;
> +
> +	/*
> +	 * Check if need to extend journal credits
> +	 * 3 for leaf, sb, and inode plus 2 (bmap and group
> +	 * descriptor) for each block group; assume two block
> +	 * groups
> +	 */
> +	if (handle->h_buffer_credits < 7*(num + 1)) {
> +		credits = ext4_writepage_trans_blocks(inode);
> +		va_start(args, num);
> +		for (i = 1; i <= num; i++) {
> +			iptr = va_arg(args, struct inode *);
> +			credits += ext4_writepage_trans_blocks(iptr);
> +		}
> +		va_end(args);
> +		err = ext4_ext_truncate_extend_restart(handle, inode, credits);
> +		/* EAGAIN is success */
> +		if (err && err != -EAGAIN)
> +			return err;
> +	}
> +	err = ext4_ext_get_access(handle, inode, path);
> +	return err;
> +}
> +
> +/*
> + * ext4_ext_update_path: update the extents of a path structure
> + * lying between path[depth].p_ext and EXT_LAST_EXTENT(path[depth].p_hdr)
> + * subtracting shift from starting block for each extent.
> + *
> + * @path: path for which extents are updated
> + * @shift: Number of blocks to be subtracted from first logical block
> + * that extent covers for each extent.
> + * @inode: file inode
> + * @handle: journal handle
> + * @start_block: Points to the starting block of next extent which is
> + * to be updated.
> + *
> + * Returns: 0 on success or negative on error.
> + */
> +int ext4_ext_update_path(struct ext4_ext_path *path, ext4_lblk_t shift,
> +			 struct inode *inode, handle_t *handle,
> +			 ext4_lblk_t *start_block)
> +{
> +	int depth, err = 0, flag = 0;
> +	struct ext4_extent *ex_start, *ex_last;
> +
> +	depth = path->p_depth;
> +	while (depth >= 0) {
> +		if (depth == path->p_depth) {
> +			ex_start = path[depth].p_ext;
> +			if (!ex_start)
> +				return -EIO;
> +
> +			err = ext4_trange_dirty_path(handle, inode,
> +						     path + depth, 0);
> +			if (err)
> +				goto out;
> +
> +			if (path[depth].p_ext ==
> +				EXT_FIRST_EXTENT(path[depth].p_hdr))
> +				flag |= EXTENT_START_FLAG;
> +
> +			ex_last = EXT_LAST_EXTENT(path[depth].p_hdr);
> +			while (ex_start <= ex_last) {
> +				*start_block = ex_start->ee_block +
> +					ext4_ext_get_actual_len(ex_start);
> +				ex_start->ee_block -= shift;
> +				ex_start++;
> +			}
> +			err = ext4_ext_dirty(handle, inode, path + depth);
> +			if (err)
> +				goto out;
> +		} else {
> +			/* If encountered starting extent, update index too */
> +			if (path->p_depth - depth == 1) {
> +				if (flag & EXTENT_START_FLAG) {
> +					/* Update index too */
> +					err = ext4_trange_dirty_path(handle,
> +						    inode, path + depth, 0);
> +					if (err)
> +						goto out;
> +					path[depth].p_idx->ei_block -= shift;
> +					err = ext4_ext_dirty(handle, inode,
> +							     path + depth);
> +					if (err)
> +						goto out;
> +					flag &= ~EXTENT_START_FLAG;
> +				} else
> +					/* No need to update any extent index */
> +					break;
> +			}
> +			/* Check, if earlier encountered starting index */
> +			if (flag & INDEX_START_FLAG) {
> +				err = ext4_trange_dirty_path(handle, inode,
> +							path + (depth), 0);
> +				if (err)
> +					goto out;
> +				path[depth].p_idx->ei_block -= shift;
> +				err = ext4_ext_dirty(handle, inode,
> +						     path + depth);
> +				if (err)
> +					goto out;
> +				flag &= ~INDEX_START_FLAG;
> +			}
> +			/* Check if this is a starting index */
> +			if (path[depth].p_idx ==
> +			    EXT_FIRST_INDEX(path[depth].p_hdr)) {
> +				/* starting of a block */
> +				flag |= INDEX_START_FLAG;
> +			} else
> +				break;
> +		}
> +		depth--;
> +	}
> +out:
> +	return err;
> +}
> +
> +/*
> + * ext4_ext_update_logical: update logical blocks ranging from start
> + * to the end block for inode by moving them shift blocks to the left
> + *
> + * @inode: file inode
> + * @handle: journal handle
> + * @start_block : starting block for block updation
> + * @shift: number of blocks to be shifted
> + * @end_block: last block to be updated
> + *
> + * Returns: 0 on success or negative on failure
> + */
> +static int ext4_ext_update_logical(struct inode *inode, handle_t *handle,
> +				   ext4_lblk_t start_block, ext4_lblk_t shift,
> +				   ext4_lblk_t end_block)
> +{
> +	struct ext4_ext_path *path;
> +	int err = 0;
> +
> +	while (start_block < end_block) {
> +		path = ext4_ext_find_extent(inode, start_block, NULL);
> +		if (IS_ERR(path)) {
> +			err = PTR_ERR(path);
> +			break;
> +		}
> +		err = ext4_ext_update_path(path, shift, inode,
> +					   handle, &start_block);
> +		ext4_ext_drop_refs(path);
> +		kfree(path);
> +		if (err)
> +			break;
> +	}
> +	return err;
> +}
> +
> +/*
> + * ext4_ext_truncate_range: truncate the block range from start
> + * block to end block including the end block from inode.
> + *
> + * @inode: file inode
> + * @start: start block
> + * @end: end block
> + * last_block: last_block number of the inode
> + *
> + * Returns: 0 on success or negative on error
> + */
> +int ext4_ext_truncate_range(struct inode *inode, ext4_lblk_t start,
> +			    ext4_lblk_t end, ext4_lblk_t last_block)
> +{
> +	int ret, credits;
> +	ext4_lblk_t shift = end - start + 1;
> +	handle_t *handle;
> +	loff_t isize_reduced;
> +	int blkbits = inode->i_blkbits;
> +	struct address_space *mapping = inode->i_mapping;
> +
> +	/* sync dirty pages for transfer */
> +	if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
> +		ret = filemap_write_and_wait_range(mapping,
> +				(loff_t)start << blkbits,
> +				((loff_t)(last_block + 1) << blkbits) - 1);
> +		if (ret)
> +			return ret;
> +	}
> +	truncate_inode_pages_range(inode->i_mapping,
> +				   start << inode->i_blkbits, -1);
> +	ext4_inode_block_unlocked_dio(inode);
> +	inode_dio_wait(inode);
> +	down_write(&EXT4_I(inode)->i_data_sem);
> +	ext4_discard_preallocations(inode);
> +	ret = ext4_es_remove_extent(inode, start, end - start + 1);
> +	if (ret)
> +		goto out;
> +
> +	credits = ext4_writepage_trans_blocks(inode);
> +	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
> +	if (IS_ERR(handle)) {
> +		ret = PTR_ERR(handle);
> +		goto out;
> +	}
> +
> +	ret = ext4_ext_remove_space(inode, start, end);
> +	if (ret)
> +		goto journal_stop;
> +
> +	ext4_discard_preallocations(inode);
> +
> +	if (end < last_block) {
> +		ret = ext4_ext_update_logical(inode, handle, end + 1,
> +					      shift, last_block + 1);
> +		if (ret)
> +			goto journal_stop;
> +	}
> +	isize_reduced = (loff_t)shift << blkbits;
> +	i_size_write(inode, inode->i_size - isize_reduced);
> +	EXT4_I(inode)->i_disksize -= isize_reduced;
> +	inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
> +	ext4_mark_inode_dirty(handle, inode);
> +journal_stop:
> +	ext4_journal_stop(handle);
> +out:
> +	ext4_inode_resume_unlocked_dio(inode);
> +	up_write(&EXT4_I(inode)->i_data_sem);
> +	return ret;
> +}
> +
> diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
> index 9491ac0..0530daf 100644
> --- a/fs/ext4/ioctl.c
> +++ b/fs/ext4/ioctl.c
> @@ -622,6 +622,68 @@ resizefs_out:
>  
>  		return 0;
>  	}
> +	case EXT4_IOC_TRUNCATE_BLOCK_RANGE:
> +	{
> +		struct truncate_range tr;
> +		ext4_lblk_t last_block, end_block;
> +		int error;
> +		loff_t i_size = i_size_read(inode);
> +
> +		if (!i_size)
> +			return 0;
> +
> +		if (!(filp->f_mode & FMODE_WRITE))
> +			return -EBADF;
> +
> +		if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
> +			return -EPERM;
> +
> +		if (!S_ISREG(inode->i_mode))
> +			return -EOPNOTSUPP;
> +
> +		if (IS_SWAPFILE(inode))
> +			return -EOPNOTSUPP;
> +
> +		if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
> +			return -EOPNOTSUPP;
> +
> +		if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
> +		    EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
> +			ext4_msg(sb, KERN_ERR,
> +			 "Truncate block range not supported with bigalloc");
> +			return -EOPNOTSUPP;
> +		}
> +
> +		if (copy_from_user(&tr, (const void *) arg,
> +				sizeof(struct truncate_range)))
> +			return -EFAULT;
> +
> +		if (!tr.length)
> +			return -EINVAL;
> +
> +		end_block = tr.start_block + tr.length - 1;
> +
> +		last_block = ((round_up(i_size,
> +					EXT4_BLOCK_SIZE(inode->i_sb)))
> +			      >> inode->i_blkbits) - 1;
> +		if (tr.start_block > end_block ||
> +		    tr.start_block > last_block)
> +			return -EINVAL;
> +
> +		if (end_block > last_block)
> +			end_block = last_block;
> +
> +		error = mnt_want_write_file(filp);
> +		if (error)
> +			return error;
> +
> +		mutex_lock(&inode->i_mutex);
> +		error = ext4_ext_truncate_range(inode, tr.start_block,
> +						end_block, last_block);
> +		mutex_unlock(&inode->i_mutex);
> +		mnt_drop_write_file(filp);
> +		return error;
> +	}
>  
>  	default:
>  		return -ENOTTY;
> -- 
> 1.7.9.5
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@...r.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Powered by blists - more mailing lists