Commit c4e9f845 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/armbru/tags/pull-error-monitor-2019-04-18' into staging 



Error reporting & monitor patches for 2019-04-18

# gpg: Signature made Thu 18 Apr 2019 21:40:41 BST
# gpg:                using RSA key 3870B400EB918653
# gpg: Good signature from "Markus Armbruster <armbru@redhat.com>" [full]
# gpg:                 aka "Markus Armbruster <armbru@pond.sub.org>" [full]
# Primary key fingerprint: 354B C8B3 D7EB 2A6B 6867  4E5F 3870 B400 EB91 8653

* remotes/armbru/tags/pull-error-monitor-2019-04-18: (36 commits)
  include: Move fprintf_function to disas/
  disas: Rename include/disas/bfd.h back to include/disas/dis-asm.h
  monitor: Clean up how monitor_disas() funnels output to monitor
  qom/cpu: Simplify how CPUClass:cpu_dump_state() prints
  qemu-print: New qemu_fprintf(), qemu_vfprintf()
  qom/cpu: Simplify how CPUClass::dump_statistics() prints
  target/i386: Simplify how x86_cpu_dump_local_apic_state() prints
  target: Clean up how the dump_mmu() print
  target: Simplify how the TARGET_cpu_list() print
  memory: Clean up how mtree_info() prints
  block/qapi: Clean up how we print to monitor or stdout
  qsp: Simplify how qsp_report() prints
  tcg: Simplify how dump_drift_info() prints
  tcg: Simplify how dump_exec_info() prints
  tcg: Simplify how dump_opcount_info() prints
  trace: Simplify how st_print_trace_file_status() prints
  include: Include fprintf-fn.h only where needed
  monitor: Simplify how -device/device_add print help
  char-pty: Print "char device redirected" message to stdout
  char: Make -chardev help print to stdout
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 85947daf ede9a8a6

MAINTAINERS

+2 −0
Original line number Diff line number Diff line
@@ -1895,6 +1895,8 @@ F: hmp.[ch] 
F: hmp-commands*.hx

F: include/monitor/hmp-target.h

F: tests/test-hmp.c

F: include/qemu/qemu-print.h

F: util/qemu-print.c



Network device backends

M: Jason Wang <jasowang@redhat.com>

accel/kvm/kvm-all.c

+2 −2
Original line number Diff line number Diff line
@@ -1798,7 +1798,7 @@ static int kvm_handle_internal_error(CPUState *cpu, struct kvm_run *run) 
    if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {

        fprintf(stderr, "emulation failure\n");

        if (!kvm_arch_stop_on_emulation_error(cpu)) {

            cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);

            cpu_dump_state(cpu, stderr, CPU_DUMP_CODE);

            return EXCP_INTERRUPT;

        }

    }
@@ -2089,7 +2089,7 @@ int kvm_cpu_exec(CPUState *cpu) 
    qemu_mutex_lock_iothread();



    if (ret < 0) {

        cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);

        cpu_dump_state(cpu, stderr, CPU_DUMP_CODE);

        vm_stop(RUN_STATE_INTERNAL_ERROR);

    }

accel/tcg/translate-all.c

+25 −24
Original line number Diff line number Diff line
@@ -50,6 +50,7 @@ 
#include "translate-all.h"

#include "qemu/bitmap.h"

#include "qemu/error-report.h"

#include "qemu/qemu-print.h"

#include "qemu/timer.h"

#include "qemu/main-loop.h"

#include "exec/log.h"
@@ -2214,8 +2215,7 @@ void tb_flush_jmp_cache(CPUState *cpu, target_ulong addr) 
    tb_jmp_cache_clear_page(cpu, addr);

}



static void print_qht_statistics(FILE *f, fprintf_function cpu_fprintf,

                                 struct qht_stats hst)

static void print_qht_statistics(struct qht_stats hst)

