Commit 5bce308a authored by Kevin Wolf's avatar Kevin Wolf Committed by Markus Armbruster
Browse files

monitor: Create monitor-internal.h with common definitions 



Before we can split monitor/misc.c, we need to create a header file that
contains the common definitions that will be used by multiple source
files.

For a start, add the type definitions for Monitor, MonitorHMP and
MonitorQMP and their dependencies. We'll add functions as needed when
splitting monitor/misc.c.

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
Reviewed-by: default avatarDr. David Alan Gilbert <dgilbert@redhat.com>
Message-Id: <20190613153405.24769-10-kwolf@redhat.com>
Reviewed-by: default avatarMarkus Armbruster <armbru@redhat.com>
[Header guard symbol tidied up, superfluous #include dropped, FIXME in
hmp_change() resolved]
Signed-off-by: default avatarMarkus Armbruster <armbru@redhat.com>
parent f1b3ccfa

MAINTAINERS

+2 −0
Original line number Diff line number Diff line
@@ -1918,6 +1918,7 @@ F: qapi/run-state.json 
Human Monitor (HMP)

M: Dr. David Alan Gilbert <dgilbert@redhat.com>

S: Maintained

F: monitor/monitor-internal.h

F: monitor/misc.c

F: monitor/hmp*

F: hmp.h
@@ -2040,6 +2041,7 @@ F: tests/check-qom-proplist.c 
QMP

M: Markus Armbruster <armbru@redhat.com>

S: Supported

F: monitor/monitor-internal.h

F: monitor/qmp*

F: monitor/misc.c

F: docs/devel/*qmp-*

monitor/hmp-cmds.c

+2 −3
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 
#include "qemu/option.h"

#include "qemu/timer.h"

#include "qemu/sockets.h"

#include "monitor/monitor.h"

#include "monitor/monitor-internal.h"

#include "monitor/qdev.h"

#include "qapi/error.h"

#include "qapi/opts-visitor.h"
@@ -1943,8 +1943,7 @@ static void hmp_change_read_arg(void *opaque, const char *password, 


void hmp_change(Monitor *mon, const QDict *qdict)

{

    /* FIXME Make MonitorHMP public and use container_of */

    MonitorHMP *hmp_mon = (MonitorHMP *)mon;

    MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);

    const char *device = qdict_get_str(qdict, "device");

    const char *target = qdict_get_str(qdict, "target");

    const char *arg = qdict_get_try_str(qdict, "arg");

monitor/misc.c

+1 −113
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
 */



#include "qemu/osdep.h"

#include "monitor-internal.h"

#include "qemu/units.h"

#include <dirent.h>

#include "cpu.h"
@@ -35,15 +36,12 @@ 
#include "exec/gdbstub.h"

#include "net/net.h"

#include "net/slirp.h"

#include "chardev/char-fe.h"

#include "chardev/char-io.h"

#include "chardev/char-mux.h"

#include "ui/qemu-spice.h"

#include "sysemu/numa.h"

#include "monitor/monitor.h"

#include "qemu/config-file.h"

#include "qemu/ctype.h"

#include "qemu/readline.h"

#include "ui/console.h"

#include "ui/input.h"

#include "sysemu/block-backend.h"
@@ -61,7 +59,6 @@ 
#include "qapi/qmp/qnum.h"

#include "qapi/qmp/qstring.h"

#include "qapi/qmp/qjson.h"

#include "qapi/qmp/json-parser.h"

#include "qapi/qmp/qlist.h"

#include "qom/object_interfaces.h"

#include "trace.h"
@@ -93,55 +90,6 @@ 
#include "hw/s390x/storage-attributes.h"

#endif



