fs/iomap/iter.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2010 Red Hat, Inc.
   4  * Copyright (c) 2016-2021 Christoph Hellwig.
   5  */
   6 #include <linux/fs.h>
   7 #include <linux/iomap.h>
   8 #include "trace.h"
   9
  10 /*
  11  * Advance to the next range we need to map.
  12  *
  13  * If the iomap is marked IOMAP_F_STALE, it means the existing map was not fully
  14  * processed - it was aborted because the extent the iomap spanned may have been
  15  * changed during the operation. In this case, the iteration behaviour is to
  16  * remap the unprocessed range of the iter, and that means we may need to remap
  17  * even when we've made no progress (i.e. iter->processed = 0). Hence the
  18  * "finished iterating" case needs to distinguish between
  19  * (processed = 0) meaning we are done and (processed = 0 && stale) meaning we
  20  * need to remap the entire remaining range.
  21  */
  22 static inline int iomap_iter_advance(struct iomap_iter *iter)
  23 {
  24         bool stale = iter->iomap.flags & IOMAP_F_STALE;
  25
  26         /* handle the previous iteration (if any) */
  27         if (iter->iomap.length) {
  28                 if (iter->processed < 0)
  29                         return iter->processed;
  30                 if (!iter->processed && !stale)
  31                         return 0;
  32                 if (WARN_ON_ONCE(iter->processed > iomap_length(iter)))
  33                         return -EIO;
  34                 iter->pos += iter->processed;
  35                 iter->len -= iter->processed;
  36                 if (!iter->len)
  37                         return 0;
  38         }
  39
  40         /* clear the state for the next iteration */
  41         iter->processed = 0;
  42         memset(&iter->iomap, 0, sizeof(iter->iomap));
  43         memset(&iter->srcmap, 0, sizeof(iter->srcmap));
  44         return 1;
  45 }
  46
  47 static inline void iomap_iter_done(struct iomap_iter *iter)
  48 {
  49         WARN_ON_ONCE(iter->iomap.offset > iter->pos);
  50         WARN_ON_ONCE(iter->iomap.length == 0);
  51         WARN_ON_ONCE(iter->iomap.offset + iter->iomap.length <= iter->pos);
  52         WARN_ON_ONCE(iter->iomap.flags & IOMAP_F_STALE);
  53
  54         trace_iomap_iter_dstmap(iter->inode, &iter->iomap);
  55         if (iter->srcmap.type != IOMAP_HOLE)
  56                 trace_iomap_iter_srcmap(iter->inode, &iter->srcmap);
  57 }
  58
  59 /**
  60  * iomap_iter - iterate over a ranges in a file
  61  * @iter: iteration structue
  62  * @ops: iomap ops provided by the file system
  63  *
  64  * Iterate over filesystem-provided space mappings for the provided file range.
  65  *
  66  * This function handles cleanup of resources acquired for iteration when the
  67  * filesystem indicates there are no more space mappings, which means that this
  68  * function must be called in a loop that continues as long it returns a
  69  * positive value.  If 0 or a negative value is returned, the caller must not
  70  * return to the loop body.  Within a loop body, there are two ways to break out
  71  * of the loop body:  leave @iter.processed unchanged, or set it to a negative
  72  * errno.
  73  */
  74 int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops)
  75 {
  76         int ret;
  77
  78         if (iter->iomap.length && ops->iomap_end) {
  79                 ret = ops->iomap_end(iter->inode, iter->pos, iomap_length(iter),
  80                                 iter->processed > 0 ? iter->processed : 0,
  81                                 iter->flags, &iter->iomap);
  82                 if (ret < 0 && !iter->processed)
  83                         return ret;
  84         }
  85
  86         trace_iomap_iter(iter, ops, _RET_IP_);
  87         ret = iomap_iter_advance(iter);
  88         if (ret <= 0)
  89                 return ret;
  90
  91         ret = ops->iomap_begin(iter->inode, iter->pos, iter->len, iter->flags,
  92                                &iter->iomap, &iter->srcmap);
  93         if (ret < 0)
  94                 return ret;
  95         iomap_iter_done(iter);
  96         return 1;
  97 }