{

    uint32_t hgram_opts;

    size_t hgram_bins;
@@ -2224,7 +2224,7 @@ static void print_qht_statistics(FILE *f, fprintf_function cpu_fprintf, 
    if (!hst.head_buckets) {

        return;

    }

    cpu_fprintf(f, "TB hash buckets     %zu/%zu (%0.2f%% head buckets used)\n",

    qemu_printf("TB hash buckets     %zu/%zu (%0.2f%% head buckets used)\n",

                hst.used_head_buckets, hst.head_buckets,

                (double)hst.used_head_buckets / hst.head_buckets * 100);
@@ -2234,7 +2234,7 @@ static void print_qht_statistics(FILE *f, fprintf_function cpu_fprintf, 
        hgram_opts |= QDIST_PR_NODECIMAL;

    }

    hgram = qdist_pr(&hst.occupancy, 10, hgram_opts);

    cpu_fprintf(f, "TB hash occupancy   %0.2f%% avg chain occ. Histogram: %s\n",

    qemu_printf("TB hash occupancy   %0.2f%% avg chain occ. Histogram: %s\n",

                qdist_avg(&hst.occupancy) * 100, hgram);

    g_free(hgram);
@@ -2247,7 +2247,7 @@ static void print_qht_statistics(FILE *f, fprintf_function cpu_fprintf, 
        hgram_opts |= QDIST_PR_NODECIMAL | QDIST_PR_NOBINRANGE;

    }

    hgram = qdist_pr(&hst.chain, hgram_bins, hgram_opts);

    cpu_fprintf(f, "TB hash avg chain   %0.3f buckets. Histogram: %s\n",

    qemu_printf("TB hash avg chain   %0.3f buckets. Histogram: %s\n",

                qdist_avg(&hst.chain), hgram);

    g_free(hgram);

}
@@ -2285,7 +2285,7 @@ static gboolean tb_tree_stats_iter(gpointer key, gpointer value, gpointer data) 
    return false;

}



void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)

void dump_exec_info(void)

{

    struct tb_tree_stats tst = {};

    struct qht_stats hst;
@@ -2294,48 +2294,49 @@ void dump_exec_info(FILE *f, fprintf_function cpu_fprintf) 
    tcg_tb_foreach(tb_tree_stats_iter, &tst);

    nb_tbs = tst.nb_tbs;

    /* XXX: avoid using doubles ? */

    cpu_fprintf(f, "Translation buffer state:\n");

    qemu_printf("Translation buffer state:\n");

    /*

     * Report total code size including the padding and TB structs;

     * otherwise users might think "-tb-size" is not honoured.

     * For avg host size we use the precise numbers from tb_tree_stats though.

     */

    cpu_fprintf(f, "gen code size       %zu/%zu\n",

    qemu_printf("gen code size       %zu/%zu\n",

                tcg_code_size(), tcg_code_capacity());

    cpu_fprintf(f, "TB count            %zu\n", nb_tbs);

    cpu_fprintf(f, "TB avg target size  %zu max=%zu bytes\n",

    qemu_printf("TB count            %zu\n", nb_tbs);

    qemu_printf("TB avg target size  %zu max=%zu bytes\n",

                nb_tbs ? tst.target_size / nb_tbs : 0,

                tst.max_target_size);

    cpu_fprintf(f, "TB avg host size    %zu bytes (expansion ratio: %0.1f)\n",

    qemu_printf("TB avg host size    %zu bytes (expansion ratio: %0.1f)\n",

                nb_tbs ? tst.host_size / nb_tbs : 0,

                tst.target_size ? (double)tst.host_size / tst.target_size : 0);

    cpu_fprintf(f, "cross page TB count %zu (%zu%%)\n", tst.cross_page,

    qemu_printf("cross page TB count %zu (%zu%%)\n", tst.cross_page,

                nb_tbs ? (tst.cross_page * 100) / nb_tbs : 0);

    cpu_fprintf(f, "direct jump count   %zu (%zu%%) (2 jumps=%zu %zu%%)\n",

    qemu_printf("direct jump count   %zu (%zu%%) (2 jumps=%zu %zu%%)\n",

                tst.direct_jmp_count,

                nb_tbs ? (tst.direct_jmp_count * 100) / nb_tbs : 0,

                tst.direct_jmp2_count,

                nb_tbs ? (tst.direct_jmp2_count * 100) / nb_tbs : 0);



    qht_statistics_init(&tb_ctx.htable, &hst);

    print_qht_statistics(f, cpu_fprintf, hst);

    print_qht_statistics(hst);

    qht_statistics_destroy(&hst);



    cpu_fprintf(f, "\nStatistics:\n");

    cpu_fprintf(f, "TB flush count      %u\n",

    qemu_printf("\nStatistics:\n");

    qemu_printf("TB flush count      %u\n",

                atomic_read(&tb_ctx.tb_flush_count));

    cpu_fprintf(f, "TB invalidate count %zu\n", tcg_tb_phys_invalidate_count());

    qemu_printf("TB invalidate count %zu\n",

                tcg_tb_phys_invalidate_count());



    tlb_flush_counts(&flush_full, &flush_part, &flush_elide);

    cpu_fprintf(f, "TLB full flushes    %zu\n", flush_full);

    cpu_fprintf(f, "TLB partial flushes %zu\n", flush_part);

    cpu_fprintf(f, "TLB elided flushes  %zu\n", flush_elide);

    tcg_dump_info(f, cpu_fprintf);

    qemu_printf("TLB full flushes    %zu\n", flush_full);

    qemu_printf("TLB partial flushes %zu\n", flush_part);

    qemu_printf("TLB elided flushes  %zu\n", flush_elide);

    tcg_dump_info();

}



void dump_opcount_info(FILE *f, fprintf_function cpu_fprintf)

void dump_opcount_info(void)

{

    tcg_dump_op_count(f, cpu_fprintf);

    tcg_dump_op_count();

}



#else /* CONFIG_USER_ONLY */

block/qapi.c

+55 −65
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 
#include "qapi/qmp/qlist.h"

#include "qapi/qmp/qnum.h"

#include "qapi/qmp/qstring.h"

#include "qemu/qemu-print.h"

#include "sysemu/block-backend.h"

#include "qemu/cutils.h"
@@ -660,8 +661,7 @@ static char *get_human_readable_size(char *buf, int buf_size, int64_t size) 
    return buf;

}



void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f,

                        QEMUSnapshotInfo *sn)

void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)

{

    char buf1[128], date_buf[128], clock_buf[128];

    struct tm tm;
@@ -669,8 +669,7 @@ void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, 
    int64_t secs;



    if (!sn) {

        func_fprintf(f,

                     "%-10s%-20s%7s%20s%15s",

        qemu_printf("%-10s%-20s%7s%20s%15s",

                    "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");

    } else {

        ti = sn->date_sec;
@@ -684,8 +683,7 @@ void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, 
                 (int)((secs / 60) % 60),

                 (int)(secs % 60),

                 (int)((sn->vm_clock_nsec / 1000000) % 1000));

        func_fprintf(f,

                     "%-10s%-20s%7s%20s%15s",

        qemu_printf("%-10s%-20s%7s%20s%15s",

                    sn->id_str, sn->name,

                    get_human_readable_size(buf1, sizeof(buf1),

                                            sn->vm_state_size),
@@ -694,40 +692,37 @@ void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, 
    }

}



static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation,

                       QDict *dict);

static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation,

                       QList *list);

static void dump_qdict(int indentation, QDict *dict);

static void dump_qlist(int indentation, QList *list);



static void dump_qobject(fprintf_function func_fprintf, void *f,

                         int comp_indent, QObject *obj)

static void dump_qobject(int comp_indent, QObject *obj)

{

    switch (qobject_type(obj)) {

        case QTYPE_QNUM: {

            QNum *value = qobject_to(QNum, obj);

            char *tmp = qnum_to_string(value);

            func_fprintf(f, "%s", tmp);

            qemu_printf("%s", tmp);

            g_free(tmp);

            break;

        }

        case QTYPE_QSTRING: {

            QString *value = qobject_to(QString, obj);

            func_fprintf(f, "%s", qstring_get_str(value));

            qemu_printf("%s", qstring_get_str(value));

            break;

        }

        case QTYPE_QDICT: {

            QDict *value = qobject_to(QDict, obj);

            dump_qdict(func_fprintf, f, comp_indent, value);

            dump_qdict(comp_indent, value);

            break;

        }

        case QTYPE_QLIST: {

            QList *value = qobject_to(QList, obj);

            dump_qlist(func_fprintf, f, comp_indent, value);

            dump_qlist(comp_indent, value);

            break;

        }

        case QTYPE_QBOOL: {

            QBool *value = qobject_to(QBool, obj);

            func_fprintf(f, "%s", qbool_get_bool(value) ? "true" : "false");

            qemu_printf("%s", qbool_get_bool(value) ? "true" : "false");

            break;

        }

        default:
@@ -735,8 +730,7 @@ static void dump_qobject(fprintf_function func_fprintf, void *f, 
    }

}



static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation,

                       QList *list)

static void dump_qlist(int indentation, QList *list)

{

    const QListEntry *entry;

    int i = 0;
@@ -744,17 +738,16 @@ static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 
    for (entry = qlist_first(list); entry; entry = qlist_next(entry), i++) {

        QType type = qobject_type(entry->value);

        bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST);

        func_fprintf(f, "%*s[%i]:%c", indentation * 4, "", i,

        qemu_printf("%*s[%i]:%c", indentation * 4, "", i,

                    composite ? '\n' : ' ');

        dump_qobject(func_fprintf, f, indentation + 1, entry->value);

        dump_qobject(indentation + 1, entry->value);

        if (!composite) {

            func_fprintf(f, "\n");

            qemu_printf("\n");

        }

    }

}



static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation,

                       QDict *dict)

static void dump_qdict(int indentation, QDict *dict)

{

    const QDictEntry *entry;
@@ -769,18 +762,17 @@ static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 
            key[i] = entry->key[i] == '-' ? ' ' : entry->key[i];

        }

        key[i] = 0;

        func_fprintf(f, "%*s%s:%c", indentation * 4, "", key,

        qemu_printf("%*s%s:%c", indentation * 4, "", key,

                    composite ? '\n' : ' ');

        dump_qobject(func_fprintf, f, indentation + 1, entry->value);

        dump_qobject(indentation + 1, entry->value);

        if (!composite) {

            func_fprintf(f, "\n");

            qemu_printf("\n");

        }

        g_free(key);

    }

}



void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f,

                                   ImageInfoSpecific *info_spec)

void bdrv_image_info_specific_dump(ImageInfoSpecific *info_spec)

{

    QObject *obj, *data;

    Visitor *v = qobject_output_visitor_new(&obj);
@@ -788,13 +780,12 @@ void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f, 
    visit_type_ImageInfoSpecific(v, NULL, &info_spec, &error_abort);

    visit_complete(v, &obj);

    data = qdict_get(qobject_to(QDict, obj), "data");

    dump_qobject(func_fprintf, f, 1, data);

    dump_qobject(1, data);

    qobject_unref(obj);

    visit_free(v);

}



void bdrv_image_info_dump(fprintf_function func_fprintf, void *f,

                          ImageInfo *info)

void bdrv_image_info_dump(ImageInfo *info)

{

    char size_buf[128], dsize_buf[128];

    if (!info->has_actual_size) {
@@ -804,8 +795,7 @@ void bdrv_image_info_dump(fprintf_function func_fprintf, void *f, 
                                info->actual_size);

    }

    get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);

    func_fprintf(f,

                 "image: %s\n"

    qemu_printf("image: %s\n"

                "file format: %s\n"

                "virtual size: %s (%" PRId64 " bytes)\n"

                "disk size: %s\n",
@@ -814,29 +804,29 @@ void bdrv_image_info_dump(fprintf_function func_fprintf, void *f, 
                dsize_buf);



    if (info->has_encrypted && info->encrypted) {

        func_fprintf(f, "encrypted: yes\n");

        qemu_printf("encrypted: yes\n");

    }



    if (info->has_cluster_size) {

        func_fprintf(f, "cluster_size: %" PRId64 "\n",

        qemu_printf("cluster_size: %" PRId64 "\n",

                    info->cluster_size);

    }



    if (info->has_dirty_flag && info->dirty_flag) {

        func_fprintf(f, "cleanly shut down: no\n");

        qemu_printf("cleanly shut down: no\n");

    }



    if (info->has_backing_filename) {

        func_fprintf(f, "backing file: %s", info->backing_filename);

        qemu_printf("backing file: %s", info->backing_filename);

        if (!info->has_full_backing_filename) {

            func_fprintf(f, " (cannot determine actual path)");

            qemu_printf(" (cannot determine actual path)");

        } else if (strcmp(info->backing_filename,

                          info->full_backing_filename) != 0) {

            func_fprintf(f, " (actual path: %s)", info->full_backing_filename);

            qemu_printf(" (actual path: %s)", info->full_backing_filename);

        }

        func_fprintf(f, "\n");

        qemu_printf("\n");

        if (info->has_backing_filename_format) {

            func_fprintf(f, "backing file format: %s\n",

            qemu_printf("backing file format: %s\n",

                        info->backing_filename_format);

        }

    }
@@ -844,9 +834,9 @@ void bdrv_image_info_dump(fprintf_function func_fprintf, void *f, 
    if (info->has_snapshots) {

        SnapshotInfoList *elem;



        func_fprintf(f, "Snapshot list:\n");

        bdrv_snapshot_dump(func_fprintf, f, NULL);

        func_fprintf(f, "\n");

        qemu_printf("Snapshot list:\n");

        bdrv_snapshot_dump(NULL);

        qemu_printf("\n");



        /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but

         * we convert to the block layer's native QEMUSnapshotInfo for now.
@@ -862,13 +852,13 @@ void bdrv_image_info_dump(fprintf_function func_fprintf, void *f, 


            pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);

            pstrcpy(sn.name, sizeof(sn.name), elem->value->name);

            bdrv_snapshot_dump(func_fprintf, f, &sn);

            func_fprintf(f, "\n");

            bdrv_snapshot_dump(&sn);

            qemu_printf("\n");

        }

    }



    if (info->has_format_specific) {

        func_fprintf(f, "Format specific information:\n");

        bdrv_image_info_specific_dump(func_fprintf, f, info->format_specific);

        qemu_printf("Format specific information:\n");

        bdrv_image_info_specific_dump(info->format_specific);

    }

}

block/ssh.c

+13 −25
Original line number Diff line number Diff line
@@ -159,15 +159,8 @@ sftp_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...) 
    g_free(msg);

}



static void GCC_FMT_ATTR(2, 3)

sftp_error_report(BDRVSSHState *s, const char *fs, ...)

static void sftp_error_trace(BDRVSSHState *s, const char *op)

{

    va_list args;



    va_start(args, fs);

    error_vprintf(fs, args);



    if ((s)->sftp) {

    char *ssh_err;

    int ssh_err_code;

    unsigned long sftp_err_code;
@@ -178,12 +171,7 @@ sftp_error_report(BDRVSSHState *s, const char *fs, ...) 
    /* See <libssh2_sftp.h>. */

    sftp_err_code = libssh2_sftp_last_error((s)->sftp);



        error_printf(": %s (libssh2 error code: %d, sftp error code: %lu)",

                     ssh_err, ssh_err_code, sftp_err_code);

    }



    va_end(args);

    error_printf("\n");

    trace_sftp_error(op, ssh_err, ssh_err_code, sftp_err_code);

}



static int parse_uri(const char *filename, QDict *options, Error **errp)
@@ -1035,7 +1023,7 @@ static coroutine_fn int ssh_read(BDRVSSHState *s, BlockDriverState *bs, 
            goto again;

        }

        if (r < 0) {

            sftp_error_report(s, "read failed");

            sftp_error_trace(s, "read");

            s->offset = -1;

            return -EIO;

        }
@@ -1105,7 +1093,7 @@ static int ssh_write(BDRVSSHState *s, BlockDriverState *bs, 
            goto again;

        }

        if (r < 0) {

            sftp_error_report(s, "write failed");

            sftp_error_trace(s, "write");

            s->offset = -1;

            return -EIO;

        }
@@ -1188,7 +1176,7 @@ static coroutine_fn int ssh_flush(BDRVSSHState *s, BlockDriverState *bs) 
        return 0;

    }

    if (r < 0) {

        sftp_error_report(s, "fsync failed");

        sftp_error_trace(s, "fsync");

        return -EIO;

    }