Commit 9514f264 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/gkurz/tags/for-upstream' into staging 



This pull request brings:
- a fix to a minor bug reported by Coverity
- throttling support in the local backend (command line only)

# gpg: Signature made Tue 28 Feb 2017 09:32:30 GMT
# gpg:                using DSA key 0x02FC3AEB0101DBC2
# gpg: Good signature from "Greg Kurz <groug@kaod.org>"
# gpg:                 aka "Greg Kurz <groug@free.fr>"
# gpg:                 aka "Greg Kurz <gkurz@linux.vnet.ibm.com>"
# gpg:                 aka "Gregory Kurz (Groug) <groug@free.fr>"
# gpg:                 aka "[jpeg image of size 3330]"
# gpg: WARNING: This key is not certified with a trusted signature!
# gpg:          There is no indication that the signature belongs to the owner.
# Primary key fingerprint: 2BD4 3B44 535E C0A7 9894  DBA2 02FC 3AEB 0101 DBC2

* remotes/gkurz/tags/for-upstream:
  throttle: factor out duplicate code
  fsdev: add IO throttle support to fsdev devices
  9pfs: fix v9fs_lock error case

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 7d1730b7 a2a7862c

blockdev.c

+6 −77
Original line number Diff line number Diff line
@@ -52,6 +52,7 @@ 
#include "sysemu/arch_init.h"

#include "qemu/cutils.h"

#include "qemu/help_option.h"

#include "qemu/throttle-options.h"



static QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states =

    QTAILQ_HEAD_INITIALIZER(monitor_bdrv_states);
@@ -4007,83 +4008,11 @@ QemuOptsList qemu_common_drive_opts = { 
            .name = BDRV_OPT_READ_ONLY,

            .type = QEMU_OPT_BOOL,

            .help = "open drive file as read-only",

        },{

            .name = "throttling.iops-total",

            .type = QEMU_OPT_NUMBER,

            .help = "limit total I/O operations per second",

        },{

            .name = "throttling.iops-read",

            .type = QEMU_OPT_NUMBER,

            .help = "limit read operations per second",

        },{

            .name = "throttling.iops-write",

            .type = QEMU_OPT_NUMBER,

            .help = "limit write operations per second",

        },{

            .name = "throttling.bps-total",

            .type = QEMU_OPT_NUMBER,

            .help = "limit total bytes per second",

        },{

            .name = "throttling.bps-read",

            .type = QEMU_OPT_NUMBER,

            .help = "limit read bytes per second",

        },{

            .name = "throttling.bps-write",

            .type = QEMU_OPT_NUMBER,

            .help = "limit write bytes per second",

        },{

            .name = "throttling.iops-total-max",

            .type = QEMU_OPT_NUMBER,

            .help = "I/O operations burst",

        },{

            .name = "throttling.iops-read-max",

            .type = QEMU_OPT_NUMBER,

            .help = "I/O operations read burst",

        },{

            .name = "throttling.iops-write-max",

            .type = QEMU_OPT_NUMBER,

            .help = "I/O operations write burst",

        },{

            .name = "throttling.bps-total-max",

            .type = QEMU_OPT_NUMBER,

            .help = "total bytes burst",

        },{

            .name = "throttling.bps-read-max",

            .type = QEMU_OPT_NUMBER,

            .help = "total bytes read burst",

        },{

            .name = "throttling.bps-write-max",

            .type = QEMU_OPT_NUMBER,

            .help = "total bytes write burst",

        },{

            .name = "throttling.iops-total-max-length",

            .type = QEMU_OPT_NUMBER,

            .help = "length of the iops-total-max burst period, in seconds",

        },{

            .name = "throttling.iops-read-max-length",

            .type = QEMU_OPT_NUMBER,

            .help = "length of the iops-read-max burst period, in seconds",

        },{

            .name = "throttling.iops-write-max-length",

            .type = QEMU_OPT_NUMBER,

            .help = "length of the iops-write-max burst period, in seconds",

        },{

            .name = "throttling.bps-total-max-length",

            .type = QEMU_OPT_NUMBER,

            .help = "length of the bps-total-max burst period, in seconds",

        },{

            .name = "throttling.bps-read-max-length",

            .type = QEMU_OPT_NUMBER,

            .help = "length of the bps-read-max burst period, in seconds",

        },{

            .name = "throttling.bps-write-max-length",

            .type = QEMU_OPT_NUMBER,

            .help = "length of the bps-write-max burst period, in seconds",

        },{

            .name = "throttling.iops-size",

            .type = QEMU_OPT_NUMBER,

            .help = "when limiting by iops max size of an I/O in bytes",

        },{

        },



        THROTTLE_OPTS,



        {

            .name = "throttling.group",

            .type = QEMU_OPT_STRING,

            .help = "name of the block throttling group",

fsdev/Makefile.objs

+1 −1
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ common-obj-y = qemu-fsdev.o 9p-marshal.o 9p-iov-marshal.o 
else

common-obj-y = qemu-fsdev-dummy.o

endif

common-obj-y += qemu-fsdev-opts.o

common-obj-y += qemu-fsdev-opts.o qemu-fsdev-throttle.o



# Toplevel always builds this; targets without virtio will put it in

# common-obj-y

fsdev/file-op-9p.h

+3 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include <dirent.h>

#include <utime.h>

#include <sys/vfs.h>

#include "qemu-fsdev-throttle.h"



#define SM_LOCAL_MODE_BITS    0600

#define SM_LOCAL_DIR_MODE_BITS    0700
@@ -74,6 +75,7 @@ typedef struct FsDriverEntry { 
    char *path;

    int export_flags;

    FileOperations *ops;

    FsThrottle fst;

} FsDriverEntry;



typedef struct FsContext
@@ -83,6 +85,7 @@ typedef struct FsContext 
    int export_flags;

    struct xattr_operations **xops;

    struct extended_ops exops;

    FsThrottle *fst;

    /* fs driver specific data */

    void *private;

} FsContext;

