[linux-block.git] / fs / iomap / fiemap.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2016-2021 Christoph Hellwig.
 */
#include <linux/module.h>
#include <linux/compiler.h>
#include <linux/fs.h>
#include <linux/iomap.h>
#include <linux/fiemap.h>
#include <linux/pagemap.h>

static int iomap_to_fiemap(struct fiemap_extent_info *fi,
		const struct iomap *iomap, u32 flags)
{
	switch (iomap->type) {
	case IOMAP_HOLE:
		/* skip holes */
		return 0;
	case IOMAP_DELALLOC:
		flags |= FIEMAP_EXTENT_DELALLOC | FIEMAP_EXTENT_UNKNOWN;
		break;
	case IOMAP_MAPPED:
		break;
	case IOMAP_UNWRITTEN:
		flags |= FIEMAP_EXTENT_UNWRITTEN;
		break;
	case IOMAP_INLINE:
		flags |= FIEMAP_EXTENT_DATA_INLINE;
		break;
	}

	if (iomap->flags & IOMAP_F_MERGED)
		flags |= FIEMAP_EXTENT_MERGED;
	if (iomap->flags & IOMAP_F_SHARED)
		flags |= FIEMAP_EXTENT_SHARED;

	return fiemap_fill_next_extent(fi, iomap->offset,
			iomap->addr != IOMAP_NULL_ADDR ? iomap->addr : 0,
			iomap->length, flags);
}

static loff_t iomap_fiemap_iter(const struct iomap_iter *iter,
		struct fiemap_extent_info *fi, struct iomap *prev)
{
	int ret;

	if (iter->iomap.type == IOMAP_HOLE)
		return iomap_length(iter);

	ret = iomap_to_fiemap(fi, prev, 0);
	*prev = iter->iomap;
	switch (ret) {
	case 0:		/* success */
		return iomap_length(iter);
	case 1:		/* extent array full */
		return 0;
	default:	/* error */
		return ret;
	}
}

int iomap_fiemap(struct inode *inode, struct fiemap_extent_info *fi,
		u64 start, u64 len, const struct iomap_ops *ops)
{
	struct iomap_iter iter = {
		.inode		= inode,
		.pos		= start,
		.len		= len,
		.flags		= IOMAP_REPORT,
	};
	struct iomap prev = {
		.type		= IOMAP_HOLE,
	};
	int ret;

	ret = fiemap_prep(inode, fi, start, &iter.len, 0);
	if (ret)
		return ret;

	while ((ret = iomap_iter(&iter, ops)) > 0)
		iter.processed = iomap_fiemap_iter(&iter, fi, &prev);

	if (prev.type != IOMAP_HOLE) {
		ret = iomap_to_fiemap(fi, &prev, FIEMAP_EXTENT_LAST);
		if (ret < 0)
			return ret;
	}

	/* inode with no (attribute) mapping will give ENOENT */
	if (ret < 0 && ret != -ENOENT)
		return ret;
	return 0;
}
EXPORT_SYMBOL_GPL(iomap_fiemap);

/* legacy ->bmap interface.  0 is the error return (!) */
sector_t
iomap_bmap(struct address_space *mapping, sector_t bno,
		const struct iomap_ops *ops)
{
	struct iomap_iter iter = {
		.inode	= mapping->host,
		.pos	= (loff_t)bno << mapping->host->i_blkbits,
		.len	= i_blocksize(mapping->host),
		.flags	= IOMAP_REPORT,
	};
	const unsigned int blkshift = mapping->host->i_blkbits - SECTOR_SHIFT;
	int ret;

	if (filemap_write_and_wait(mapping))
		return 0;

	bno = 0;
	while ((ret = iomap_iter(&iter, ops)) > 0) {
		if (iter.iomap.type == IOMAP_MAPPED)
			bno = iomap_sector(&iter.iomap, iter.pos) >> blkshift;
		/* leave iter.processed unset to abort loop */
	}
	if (ret)
		return 0;

	return bno;
}
EXPORT_SYMBOL_GPL(iomap_bmap);
Commit	Line	Data
5157fb8f DW	1	// SPDX-License-Identifier: GPL-2.0
5157fb8f DW	2	/*
7892386d	3	* Copyright (c) 2016-2021 Christoph Hellwig.
5157fb8f DW	4	*/
	5	#include <linux/module.h>
	6	#include <linux/compiler.h>
	7	#include <linux/fs.h>
	8	#include <linux/iomap.h>
