98 lines
3.1 KiB
C
98 lines
3.1 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2010 Red Hat, Inc.
|
|
* Copyright (c) 2016-2021 Christoph Hellwig.
|
|
*/
|
|
#include <linux/fs.h>
|
|
#include <linux/iomap.h>
|
|
#include "trace.h"
|
|
|
|
/*
|
|
* Advance to the next range we need to map.
|
|
*
|
|
* If the iomap is marked IOMAP_F_STALE, it means the existing map was not fully
|
|
* processed - it was aborted because the extent the iomap spanned may have been
|
|
* changed during the operation. In this case, the iteration behaviour is to
|
|
* remap the unprocessed range of the iter, and that means we may need to remap
|
|
* even when we've made no progress (i.e. iter->processed = 0). Hence the
|
|
* "finished iterating" case needs to distinguish between
|
|
* (processed = 0) meaning we are done and (processed = 0 && stale) meaning we
|
|
* need to remap the entire remaining range.
|
|
*/
|
|
static inline int iomap_iter_advance(struct iomap_iter *iter)
|
|
{
|
|
bool stale = iter->iomap.flags & IOMAP_F_STALE;
|
|
|
|
/* handle the previous iteration (if any) */
|
|
if (iter->iomap.length) {
|
|
if (iter->processed < 0)
|
|
return iter->processed;
|
|
if (!iter->processed && !stale)
|
|
return 0;
|
|
if (WARN_ON_ONCE(iter->processed > iomap_length(iter)))
|
|
return -EIO;
|
|
iter->pos += iter->processed;
|
|
iter->len -= iter->processed;
|
|
if (!iter->len)
|
|
return 0;
|
|
}
|
|
|
|
/* clear the state for the next iteration */
|
|
iter->processed = 0;
|
|
memset(&iter->iomap, 0, sizeof(iter->iomap));
|
|
memset(&iter->srcmap, 0, sizeof(iter->srcmap));
|
|
return 1;
|
|
}
|
|
|
|
static inline void iomap_iter_done(struct iomap_iter *iter)
|
|
{
|
|
WARN_ON_ONCE(iter->iomap.offset > iter->pos);
|
|
WARN_ON_ONCE(iter->iomap.length == 0);
|
|
WARN_ON_ONCE(iter->iomap.offset + iter->iomap.length <= iter->pos);
|
|
WARN_ON_ONCE(iter->iomap.flags & IOMAP_F_STALE);
|
|
|
|
trace_iomap_iter_dstmap(iter->inode, &iter->iomap);
|
|
if (iter->srcmap.type != IOMAP_HOLE)
|
|
trace_iomap_iter_srcmap(iter->inode, &iter->srcmap);
|
|
}
|
|
|
|
/**
|
|
* iomap_iter - iterate over a ranges in a file
|
|
* @iter: iteration structue
|
|
* @ops: iomap ops provided by the file system
|
|
*
|
|
* Iterate over filesystem-provided space mappings for the provided file range.
|
|
*
|
|
* This function handles cleanup of resources acquired for iteration when the
|
|
* filesystem indicates there are no more space mappings, which means that this
|
|
* function must be called in a loop that continues as long it returns a
|
|
* positive value. If 0 or a negative value is returned, the caller must not
|
|
* return to the loop body. Within a loop body, there are two ways to break out
|
|
* of the loop body: leave @iter.processed unchanged, or set it to a negative
|
|
* errno.
|
|
*/
|
|
int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops)
|
|
{
|
|
int ret;
|
|
|
|
if (iter->iomap.length && ops->iomap_end) {
|
|
ret = ops->iomap_end(iter->inode, iter->pos, iomap_length(iter),
|
|
iter->processed > 0 ? iter->processed : 0,
|
|
iter->flags, &iter->iomap);
|
|
if (ret < 0 && !iter->processed)
|
|
return ret;
|
|
}
|
|
|
|
trace_iomap_iter(iter, ops, _RET_IP_);
|
|
ret = iomap_iter_advance(iter);
|
|
if (ret <= 0)
|
|
return ret;
|
|
|
|
ret = ops->iomap_begin(iter->inode, iter->pos, iter->len, iter->flags,
|
|
&iter->iomap, &iter->srcmap);
|
|
if (ret < 0)
|
|
return ret;
|
|
iomap_iter_done(iter);
|
|
return 1;
|
|
}
|