block: add logging facility for long standing IO requests
v2 cover block: add logging facility for long standing IO requests
There are severe delays with IO requests processing if QEMU is running in virtual machine or over software defined storage. Such delays potentially results in unpredictable guest behavior. For example, guests over IDE or SATA drive could remount filesystem read-only if write is performed longer than 10 seconds.
Such reports are very complex to process. Some good starting point for this seems quite reasonable. This patch provides one. It adds logging of such potentially dangerous long IO operations.
Changed from v2:
- removed accidentally added slirp subproject ID
- added comment describing timeout selection to patch 3
Changes from v1:
- fixed conversions using macros suggested by Stefan
- fixed option declaration
- enabled by default with patch 3
PATCH v2 1/3 block/block-backend: add converter from BlockAcctStats to BlockBackend
Right now BlockAcctStats is always reside on BlockBackend. This structure is not used in any other place. Thus we are able to create a converter from one pointer to another.
--- block/block-backend.c | 5 +++++ include/sysemu/block-backend.h | 1 + 2 files changed, 6 insertions(+)
block/block-backend.c +5 -0
@@ -2153,6 +2153,11 @@ BlockAcctStats *blk_get_stats(BlockBackend *blk)return &blk->stats; } +BlockBackend *blk_stats2blk (BlockAcctStats *s) +{ +return container_of (s, BlockBackend, stats); +} +void *blk_aio_get (const AIOCBInfo *aiocb_info,BlockBackend *blk,BlockCompletionFunc *cb,void *opaque) {
include/sysemu/block-backend.h +1 -0
@@ -227,6 +227,7 @@ void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify);void blk_io_plug (BlockBackend *blk);void blk_io_unplug (BlockBackend *blk);BlockAcctStats *blk_get_stats (BlockBackend *blk); +BlockBackend *blk_stats2blk (BlockAcctStats *stats);BlockBackendRootState *blk_get_root_state (BlockBackend *blk);void blk_update_root_state (BlockBackend *blk);bool blk_get_detect_zeroes_from_root_state (BlockBackend *blk);
Signature · 1 line
2.17.1
Re: [PATCH 1/3] block/block-backend: add converter from BlockAcctStats to BlockBackend
Quoted 9 lines · Denis V. Lunev
Right now BlockAcctStats is always reside on BlockBackend. This structure is not used in any other place. Thus we are able to create a converter from one pointer to another.
Signed-off-by Denis V. Lunev <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>CC Stefan Hajnoczi <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>
Quoted 4 lines
--- block/block-backend.c | 5 +++++ include/sysemu/block-backend.h | 1 + 2 files changed, 6 insertions(+)
(Note: I’m just writing this mail because I already responded to patch
2. I wouldn’t have if I didn’t have anything to say regarding the other patches in this series, so nothing I say here is backed by a strong opinion from me.)
block/block-backend.c BlockAcctStats *blk_get_stats(BlockBackend *blk) · line 2156
Quoted 9 lines
block/block-backend.c +1
-0@@ -2153,6 +2153,11 @@ BlockAcctStats *blk_get_stats(BlockBackend *blk)return &blk->stats; } +BlockBackend *blk_stats2blk (BlockAcctStats *s)
(Extreme bikeshedding: I’d prefer something like blk_from_stats().)
block/block-backend.c BlockAcctStats *blk_get_stats(BlockBackend *blk) · line 2159
Quoted 3 lines
block/block-backend.c +3
-0+{ +return container_of (s, BlockBackend, stats); +}
Works, but I get all itchy, especially given the reasoning in the commit message, which is basically “Right now this works”.
That sounds to me like maybe in the future someone could get the idea of moving BlockAcctStats somewhere else and then this is something that we absolutely must not forget about, lest horrible accidents occur.
Would a back pointer from BlockAcctStats to the BlockBackend work or do you find that just too ugly and unnecessary? (I think it would help at least so that we do not forget this place here.)
Or maybe just a comment above BlockAcctStats would help quench my itch, too, like “Note: blk_stats2blk() expects objects of this type only to occur as part of a BlockBackend”.
Max
PATCH v2 2/3 block: add logging facility for long standing IO requests
In reply to Denis V. LunevThere are severe delays with IO requests processing if QEMU is running in virtual machine or over software defined storage. Such delays potentially results in unpredictable guest behavior. For example, guests over IDE or SATA drive could remount filesystem read-only if write is performed longer than 10 seconds.
Such reports are very complex to process. Some good starting point for this seems quite reasonable. This patch provides one. It adds logging of such potentially dangerous long IO operations.
--- block/accounting.c | 59 +++++++++++++++++++++++++++++++++++++- blockdev.c | 7 ++++- include/block/accounting.h | 5 +++- 3 files changed, 68 insertions(+), 3 deletions(-)
block/accounting.c +58 -1
@@ -27,7 +27,9 @@#include "block/accounting.h" #include "block/block_int.h" #include "qemu/timer.h" +#include "qemu/log.h" #include "sysemu/qtest.h" +#include "sysemu/block-backend.h" static QEMUClockType clock_type =QEMU_CLOCK_REALTIME ;static const int qtest_latency_ns =NANOSECONDS_PER_SECOND /1000 ;
@@ -41,10 +43,11 @@ void block_acct_init(BlockAcctStats *stats) }void block_acct_setup (BlockAcctStats *stats,bool account_invalid, -bool account_failed) +bool account_failed,unsigned latency_log_threshold_ms) { stats->account_invalid = account_invalid; stats->account_failed = account_failed; + stats->latency_log_threshold_ms = latency_log_threshold_ms; }void block_acct_cleanup (BlockAcctStats *stats)
@@ -182,6 +185,58 @@ void block_latency_histograms_clear(BlockAcctStats *stats) } } +static const char *block_account_type (enum BlockAcctType type) +{ +switch (type) { +case BLOCK_ACCT_READ : +return "READ" ; +case BLOCK_ACCT_WRITE : +return "WRITE" ; +case BLOCK_ACCT_FLUSH : +return "DISCARD" ; +case BLOCK_ACCT_UNMAP : +return "TRUNCATE" ; +case BLOCK_ACCT_NONE : +return "NONE" ; +case BLOCK_MAX_IOTYPE : +break ; + } +return "UNKNOWN" ; +} + +static void block_acct_report_long (BlockAcctStats *stats, +BlockAcctCookie *cookie,int64_t latency_ns) +{ +unsigned latency_ms = latency_ns /SCALE_MS ; +int64_t start_time_host_s; +char buf[64 ]; +struct tm t; +BlockDriverState *bs; + +if (cookie->type ==BLOCK_ACCT_NONE ) { +return ; + } +if (stats->latency_log_threshold_ms ==0 ) { +return ; + } +if (latency_ms < stats->latency_log_threshold_ms) { +return ; + } + + start_time_host_s = cookie->start_time_ns /NANOSECONDS_PER_SECOND ; +strftime (buf,sizeof (buf),"%m-%d %H:%M:%S" , +localtime_r (&start_time_host_s, &t)); + + bs =blk_bs (blk_stats2blk (stats)); +qemu_log ("long %s[%ld] IO request: %d.03%d since %s.%03d bs: %s(%s, %s)\n" , +block_account_type (cookie->type), cookie->bytes, + (int )(latency_ms /1000 ), (int )(latency_ms %1000 ), buf, + (int )((cookie->start_time_ns /1000000 ) %1000 ), + bs ==NULL ?"unknown" :bdrv_get_node_name (bs), + bs ==NULL ?"unknown" :bdrv_get_format_name (bs), + bs ==NULL ?"unknown" : bs->filename); +} +static void block_account_one_io (BlockAcctStats *stats,BlockAcctCookie *cookie,bool failed) {
@@ -222,6 +277,8 @@ static void block_account_one_io(BlockAcctStats *stats, BlockAcctCookie *cookie,qemu_mutex_unlock (&stats->lock); +block_acct_report_long (stats, cookie, latency_ns); + cookie->type =BLOCK_ACCT_NONE ; }
blockdev.c +6 -1
@@ -622,7 +622,8 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, bs->detect_zeroes = detect_zeroes; -block_acct_setup (blk_get_stats (blk), account_invalid, account_failed); +block_acct_setup (blk_get_stats (blk), account_invalid, account_failed, +qemu_opt_get_number (opts,"latency-log-threshold" ,0 ));if (!parse_stats_intervals (blk_get_stats (blk), interval_list, errp)) {blk_unref (blk);
@@ -3727,6 +3728,10 @@ QemuOptsList qemu_common_drive_opts = { .type = QEMU_OPT_BOOL, .help = "whether to account for failed I/O operations " "in the statistics", + },{ + .name = "latency-log-threshold", + .type = QEMU_OPT_NUMBER, + .help = "threshold for long I/O report (disabled if <=0), in ms", }, {/* end of list */ } },
include/block/accounting.h +4 -1
@@ -91,6 +91,9 @@ struct BlockAcctStats {bool account_invalid;bool account_failed;BlockLatencyHistogram latency_histogram[BLOCK_MAX_IOTYPE ]; + +/* Threshold for long I/O detection, ms */ +unsigned latency_log_threshold_ms; }; typedef struct BlockAcctCookie {
@@ -101,7 +104,7 @@ typedef struct BlockAcctCookie {void block_acct_init (BlockAcctStats *stats);void block_acct_setup (BlockAcctStats *stats,bool account_invalid, -bool account_failed); +bool account_failed,unsigned latency_log_threshold_ms);void block_acct_cleanup (BlockAcctStats *stats);void block_acct_add_interval (BlockAcctStats *stats,unsigned interval_length); BlockAcctTimedStats *block_acct_interval_next(BlockAcctStats *stats,
Signature · 1 line
2.17.1
Quoted 1 line · Denis V. Lunev
+ strftime(buf, sizeof(buf), "%m-%d %H:%M:%S",
"%F %T" would include the year, which can be useful.
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 234
Quoted 7 lines
block/accounting.c +7
-0+ localtime_r(&start_time_host_s, &t)); + + bs =blk_bs (blk_stats2blk (stats)); + qemu_log("long %s[%ld] IO request: %d.03%d since %s.%03d bs: %s(%s, %s)\n", + block_account_type(cookie->type), cookie->bytes, + (int)(latency_ms / 1000), (int)(latency_ms % 1000), buf, + (int)((cookie->start_time_ns / 1000000) % 1000),
Is there a reason not to use %u rather than casting?
dme.
Signature · 1 line
We wanna wait, but here we go again.
Quoted 4 lines · David Edmondson
Quoted 1 line · Denis V. Lunev
+ strftime(buf, sizeof(buf), "%m-%d %H:%M:%S",
"%F %T" would include the year, which can be useful.
ok
Quoted 9 lines
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 234
Quoted 8 lines
block/accounting.c +7
-0+ localtime_r(&start_time_host_s, &t)); + + bs =blk_bs (blk_stats2blk (stats)); + qemu_log("long %s[%ld] IO request: %d.03%d since %s.%03d bs: %s(%s, %s)\n", + block_account_type(cookie->type), cookie->bytes, + (int)(latency_ms / 1000), (int)(latency_ms % 1000), buf, + (int)((cookie->start_time_ns / 1000000) % 1000),Is there a reason not to use %u rather than casting?
no, we could use unsigned.
Will resend shortly.
Quoted 25 lines · Denis V. Lunev
There are severe delays with IO requests processing if QEMU is running in virtual machine or over software defined storage. Such delays potentially results in unpredictable guest behavior. For example, guests over IDE or SATA drive could remount filesystem read-only if write is performed longer than 10 seconds.
Such reports are very complex to process. Some good starting point for this seems quite reasonable. This patch provides one. It adds logging of such potentially dangerous long IO operations.
Signed-off-by Denis V. Lunev <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>CC Stefan Hajnoczi <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>--- block/accounting.c | 59 +++++++++++++++++++++++++++++++++++++- blockdev.c | 7 ++++- include/block/accounting.h | 5 +++- 3 files changed, 68 insertions(+), 3 deletions(-)block/accounting.c +0
-0
[...]
Quoted 5 lines
block/accounting.c +1
-0@@ -182,6 +185,58 @@ void block_latency_histograms_clear(BlockAcctStats *stats) } } +static const char *block_account_type (enum BlockAcctType type)
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 198
Quoted 10 lines
block/accounting.c +10
-0+{ +switch (type) { +case BLOCK_ACCT_READ : +return "READ" ; +case BLOCK_ACCT_WRITE : +return "WRITE" ; +case BLOCK_ACCT_FLUSH : +return "DISCARD" ; +case BLOCK_ACCT_UNMAP : +return "TRUNCATE" ;
I don’t understand how FLUSH translates to DISCARD, and UNMAP to TRUNCATE.
Quoted 25 lines
block/accounting.c +25
-0+case BLOCK_ACCT_NONE : +return "NONE" ; +case BLOCK_MAX_IOTYPE : +break ; + } +return "UNKNOWN" ; +} + +static void block_acct_report_long (BlockAcctStats *stats, +BlockAcctCookie *cookie,int64_t latency_ns) +{ +unsigned latency_ms = latency_ns /SCALE_MS ; +int64_t start_time_host_s; +char buf[64 ]; +struct tm t; +BlockDriverState *bs; + +if (cookie->type ==BLOCK_ACCT_NONE ) { +return ; + } +if (stats->latency_log_threshold_ms ==0 ) { +return ; + } +if (latency_ms < stats->latency_log_threshold_ms) { +return ;
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 233
Quoted 10 lines
block/accounting.c +10
-0+ } + + start_time_host_s = cookie->start_time_ns /NANOSECONDS_PER_SECOND ; +strftime (buf,sizeof (buf),"%m-%d %H:%M:%S" , +localtime_r (&start_time_host_s, &t)); + + bs =blk_bs (blk_stats2blk (stats)); + qemu_log("long %s[%ld] IO request: %d.03%d since %s.%03d bs: %s(%s, %s)\n", + block_account_type(cookie->type), cookie->bytes, + (int)(latency_ms / 1000), (int)(latency_ms % 1000), buf,
Why not just latency_ms * .001f and %.3f?
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 234
Quoted 1 line
block/accounting.c +1
-0+ (int)((cookie->start_time_ns / 1000000) % 1000),
s/1000000/SCALE_MS/? (But I’m not sure whether that’s what the SCALE_?S are for.)
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 237
Quoted 3 lines
block/accounting.c +3
-0+ bs ==NULL ?"unknown" :bdrv_get_node_name (bs), + bs ==NULL ?"unknown" :bdrv_get_format_name (bs), + bs == NULL ? "unknown" : bs->filename);
Now that I’m writing this response already, I wonder whether a QMP event wouldn’t be nice. (But considering that accounting apparently just doesn’t with -blockdev, I suppose that’s not that big of a worry.)
Quoted 5 lines
block/accounting.c +2
-0+} +static void block_account_one_io (BlockAcctStats *stats,BlockAcctCookie *cookie,bool failed) {
[...]
blockdev.c static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, · line 626
Quoted 11 lines
blockdev.c +2
-1@@ -622,7 +622,8 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, bs->detect_zeroes = detect_zeroes; -block_acct_setup (blk_get_stats (blk), account_invalid, account_failed); +block_acct_setup (blk_get_stats (blk), account_invalid, account_failed, +qemu_opt_get_number (opts,"latency-log-threshold" ,0 ));
latency_log_threshold_ms is an unsigned int and so this will silently overflow for values >= 2^32.
(Or for user-specified values < 0, which are wrapped around.)
blockdev.c QemuOptsList qemu_common_drive_opts = { · line 3734
Quoted 11 lines
blockdev.c +4
-0if (!parse_stats_intervals (blk_get_stats (blk), interval_list, errp)) {blk_unref (blk);@@ -3727,6 +3728,10 @@ QemuOptsList qemu_common_drive_opts = { .type = QEMU_OPT_BOOL, .help = "whether to account for failed I/O operations " "in the statistics", + },{ + .name = "latency-log-threshold", + .type = QEMU_OPT_NUMBER, + .help = "threshold for long I/O report (disabled if <=0), in ms",
Because of that overflow, negative values will not necessarily disable reporting, because truncating them to 32 bit may make them small absolute values again.
In any case, I’d just say “disabled if 0”, and not mention anything about <0.
Max
Quoted 32 lines · Max Reitz
Quoted 25 lines · Denis V. Lunev
There are severe delays with IO requests processing if QEMU is running in virtual machine or over software defined storage. Such delays potentially results in unpredictable guest behavior. For example, guests over IDE or SATA drive could remount filesystem read-only if write is performed longer than 10 seconds.
Such reports are very complex to process. Some good starting point for this seems quite reasonable. This patch provides one. It adds logging of such potentially dangerous long IO operations.
Signed-off-by Denis V. Lunev <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>CC Stefan Hajnoczi <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>--- block/accounting.c | 59 +++++++++++++++++++++++++++++++++++++- blockdev.c | 7 ++++- include/block/accounting.h | 5 +++- 3 files changed, 68 insertions(+), 3 deletions(-)block/accounting.c +0
-0[...]
Quoted 4 lines
block/accounting.c +0
-0@@ -182,6 +185,58 @@ void block_latency_histograms_clear(BlockAcctStats *stats) } }
Quoted 13 lines
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 198
Quoted 11 lines
block/accounting.c +11
-0+static const char *block_account_type (enum BlockAcctType type) +{ +switch (type) { +case BLOCK_ACCT_READ : +return "READ" ; +case BLOCK_ACCT_WRITE : +return "WRITE" ; +case BLOCK_ACCT_FLUSH : +return "DISCARD" ; +case BLOCK_ACCT_UNMAP : +return "TRUNCATE" ;I don’t understand how FLUSH translates to DISCARD, and UNMAP to TRUNCATE.
Ha, seems I have made copy/pasted and missed this. Nice catch.
Quoted 28 lines
Quoted 28 lines
block/accounting.c +28
-0+case BLOCK_ACCT_NONE : +return "NONE" ; +case BLOCK_MAX_IOTYPE : +break ; + } +return "UNKNOWN" ; +} + +static void block_acct_report_long (BlockAcctStats *stats, +BlockAcctCookie *cookie,int64_t latency_ns) +{ +unsigned latency_ms = latency_ns /SCALE_MS ; +int64_t start_time_host_s; +char buf[64 ]; +struct tm t; +BlockDriverState *bs; + +if (cookie->type ==BLOCK_ACCT_NONE ) { +return ; + } +if (stats->latency_log_threshold_ms ==0 ) { +return ; + } +if (latency_ms < stats->latency_log_threshold_ms) { +return ; + } + + start_time_host_s = cookie->start_time_ns /NANOSECONDS_PER_SECOND ;
Quoted 8 lines
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 233
Quoted 7 lines
block/accounting.c +7
-0+strftime (buf,sizeof (buf),"%m-%d %H:%M:%S" , +localtime_r (&start_time_host_s, &t)); + + bs =blk_bs (blk_stats2blk (stats)); + qemu_log("long %s[%ld] IO request: %d.03%d since %s.%03d bs: %s(%s, %s)\n", + block_account_type(cookie->type), cookie->bytes, + (int)(latency_ms / 1000), (int)(latency_ms % 1000), buf,Why not just
latency_ms* .001f and %.3f?
I personally dislike floating point, this leads to a bit strange output.
Quoted 4 lines
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 234
Quoted 2 lines
block/accounting.c +1
-0+ (int)((cookie->start_time_ns / 1000000) % 1000),s/1000000/SCALE_MS/? (But I’m not sure whether that’s what the SCALE_?S are for.)
yes, you right.
Quoted 6 lines
block/accounting.c void block_latency_histograms_clear(BlockAcctStats *stats) · line 237
Quoted 3 lines
block/accounting.c +3
-0+ bs ==NULL ?"unknown" :bdrv_get_node_name (bs), + bs ==NULL ?"unknown" :bdrv_get_format_name (bs), + bs == NULL ? "unknown" : bs->filename);Now that I’m writing this response already, I wonder whether a QMP event wouldn’t be nice. (But considering that accounting apparently just doesn’t with -blockdev, I suppose that’s not that big of a worry.)
may be. Why not?
Though there is some note. Usually after the stall there is a bunch of requests completed at the same time once the storage is unfrozen, thus some aggregation would be required.
I think that this should be made separately.
Quoted 38 lines
Quoted 5 lines
block/accounting.c +2
-0+} +static void block_account_one_io (BlockAcctStats *stats,BlockAcctCookie *cookie,bool failed) {[...]
blockdev.c static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, · line 626
Quoted 11 lines
blockdev.c +2
-1@@ -622,7 +622,8 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, bs->detect_zeroes = detect_zeroes; -block_acct_setup (blk_get_stats (blk), account_invalid, account_failed); +block_acct_setup (blk_get_stats (blk), account_invalid, account_failed, +qemu_opt_get_number (opts,"latency-log-threshold" ,0 ));
latency_log_threshold_msis an unsigned int and so this will silently overflow for values >= 2^32.(Or for user-specified values < 0, which are wrapped around.)
blockdev.c QemuOptsList qemu_common_drive_opts = { · line 3734
Quoted 11 lines
blockdev.c +4
-0if (!parse_stats_intervals (blk_get_stats (blk), interval_list, errp)) {blk_unref (blk);@@ -3727,6 +3728,10 @@ QemuOptsList qemu_common_drive_opts = { .type = QEMU_OPT_BOOL, .help = "whether to account for failed I/O operations " "in the statistics", + },{ + .name = "latency-log-threshold", + .type = QEMU_OPT_NUMBER, + .help = "threshold for long I/O report (disabled if <=0), in ms",Because of that overflow, negative values will not necessarily disable reporting, because truncating them to 32 bit may make them small absolute values again.
Quoted 2 lines
In any case, I’d just say “disabled if 0”, and not mention anything about <0.
will do.
Thanks for review!
Den
PATCH v2 3/3 block: enable long IO requests report by default
In reply to Denis V. LunevLatency threshold is set to 10 seconds following guest request timeout on legacy storage controller.
--- blockdev.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
blockdev.c +6 -1
@@ -622,8 +622,13 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, bs->detect_zeroes = detect_zeroes; +/* +* Set log threshold to 10 seconds. Timeout choosen by observation +* of the guest behavior with legacy storage controllers. Linux +* could remount FS read-only if journal write takes this time. +*/ block_acct_setup (blk_get_stats (blk), account_invalid, account_failed, -qemu_opt_get_number (opts,"latency-log-threshold" ,0 )); +qemu_opt_get_number (opts,"latency-log-threshold" ,10000 ));if (!parse_stats_intervals (blk_get_stats (blk), interval_list, errp)) {blk_unref (blk);
Signature · 1 line
2.17.1
Re: [PATCH 3/3] block: enable long IO requests report by default
Quoted 17 lines · Denis V. Lunev
Latency threshold is set to 10 seconds following guest request timeout on legacy storage controller.
Signed-off-by Denis V. Lunev <[email protected]>CC Vladimir Sementsov-Ogievskiy <[email protected]>CC Stefan Hajnoczi <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>--- blockdev.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)blockdev.c +0
-0
blockdev.c static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, · line 626
Quoted 5 lines
blockdev.c +2
-0@@ -622,8 +622,13 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, bs->detect_zeroes = detect_zeroes; +/* +* Set log threshold to 10 seconds. Timeout choosen by observation
*chosen
blockdev.c static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, · line 631
Quoted 6 lines
blockdev.c +4
-1+* of the guest behavior with legacy storage controllers. Linux +* could remount FS read-only if journal write takes this time. +*/ block_acct_setup (blk_get_stats (blk), account_invalid, account_failed, -qemu_opt_get_number (opts,"latency-log-threshold" ,0 )); +qemu_opt_get_number (opts,"latency-log-threshold" ,10000 ));
Yeah, why not.
Quoted 19 lines · Denis V. Lunev
There are severe delays with IO requests processing if QEMU is running in virtual machine or over software defined storage. Such delays potentially results in unpredictable guest behavior. For example, guests over IDE or SATA drive could remount filesystem read-only if write is performed longer than 10 seconds.
Such reports are very complex to process. Some good starting point for this seems quite reasonable. This patch provides one. It adds logging of such potentially dangerous long IO operations.
Changed from v2:
- removed accidentally added slirp subproject ID
- added comment describing timeout selection to patch 3Changes from v1:
- fixed conversions using macros suggested by Stefan
- fixed option declaration
- enabled by default with patch 3
Quoted 5 lines
Signed-off-by Denis V. Lunev <[email protected]>CC Vladimir Sementsov-Ogievskiy <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Stefan Hajnoczi <[email protected]>
Quoted 20 lines · Stefan Hajnoczi
Quoted 19 lines · Denis V. Lunev
There are severe delays with IO requests processing if QEMU is running in virtual machine or over software defined storage. Such delays potentially results in unpredictable guest behavior. For example, guests over IDE or SATA drive could remount filesystem read-only if write is performed longer than 10 seconds.
Such reports are very complex to process. Some good starting point for this seems quite reasonable. This patch provides one. It adds logging of such potentially dangerous long IO operations.
Changed from v2:
- removed accidentally added slirp subproject ID
- added comment describing timeout selection to patch 3Changes from v1:
- fixed conversions using macros suggested by Stefan
- fixed option declaration
- enabled by default with patch 3
Quoted 6 lines
Quoted 5 lines
Signed-off-by Denis V. Lunev <[email protected]>CC Vladimir Sementsov-Ogievskiy <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Stefan Hajnoczi <[email protected]>Reviewed-by Stefan Hajnoczi <[email protected]>
ping