Revision c60bf339 monitor.c

b/monitor.c
217 217
Monitor *cur_mon;
218 218
Monitor *default_mon;
219 219

  
220
static void monitor_command_cb(Monitor *mon, const char *cmdline,
221
                               void *opaque);
220
static void monitor_command_cb(void *opaque, const char *cmdline,
221
                               void *readline_opaque);
222 222

  
223 223
static inline int qmp_cmd_mode(const Monitor *mon)
224 224
{
......
4338 4338
    }
4339 4339
}
4340 4340

  
4341
static void monitor_find_completion(Monitor *mon,
4341
static void monitor_find_completion(void *opaque,
4342 4342
                                    const char *cmdline)
4343 4343
{
4344
    Monitor *mon = opaque;
4344 4345
    char *args[MAX_ARGS];
4345 4346
    int nb_args, len;
4346 4347

  
......
4751 4752
    cur_mon = old_mon;
4752 4753
}
4753 4754

  
4754
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
4755
static void monitor_command_cb(void *opaque, const char *cmdline,
4756
                               void *readline_opaque)
4755 4757
{
4758
    Monitor *mon = opaque;
4759

  
4756 4760
    monitor_suspend(mon);
4757 4761
    handle_user_command(mon, cmdline);
4758 4762
    monitor_resume(mon);
......
4881 4885
 * End:
4882 4886
 */
4883 4887

  
4888
/* These functions just adapt the readline interface in a typesafe way.  We
4889
 * could cast function pointers but that discards compiler checks.
4890
 */
4891
static void monitor_readline_printf(void *opaque, const char *fmt, ...)
4892
{
4893
    va_list ap;
4894
    va_start(ap, fmt);
4895
    monitor_vprintf(opaque, fmt, ap);
4896
    va_end(ap);
4897
}
4898

  
4899
static void monitor_readline_flush(void *opaque)
4900
{
4901
    monitor_flush(opaque);
4902
}
4903

  
4884 4904
void monitor_init(CharDriverState *chr, int flags)
4885 4905
{
4886 4906
    static int is_first_init = 1;
......
4898 4918
    mon->chr = chr;
4899 4919
    mon->flags = flags;
4900 4920
    if (flags & MONITOR_USE_READLINE) {
4901
        mon->rs = readline_init(mon, monitor_find_completion);
4921
        mon->rs = readline_init(monitor_readline_printf,
4922
                                monitor_readline_flush,
4923
                                mon,
4924
                                monitor_find_completion);
4902 4925
        monitor_read_command(mon, 0);
4903 4926
    }
4904 4927

  
......
4920 4943
        default_mon = mon;
4921 4944
}
4922 4945

  
4923
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
4946
static void bdrv_password_cb(void *opaque, const char *password,
4947
                             void *readline_opaque)
4924 4948
{
4925
    BlockDriverState *bs = opaque;
4949
    Monitor *mon = opaque;
4950
    BlockDriverState *bs = readline_opaque;
4926 4951
    int ret = 0;
4927 4952

  
4928 4953
    if (bdrv_set_key(bs, password) != 0) {

Also available in: Unified diff