[linux-2.6-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 "../internal.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 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,
		loff_t start, loff_t 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_check_flags(fi, FIEMAP_FLAG_SYNC);
	if (ret)
		return ret;

	if (fi->fi_flags & FIEMAP_FLAG_SYNC) {
		ret = filemap_write_and_wait(inode->i_mapping);
		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)
{
	sector_t *bno = data, addr;

	if (iomap->type == IOMAP_MAPPED) {
		addr = (pos - iomap->offset + iomap->addr) >> inode->i_blkbits;
		if (addr > INT_MAX)
			WARN(1, "would truncate bmap result\n");
		else
			*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);

	if (filemap_write_and_wait(mapping))
		return 0;

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