/*

 * Supported types:

 *

 * 'F'          filename

 * 'B'          block device name

 * 's'          string (accept optional quote)

 * 'S'          it just appends the rest of the string (accept optional quote)

 * 'O'          option string of the form NAME=VALUE,...

 *              parsed according to QemuOptsList given by its name

 *              Example: 'device:O' uses qemu_device_opts.

 *              Restriction: only lists with empty desc are supported

 *              TODO lift the restriction

 * 'i'          32 bit integer

 * 'l'          target long (32 or 64 bit)

 * 'M'          Non-negative target long (32 or 64 bit), in user mode the

 *              value is multiplied by 2^20 (think Mebibyte)

 * 'o'          octets (aka bytes)

 *              user mode accepts an optional E, e, P, p, T, t, G, g, M, m,

 *              K, k suffix, which multiplies the value by 2^60 for suffixes E

 *              and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,

 *              2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k

 * 'T'          double

 *              user mode accepts an optional ms, us, ns suffix,

 *              which divides the value by 1e3, 1e6, 1e9, respectively

 * '/'          optional gdb-like print format (like "/10x")

 *

 * '?'          optional type (for all types, except '/')

 * '.'          other form of optional type (for 'i' and 'l')

 * 'b'          boolean

 *              user mode accepts "on" or "off"

 * '-'          optional parameter (eg. '-f')

 *

 */



typedef struct HMPCommand {

    const char *name;

    const char *args_type;

    const char *params;

    const char *help;

    const char *flags; /* p=preconfig */

    void (*cmd)(Monitor *mon, const QDict *qdict);

    /* @sub_table is a list of 2nd level of commands. If it does not exist,

     * cmd should be used. If it exists, sub_table[?].cmd should be

     * used, and cmd of 1st level plays the role of help function.

     */

    struct HMPCommand *sub_table;

    void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);

} HMPCommand;



/* file descriptors passed via SCM_RIGHTS */

typedef struct mon_fd_t mon_fd_t;

struct mon_fd_t {
@@ -184,66 +132,6 @@ typedef struct { 
    int64_t rate;       /* Minimum time (in ns) between two events */

} MonitorQAPIEventConf;



struct Monitor {

    CharBackend chr;

    int reset_seen;

    int flags;

    int suspend_cnt;            /* Needs to be accessed atomically */

    bool skip_flush;

    bool use_io_thread;



    gchar *mon_cpu_path;

    QTAILQ_ENTRY(Monitor) entry;



    /*

     * The per-monitor lock. We can't access guest memory when holding

     * the lock.

     */

    QemuMutex mon_lock;



    /*

     * Members that are protected by the per-monitor lock

     */

    QLIST_HEAD(, mon_fd_t) fds;

    QString *outbuf;

    guint out_watch;

    /* Read under either BQL or mon_lock, written with BQL+mon_lock.  */

    int mux_out;

};



struct MonitorHMP {

    Monitor common;

    /*

     * State used only in the thread "owning" the monitor.

     * If @use_io_thread, this is @mon_iothread. (This does not actually happen

     * in the current state of the code.)

     * Else, it's the main thread.

     * These members can be safely accessed without locks.

     */

    ReadLineState *rs;

};



typedef struct {

    Monitor common;

    JSONMessageParser parser;

    /*

     * When a client connects, we're in capabilities negotiation mode.

     * @commands is &qmp_cap_negotiation_commands then.  When command

     * qmp_capabilities succeeds, we go into command mode, and

     * @command becomes &qmp_commands.

     */

    QmpCommandList *commands;

    bool capab_offered[QMP_CAPABILITY__MAX]; /* capabilities offered */

    bool capab[QMP_CAPABILITY__MAX];         /* offered and accepted */

    /*

     * Protects qmp request/response queue.

     * Take monitor_lock first when you need both.

     */

    QemuMutex qmp_queue_lock;

    /* Input queue that holds all the parsed QMP requests */

    GQueue *qmp_requests;

} MonitorQMP;



/* Shared monitor I/O thread */

IOThread *mon_iothread;

monitor/monitor-internal.h

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

 * QEMU monitor

 *