fsdev/qemu-fsdev-opts.c

+3 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ 
#include "qemu/config-file.h"

#include "qemu/option.h"

#include "qemu/module.h"

#include "qemu/throttle-options.h"



static QemuOptsList qemu_fsdev_opts = {

    .name = "fsdev",
@@ -39,6 +40,8 @@ static QemuOptsList qemu_fsdev_opts = { 
            .type = QEMU_OPT_NUMBER,

        },



        THROTTLE_OPTS,



        { /*End of list */ }

    },

};

fsdev/qemu-fsdev-throttle.c

0 → 100644
+118 −0
Original line number Diff line number Diff line 
/*

 * Fsdev Throttle

 *

 * Copyright (C) 2016 Huawei Technologies Duesseldorf GmbH

 *

 * Author: Pradeep Jagadeesh <pradeep.jagadeesh@huawei.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or

 * (at your option) any later version.

 *

 * See the COPYING file in the top-level directory for details.

 *

 */



#include "qemu/osdep.h"

#include "qemu/error-report.h"

#include "qemu-fsdev-throttle.h"

#include "qemu/iov.h"



static void fsdev_throttle_read_timer_cb(void *opaque)

{

    FsThrottle *fst = opaque;

    qemu_co_enter_next(&fst->throttled_reqs[false]);

}



static void fsdev_throttle_write_timer_cb(void *opaque)

{

    FsThrottle *fst = opaque;

    qemu_co_enter_next(&fst->throttled_reqs[true]);

}



void fsdev_throttle_parse_opts(QemuOpts *opts, FsThrottle *fst, Error **errp)