10c5db28	9	#include <linux/fiemap.h>
cbcc268b	10	#include <linux/pagemap.h>
5157fb8f	11
5157fb8f	12	static int iomap_to_fiemap(struct fiemap_extent_info *fi,
7892386d	13	const struct iomap *iomap, u32 flags)
5157fb8f DW	14	{
	15	switch (iomap->type) {
	16	case IOMAP_HOLE:
	17	/* skip holes */
	18	return 0;
	19	case IOMAP_DELALLOC:
	20	flags \|= FIEMAP_EXTENT_DELALLOC \| FIEMAP_EXTENT_UNKNOWN;
	21	break;
	22	case IOMAP_MAPPED:
	23	break;
	24	case IOMAP_UNWRITTEN:
	25	flags \|= FIEMAP_EXTENT_UNWRITTEN;
	26	break;
	27	case IOMAP_INLINE:
	28	flags \|= FIEMAP_EXTENT_DATA_INLINE;
	29	break;
	30	}
	31
	32	if (iomap->flags & IOMAP_F_MERGED)
	33	flags \|= FIEMAP_EXTENT_MERGED;
	34	if (iomap->flags & IOMAP_F_SHARED)
	35	flags \|= FIEMAP_EXTENT_SHARED;
	36
	37	return fiemap_fill_next_extent(fi, iomap->offset,
	38	iomap->addr != IOMAP_NULL_ADDR ? iomap->addr : 0,
	39	iomap->length, flags);
	40	}
	41
7892386d CH	42	static loff_t iomap_fiemap_iter(const struct iomap_iter *iter,
7892386d CH	43	struct fiemap_extent_info fi, struct iomap prev)
5157fb8f	44	{
7892386d	45	int ret;
5157fb8f	46
7892386d CH	47	if (iter->iomap.type == IOMAP_HOLE)
7892386d CH	48	return iomap_length(iter);
5157fb8f	49
7892386d CH	50	ret = iomap_to_fiemap(fi, prev, 0);
7892386d CH	51	*prev = iter->iomap;
5157fb8f DW	52	switch (ret) {
5157fb8f DW	53	case 0: /* success */
7892386d	54	return iomap_length(iter);
5157fb8f DW	55	case 1: /* extent array full */
5157fb8f DW	56	return 0;
7892386d	57	default: /* error */
5157fb8f DW	58	return ret;
	59	}
	60	}
	61
	62	int iomap_fiemap(struct inode inode, struct fiemap_extent_info fi,
27328818	63	u64 start, u64 len, const struct iomap_ops *ops)
5157fb8f	64	{
7892386d CH	65	struct iomap_iter iter = {
	66	.inode = inode,
	67	.pos = start,
	68	.len = len,
	69	.flags = IOMAP_REPORT,
	70	};
	71	struct iomap prev = {
	72	.type = IOMAP_HOLE,
	73	};
	74	int ret;
5157fb8f	75
7892386d	76	ret = fiemap_prep(inode, fi, start, &iter.len, 0);
5157fb8f DW	77	if (ret)
	78	return ret;
	79
7892386d CH	80	while ((ret = iomap_iter(&iter, ops)) > 0)
7892386d CH	81	iter.processed = iomap_fiemap_iter(&iter, fi, &prev);
5157fb8f	82
7892386d CH	83	if (prev.type != IOMAP_HOLE) {
7892386d CH	84	ret = iomap_to_fiemap(fi, &prev, FIEMAP_EXTENT_LAST);
5157fb8f DW	85	if (ret < 0)
	86	return ret;
	87	}
	88
7892386d CH	89	/* inode with no (attribute) mapping will give ENOENT */
	90	if (ret < 0 && ret != -ENOENT)
	91	return ret;
5157fb8f DW	92	return 0;
	93	}
	94	EXPORT_SYMBOL_GPL(iomap_fiemap);
	95
5157fb8f DW	96	/* legacy ->bmap interface. 0 is the error return (!) */
	97	sector_t
	98	iomap_bmap(struct address_space *mapping, sector_t bno,
	99	const struct iomap_ops *ops)
	100	{
6d8a1287 CH	101	struct iomap_iter iter = {
	102	.inode = mapping->host,
	103	.pos = (loff_t)bno << mapping->host->i_blkbits,
	104	.len = i_blocksize(mapping->host),
	105	.flags = IOMAP_REPORT,
	106	};
	107	const unsigned int blkshift = mapping->host->i_blkbits - SECTOR_SHIFT;
2b91b28e	108	int ret;
5157fb8f DW	109
	110	if (filemap_write_and_wait(mapping))
	111	return 0;
	112
	113	bno = 0;
6d8a1287 CH	114	while ((ret = iomap_iter(&iter, ops)) > 0) {
	115	if (iter.iomap.type == IOMAP_MAPPED)
	116	bno = iomap_sector(&iter.iomap, iter.pos) >> blkshift;
	117	/* leave iter.processed unset to abort loop */
	118	}
2b91b28e DW	119	if (ret)
2b91b28e DW	120	return 0;
6d8a1287	121
5157fb8f DW	122	return bno;
	123	}
	124	EXPORT_SYMBOL_GPL(iomap_bmap);