 * Copyright (c) 2003-2004 Fabrice Bellard

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */



#ifndef MONITOR_INTERNAL_H

#define MONITOR_INTERNAL_H



#include "chardev/char-fe.h"

#include "monitor/monitor.h"

#include "qapi/qapi-types-misc.h"

#include "qapi/qmp/dispatch.h"

#include "qapi/qmp/json-parser.h"

#include "qemu/readline.h"



/*

 * Supported types:

 *

 * 'F'          filename

 * 'B'          block device name

 * 's'          string (accept optional quote)

 * 'S'          it just appends the rest of the string (accept optional quote)

 * 'O'          option string of the form NAME=VALUE,...

 *              parsed according to QemuOptsList given by its name

 *              Example: 'device:O' uses qemu_device_opts.

 *              Restriction: only lists with empty desc are supported

 *              TODO lift the restriction

 * 'i'          32 bit integer

 * 'l'          target long (32 or 64 bit)

 * 'M'          Non-negative target long (32 or 64 bit), in user mode the

 *              value is multiplied by 2^20 (think Mebibyte)

 * 'o'          octets (aka bytes)

 *              user mode accepts an optional E, e, P, p, T, t, G, g, M, m,

 *              K, k suffix, which multiplies the value by 2^60 for suffixes E

 *              and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,

 *              2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k

 * 'T'          double

 *              user mode accepts an optional ms, us, ns suffix,

 *              which divides the value by 1e3, 1e6, 1e9, respectively

 * '/'          optional gdb-like print format (like "/10x")

 *

 * '?'          optional type (for all types, except '/')

 * '.'          other form of optional type (for 'i' and 'l')

 * 'b'          boolean

 *              user mode accepts "on" or "off"

 * '-'          optional parameter (eg. '-f')

 *

 */



typedef struct HMPCommand {

    const char *name;

    const char *args_type;

    const char *params;

    const char *help;

    const char *flags; /* p=preconfig */

    void (*cmd)(Monitor *mon, const QDict *qdict);

    /*

     * @sub_table is a list of 2nd level of commands. If it does not exist,

     * cmd should be used. If it exists, sub_table[?].cmd should be

     * used, and cmd of 1st level plays the role of help function.

     */

    struct HMPCommand *sub_table;

    void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);

} HMPCommand;



struct Monitor {

    CharBackend chr;

    int reset_seen;

    int flags;

    int suspend_cnt;            /* Needs to be accessed atomically */

    bool skip_flush;

    bool use_io_thread;



    gchar *mon_cpu_path;

    QTAILQ_ENTRY(Monitor) entry;



    /*

     * The per-monitor lock. We can't access guest memory when holding

     * the lock.

     */

    QemuMutex mon_lock;



    /*

     * Members that are protected by the per-monitor lock

     */

    QLIST_HEAD(, mon_fd_t) fds;

    QString *outbuf;

    guint out_watch;

    /* Read under either BQL or mon_lock, written with BQL+mon_lock.  */

    int mux_out;

};



struct MonitorHMP {

    Monitor common;

    /*

     * State used only in the thread "owning" the monitor.

     * If @use_io_thread, this is @mon_iothread. (This does not actually happen

     * in the current state of the code.)

     * Else, it's the main thread.

     * These members can be safely accessed without locks.

     */

    ReadLineState *rs;

};



typedef struct {

    Monitor common;

    JSONMessageParser parser;

    /*

     * When a client connects, we're in capabilities negotiation mode.

     * @commands is &qmp_cap_negotiation_commands then.  When command

     * qmp_capabilities succeeds, we go into command mode, and

     * @command becomes &qmp_commands.

     */

    QmpCommandList *commands;

    bool capab_offered[QMP_CAPABILITY__MAX]; /* capabilities offered */

    bool capab[QMP_CAPABILITY__MAX];         /* offered and accepted */

    /*

     * Protects qmp request/response queue.

     * Take monitor_lock first when you need both.

     */

    QemuMutex qmp_queue_lock;

    /* Input queue that holds all the parsed QMP requests */

    GQueue *qmp_requests;

} MonitorQMP;



#endif