{

    throttle_config_init(&fst->cfg);

    fst->cfg.buckets[THROTTLE_BPS_TOTAL].avg =

        qemu_opt_get_number(opts, "throttling.bps-total", 0);

    fst->cfg.buckets[THROTTLE_BPS_READ].avg  =

        qemu_opt_get_number(opts, "throttling.bps-read", 0);

    fst->cfg.buckets[THROTTLE_BPS_WRITE].avg =

        qemu_opt_get_number(opts, "throttling.bps-write", 0);

    fst->cfg.buckets[THROTTLE_OPS_TOTAL].avg =

        qemu_opt_get_number(opts, "throttling.iops-total", 0);

    fst->cfg.buckets[THROTTLE_OPS_READ].avg =

        qemu_opt_get_number(opts, "throttling.iops-read", 0);

    fst->cfg.buckets[THROTTLE_OPS_WRITE].avg =

        qemu_opt_get_number(opts, "throttling.iops-write", 0);



    fst->cfg.buckets[THROTTLE_BPS_TOTAL].max =

        qemu_opt_get_number(opts, "throttling.bps-total-max", 0);

    fst->cfg.buckets[THROTTLE_BPS_READ].max  =

        qemu_opt_get_number(opts, "throttling.bps-read-max", 0);

    fst->cfg.buckets[THROTTLE_BPS_WRITE].max =

        qemu_opt_get_number(opts, "throttling.bps-write-max", 0);

    fst->cfg.buckets[THROTTLE_OPS_TOTAL].max =

        qemu_opt_get_number(opts, "throttling.iops-total-max", 0);

    fst->cfg.buckets[THROTTLE_OPS_READ].max =

        qemu_opt_get_number(opts, "throttling.iops-read-max", 0);

    fst->cfg.buckets[THROTTLE_OPS_WRITE].max =

        qemu_opt_get_number(opts, "throttling.iops-write-max", 0);



    fst->cfg.buckets[THROTTLE_BPS_TOTAL].burst_length =

        qemu_opt_get_number(opts, "throttling.bps-total-max-length", 1);

    fst->cfg.buckets[THROTTLE_BPS_READ].burst_length  =

        qemu_opt_get_number(opts, "throttling.bps-read-max-length", 1);

    fst->cfg.buckets[THROTTLE_BPS_WRITE].burst_length =

        qemu_opt_get_number(opts, "throttling.bps-write-max-length", 1);

    fst->cfg.buckets[THROTTLE_OPS_TOTAL].burst_length =

        qemu_opt_get_number(opts, "throttling.iops-total-max-length", 1);

    fst->cfg.buckets[THROTTLE_OPS_READ].burst_length =

        qemu_opt_get_number(opts, "throttling.iops-read-max-length", 1);

    fst->cfg.buckets[THROTTLE_OPS_WRITE].burst_length =

        qemu_opt_get_number(opts, "throttling.iops-write-max-length", 1);

    fst->cfg.op_size =

        qemu_opt_get_number(opts, "throttling.iops-size", 0);



    throttle_is_valid(&fst->cfg, errp);

}



void fsdev_throttle_init(FsThrottle *fst)

{

    if (throttle_enabled(&fst->cfg)) {

        throttle_init(&fst->ts);

        throttle_timers_init(&fst->tt,

                             qemu_get_aio_context(),

                             QEMU_CLOCK_REALTIME,

                             fsdev_throttle_read_timer_cb,

                             fsdev_throttle_write_timer_cb,

                             fst);

        throttle_config(&fst->ts, &fst->tt, &fst->cfg);

        qemu_co_queue_init(&fst->throttled_reqs[0]);

        qemu_co_queue_init(&fst->throttled_reqs[1]);

    }

}



void coroutine_fn fsdev_co_throttle_request(FsThrottle *fst, bool is_write,

                                            struct iovec *iov, int iovcnt)

{

    if (throttle_enabled(&fst->cfg)) {

        if (throttle_schedule_timer(&fst->ts, &fst->tt, is_write) ||

            !qemu_co_queue_empty(&fst->throttled_reqs[is_write])) {

            qemu_co_queue_wait(&fst->throttled_reqs[is_write], NULL);

        }



        throttle_account(&fst->ts, is_write, iov_size(iov, iovcnt));



        if (!qemu_co_queue_empty(&fst->throttled_reqs[is_write]) &&

            !throttle_schedule_timer(&fst->ts, &fst->tt, is_write)) {

            qemu_co_queue_next(&fst->throttled_reqs[is_write]);

        }

    }

}



void fsdev_throttle_cleanup(FsThrottle *fst)

{

    if (throttle_enabled(&fst->cfg)) {

        throttle_timers_destroy(&fst->tt);

    }

}