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

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

struct fiemap_ctx {
	struct fiemap_extent_info *fi;
	struct iomap prev;
};

static int iomap_to_fiemap(struct fiemap_extent_info *fi,
		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_actor(struct inode *inode, loff_t pos, loff_t length, void *data,
		struct iomap *iomap, struct iomap *srcmap)
{
	struct fiemap_ctx *ctx = data;
	loff_t ret = length;

	if (iomap->type == IOMAP_HOLE)
		return length;

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

int iomap_fiemap(struct inode *inode, struct fiemap_extent_info *fi,
		u64 start, u64 len, const struct iomap_ops *ops)
{
	struct fiemap_ctx ctx;
	loff_t ret;

	memset(&ctx, 0, sizeof(ctx));
	ctx.fi = fi;
	ctx.prev.type = IOMAP_HOLE;

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

	while (len > 0) {
		ret = iomap_apply(inode, start, len, IOMAP_REPORT, ops, &ctx,
				iomap_fiemap_actor);
		/* inode with no (attribute) mapping will give ENOENT */
		if (ret == -ENOENT)
			break;
		if (ret < 0)
			return ret;
		if (ret == 0)
			break;

		start += ret;
		len -= ret;
	}

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

	return 0;
}
EXPORT_SYMBOL_GPL(iomap_fiemap);

static loff_t
iomap_bmap_actor(struct inode *inode, loff_t pos, loff_t length,
		void *data, struct iomap *iomap, struct iomap *srcmap)
{
	sector_t *bno = data, addr;

	if (iomap->type == IOMAP_MAPPED) {
		addr = (pos - iomap->offset + iomap->addr) >> inode->i_blkbits;
		*bno = addr;
	}
	return 0;
}

/* 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 inode *inode = mapping->host;
	loff_t pos = bno << inode->i_blkbits;
	unsigned blocksize = i_blocksize(inode);
	int ret;

	if (filemap_write_and_wait(mapping))
		return 0;

	bno = 0;
	ret = iomap_apply(inode, pos, blocksize, 0, ops, &bno,
			  iomap_bmap_actor);
	if (ret)
		return 0;
	return bno;
}
EXPORT_SYMBOL_GPL(iomap_bmap);
Commit	Line	Data
5157fb8f DW	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (c) 2016-2018 Christoph Hellwig.
	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>
5157fb8f	10
5157fb8f DW	11	struct fiemap_ctx {
	12	struct fiemap_extent_info *fi;
	13	struct iomap prev;
	14	};
	15
	16	static int iomap_to_fiemap(struct fiemap_extent_info *fi,
	17	struct iomap *iomap, u32 flags)
	18	{
	19	switch (iomap->type) {
	20	case IOMAP_HOLE:
	21	/* skip holes */
	22	return 0;
	23	case IOMAP_DELALLOC:
	24	flags \|= FIEMAP_EXTENT_DELALLOC \| FIEMAP_EXTENT_UNKNOWN;
	25	break;
	26	case IOMAP_MAPPED:
	27	break;
	28	case IOMAP_UNWRITTEN:
	29	flags \|= FIEMAP_EXTENT_UNWRITTEN;
	30	break;
	31	case IOMAP_INLINE:
	32	flags \|= FIEMAP_EXTENT_DATA_INLINE;
	33	break;
	34	}
	35
	36	if (iomap->flags & IOMAP_F_MERGED)
	37	flags \|= FIEMAP_EXTENT_MERGED;
	38	if (iomap->flags & IOMAP_F_SHARED)
	39	flags \|= FIEMAP_EXTENT_SHARED;
	40
	41	return fiemap_fill_next_extent(fi, iomap->offset,
	42	iomap->addr != IOMAP_NULL_ADDR ? iomap->addr : 0,
	43	iomap->length, flags);
	44	}
	45
	46	static loff_t
	47	iomap_fiemap_actor(struct inode inode, loff_t pos, loff_t length, void data,
c039b997	48	struct iomap iomap, struct iomap srcmap)
5157fb8f DW	49	{
	50	struct fiemap_ctx *ctx = data;
	51	loff_t ret = length;
	52
	53	if (iomap->type == IOMAP_HOLE)
	54	return length;
	55
	56	ret = iomap_to_fiemap(ctx->fi, &ctx->prev, 0);
	57	ctx->prev = *iomap;
	58	switch (ret) {
	59	case 0: /* success */
	60	return length;
	61	case 1: /* extent array full */
	62	return 0;
	63	default:
	64	return ret;
	65	}
	66	}
	67
	68	int iomap_fiemap(struct inode inode, struct fiemap_extent_info fi,
27328818	69	u64 start, u64 len, const struct iomap_ops *ops)
5157fb8f DW	70	{
	71	struct fiemap_ctx ctx;
	72	loff_t ret;
	73
	74	memset(&ctx, 0, sizeof(ctx));
	75	ctx.fi = fi;
	76	ctx.prev.type = IOMAP_HOLE;
	77
45dd052e	78	ret = fiemap_prep(inode, fi, start, &len, 0);
5157fb8f DW	79	if (ret)
	80	return ret;
	81
5157fb8f DW	82	while (len > 0) {
	83	ret = iomap_apply(inode, start, len, IOMAP_REPORT, ops, &ctx,
	84	iomap_fiemap_actor);
	85	/* inode with no (attribute) mapping will give ENOENT */
	86	if (ret == -ENOENT)
	87	break;
	88	if (ret < 0)
	89	return ret;
	90	if (ret == 0)
	91	break;
	92
	93	start += ret;
	94	len -= ret;
	95	}
	96
	97	if (ctx.prev.type != IOMAP_HOLE) {
	98	ret = iomap_to_fiemap(fi, &ctx.prev, FIEMAP_EXTENT_LAST);
	99	if (ret < 0)
	100	return ret;
	101	}
	102
	103	return 0;
	104	}
	105	EXPORT_SYMBOL_GPL(iomap_fiemap);
	106
	107	static loff_t
	108	iomap_bmap_actor(struct inode *inode, loff_t pos, loff_t length,
c039b997	109	void data, struct iomap iomap, struct iomap *srcmap)
5157fb8f DW	110	{
	111	sector_t *bno = data, addr;
	112
	113	if (iomap->type == IOMAP_MAPPED) {
	114	addr = (pos - iomap->offset + iomap->addr) >> inode->i_blkbits;
b75dfde1	115	*bno = addr;
5157fb8f DW	116	}
	117	return 0;
	118	}
	119
	120	/* legacy ->bmap interface. 0 is the error return (!) */
	121	sector_t
	122	iomap_bmap(struct address_space *mapping, sector_t bno,
	123	const struct iomap_ops *ops)
	124	{
	125	struct inode *inode = mapping->host;
	126	loff_t pos = bno << inode->i_blkbits;
	127	unsigned blocksize = i_blocksize(inode);
2b91b28e	128	int ret;
5157fb8f DW	129
	130	if (filemap_write_and_wait(mapping))
	131	return 0;
	132
	133	bno = 0;
2b91b28e DW	134	ret = iomap_apply(inode, pos, blocksize, 0, ops, &bno,
	135	iomap_bmap_actor);
	136	if (ret)
	137	return 0;
5157fb8f DW	138	return bno;
	139	}
	140	EXPORT_SYMBOL_GPL(iomap_bmap);