Re: [Qemu-devel] [PATCH v3] block/gluster: add support for SEEK_DATA/SEEK_HOLE

[Jeff Cody <jcody@redhat.com>]

On Tue, Mar 15, 2016 at 03:50:17PM -0400, Jeff Cody wrote:
> On Thu, Mar 10, 2016 at 07:38:00PM +0100, Niels de Vos wrote:
> > GlusterFS 3.8 contains support for SEEK_DATA and SEEK_HOLE. This makes
> > it possible to detect sparse areas in files.
> > 
> > Signed-off-by: Niels de Vos <ndevos@redhat.com>
> > 
> > ---
> > Tested by compiling and running "qemu-img map gluster://..." with a
> > build of the current master branch of glusterfs. Using a Fedora cloud
> > image (in raw format) shows many SEEK procudure calls going back and
> > forth over the network. The output of "qemu map" matches the output when
> > run against the image on the local filesystem.
> > 
> > v2 based on feedback from Jeff Cody:
> > - Replace compile time detection by runtime detection
> > - Update return pointer (new argument) for .bdrv_co_get_block_status
> > ---
> >  block/gluster.c | 182 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> >  1 file changed, 182 insertions(+)
> > 
> > diff --git a/block/gluster.c b/block/gluster.c
> > index 65077a0..a4f0628 100644
> > --- a/block/gluster.c
> > +++ b/block/gluster.c
> > @@ -23,6 +23,7 @@ typedef struct GlusterAIOCB {
> >  typedef struct BDRVGlusterState {
> >      struct glfs *glfs;
> >      struct glfs_fd *fd;
> > +    bool supports_seek_data;
> >  } BDRVGlusterState;
> >  
> >  typedef struct GlusterConf {
> > @@ -286,6 +287,28 @@ static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags)
> >      }
> >  }
> >  
> > +/*
> > + * Do SEEK_DATA/HOLE to detect if it is functional. Older broken versions of
> > + * gfapi incorrectly return the current offset when SEEK_DATA/HOLE is used.
> > + * - Corrected versions return -1 and set errno to EINVAL.
> > + * - Versions that support SEEK_DATA/HOLE correctly, will return -1 and set
> > + *   errno to ENXIO when SEEK_DATA is called with a position of EOF.
> > + */
> > +static bool qemu_gluster_test_seek(struct glfs_fd *fd)
> > +{
> > +    off_t ret, eof;
> > +
> > +    eof = glfs_lseek(fd, 0, SEEK_END);
> > +    if (eof < 0) {
> > +        /* this should never occur */
> > +        return false;
> > +    }
> > +
> > +    /* this should always fail with ENXIO if SEEK_DATA is supported */
> > +    ret = glfs_lseek(fd, eof, SEEK_DATA);
> > +    return (ret < 0) && (errno == ENXIO);
> > +}
> > +
> >  static int qemu_gluster_open(BlockDriverState *bs,  QDict *options,
> >                               int bdrv_flags, Error **errp)
> >  {
> > @@ -320,6 +343,8 @@ static int qemu_gluster_open(BlockDriverState *bs,  QDict *options,
> >          ret = -errno;
> >      }
> >  
> > +    s->supports_seek_data = qemu_gluster_test_seek(s->fd);
> > +
> >  out:
> >      qemu_opts_del(opts);
> >      qemu_gluster_gconf_free(gconf);
> > @@ -677,6 +702,159 @@ static int qemu_gluster_has_zero_init(BlockDriverState *bs)
> >      return 0;
> >  }
> >  
> > +/*
> > + * Find allocation range in @bs around offset @start.
> > + * May change underlying file descriptor's file offset.
> > + * If @start is not in a hole, store @start in @data, and the
> > + * beginning of the next hole in @hole, and return 0.
> > + * If @start is in a non-trailing hole, store @start in @hole and the
> > + * beginning of the next non-hole in @data, and return 0.
> > + * If @start is in a trailing hole or beyond EOF, return -ENXIO.
> > + * If we can't find out, return a negative errno other than -ENXIO.
> > + *
> > + * (Shamefully copied from raw-posix.c, only miniscule adaptions.)
> > + */
> > +static int find_allocation(BlockDriverState *bs, off_t start,
> > +                           off_t *data, off_t *hole)
> > +{
> > +    BDRVGlusterState *s = bs->opaque;
> > +    off_t offs;
> > +
> > +    if (!s->supports_seek_data) {
> > +        return -ENOTSUP;
> > +    }
> > +
> > +    /*
> > +     * SEEK_DATA cases:
> > +     * D1. offs == start: start is in data
> > +     * D2. offs > start: start is in a hole, next data at offs
> > +     * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
> > +     *                              or start is beyond EOF
> > +     *     If the latter happens, the file has been truncated behind
> > +     *     our back since we opened it.  All bets are off then.
> > +     *     Treating like a trailing hole is simplest.
> > +     * D4. offs < 0, errno != ENXIO: we learned nothing
> > +     */
> > +    offs = glfs_lseek(s->fd, start, SEEK_DATA);
> > +    if (offs < 0) {
> > +        return -errno;          /* D3 or D4 */
> > +    }
> > +    assert(offs >= start);
> > +
> > +    if (offs > start) {
> > +        /* D2: in hole, next data at offs */
> > +        *hole = start;
> > +        *data = offs;
> > +        return 0;
> > +    }
> > +
> > +    /* D1: in data, end not yet known */
> > +
> > +    /*
> > +     * SEEK_HOLE cases:
> > +     * H1. offs == start: start is in a hole
> > +     *     If this happens here, a hole has been dug behind our back
> > +     *     since the previous lseek().
> > +     * H2. offs > start: either start is in data, next hole at offs,
> > +     *                   or start is in trailing hole, EOF at offs
> > +     *     Linux treats trailing holes like any other hole: offs ==
> > +     *     start.  Solaris seeks to EOF instead: offs > start (blech).
> > +     *     If that happens here, a hole has been dug behind our back
> > +     *     since the previous lseek().
> > +     * H3. offs < 0, errno = ENXIO: start is beyond EOF
> > +     *     If this happens, the file has been truncated behind our
> > +     *     back since we opened it.  Treat it like a trailing hole.
> > +     * H4. offs < 0, errno != ENXIO: we learned nothing
> > +     *     Pretend we know nothing at all, i.e. "forget" about D1.
> > +     */
> > +    offs = glfs_lseek(s->fd, start, SEEK_HOLE);
> > +    if (offs < 0) {
> > +        return -errno;          /* D1 and (H3 or H4) */
> > +    }
> > +    assert(offs >= start);
> > +
> > +    if (offs > start) {
> > +        /*
> > +         * D1 and H2: either in data, next hole at offs, or it was in
> > +         * data but is now in a trailing hole.  In the latter case,
> > +         * all bets are off.  Treating it as if it there was data all
> > +         * the way to EOF is safe, so simply do that.
> > +         */
> > +        *data = start;
> > +        *hole = offs;
> > +        return 0;
> > +    }
> > +
> > +    /* D1 and H1 */
> > +    return -EBUSY;
> > +}
> > +
> > +/*
> > + * Returns the allocation status of the specified sectors.
> > + *
> > + * If 'sector_num' is beyond the end of the disk image the return value is 0
> > + * and 'pnum' is set to 0.
> > + *
> > + * 'pnum' is set to the number of sectors (including and immediately following
> > + * the specified sector) that are known to be in the same
> > + * allocated/unallocated state.
> > + *
> > + * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
> > + * beyond the end of the disk image it will be clamped.
> > + *
> > + * (Based on raw_co_get_block_status() from raw-posix.c.)
> > + */
> > +static int64_t coroutine_fn qemu_gluster_co_get_block_status(
> > +        BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum,
> > +        BlockDriverState **file)
> > +{
> > +    BDRVGlusterState *s = bs->opaque;
> > +    off_t start, data = 0, hole = 0;
> > +    int64_t total_size;
> > +    int ret = -EINVAL;
> > +
> > +    if (!s->fd) {
> > +        return ret;
> > +    }
> > +
> > +    start = sector_num * BDRV_SECTOR_SIZE;
> > +    total_size = bdrv_getlength(bs);
> > +    if (total_size < 0) {
> > +        return total_size;
> > +    } else if (start >= total_size) {
> > +        *pnum = 0;
> > +        return 0;
> > +    } else if (start + nb_sectors * BDRV_SECTOR_SIZE > total_size) {
> > +        nb_sectors = DIV_ROUND_UP(total_size - start, BDRV_SECTOR_SIZE);
> > +    }
> > +
> > +    ret = find_allocation(bs, start, &data, &hole);
> > +    if (ret == -ENXIO) {
> > +        /* Trailing hole */
> > +        *pnum = nb_sectors;
> > +        ret = BDRV_BLOCK_ZERO;
> > +    } else if (ret < 0) {
> > +        /* No info available, so pretend there are no holes */
> > +        *pnum = nb_sectors;
> > +        ret = BDRV_BLOCK_DATA;
> > +    } else if (data == start) {
> > +        /* On a data extent, compute sectors to the end of the extent,
> > +         * possibly including a partial sector at EOF. */
> > +        *pnum = MIN(nb_sectors, DIV_ROUND_UP(hole - start, BDRV_SECTOR_SIZE));
> > +        ret = BDRV_BLOCK_DATA;
> > +    } else {
> > +        /* On a hole, compute sectors to the beginning of the next extent.  */
> > +        assert(hole == start);
> > +        *pnum = MIN(nb_sectors, (data - start) / BDRV_SECTOR_SIZE);
> > +        ret = BDRV_BLOCK_ZERO;
> > +    }
> > +
> > +    *file = bs;
> > +
> > +    return ret | BDRV_BLOCK_OFFSET_VALID | start;
> > +}
> > +
> > +
> >  static QemuOptsList qemu_gluster_create_opts = {
> >      .name = "qemu-gluster-create-opts",
> >      .head = QTAILQ_HEAD_INITIALIZER(qemu_gluster_create_opts.head),
> > @@ -719,6 +897,7 @@ static BlockDriver bdrv_gluster = {
> >  #ifdef CONFIG_GLUSTERFS_ZEROFILL
> >      .bdrv_co_write_zeroes         = qemu_gluster_co_write_zeroes,
> >  #endif
> > +    .bdrv_co_get_block_status     = qemu_gluster_co_get_block_status,
> >      .create_opts                  = &qemu_gluster_create_opts,
> >  };
> >  
> > @@ -746,6 +925,7 @@ static BlockDriver bdrv_gluster_tcp = {
> >  #ifdef CONFIG_GLUSTERFS_ZEROFILL
> >      .bdrv_co_write_zeroes         = qemu_gluster_co_write_zeroes,
> >  #endif
> > +    .bdrv_co_get_block_status     = qemu_gluster_co_get_block_status,
> >      .create_opts                  = &qemu_gluster_create_opts,
> >  };
> >  
> > @@ -773,6 +953,7 @@ static BlockDriver bdrv_gluster_unix = {
> >  #ifdef CONFIG_GLUSTERFS_ZEROFILL
> >      .bdrv_co_write_zeroes         = qemu_gluster_co_write_zeroes,
> >  #endif
> > +    .bdrv_co_get_block_status     = qemu_gluster_co_get_block_status,
> >      .create_opts                  = &qemu_gluster_create_opts,
> >  };
> >  
> > @@ -800,6 +981,7 @@ static BlockDriver bdrv_gluster_rdma = {
> >  #ifdef CONFIG_GLUSTERFS_ZEROFILL
> >      .bdrv_co_write_zeroes         = qemu_gluster_co_write_zeroes,
> >  #endif
> > +    .bdrv_co_get_block_status     = qemu_gluster_co_get_block_status,
> >      .create_opts                  = &qemu_gluster_create_opts,
> >  };
> >  
> > -- 
> > 2.5.0
> > 
> 
> Thanks,
> 
> Applied to my block branch:
> 
> git://github.com/codyprime/qemu-kvm-jtc.git block


Correction: block-next (for 2.7), not block (for 2.6)

> 
> -Jeff