qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

global_state.c (3772B)

      1 /*
      2  * Global State configuration
      3  *
      4  * Copyright (c) 2014-2017 Red Hat Inc
      5  *
      6  * Authors:
      7  *  Juan Quintela <quintela@redhat.com>
      8  *
      9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
     10  * See the COPYING file in the top-level directory.
     11  */
     12 
     13 #include "qemu/osdep.h"
     14 #include "qemu/cutils.h"
     15 #include "qemu/error-report.h"
     16 #include "sysemu/runstate.h"
     17 #include "qapi/error.h"
     18 #include "migration.h"
     19 #include "migration/global_state.h"
     20 #include "migration/vmstate.h"
     21 #include "trace.h"
     22 
     23 typedef struct {
     24     uint32_t size;
     25     uint8_t runstate[100];
     26     RunState state;
     27     bool received;
     28 } GlobalState;
     29 
     30 static GlobalState global_state;
     31 
     32 int global_state_store(void)
     33 {
     34     if (!runstate_store((char *)global_state.runstate,
     35                         sizeof(global_state.runstate))) {
     36         error_report("runstate name too big: %s", global_state.runstate);
     37         trace_migrate_state_too_big();
     38         return -EINVAL;
     39     }
     40     return 0;
     41 }
     42 
     43 void global_state_store_running(void)
     44 {
     45     const char *state = RunState_str(RUN_STATE_RUNNING);
     46     assert(strlen(state) < sizeof(global_state.runstate));
     47     strpadcpy((char *)global_state.runstate, sizeof(global_state.runstate),
     48               state, '\0');
     49 }
     50 
     51 bool global_state_received(void)
     52 {
     53     return global_state.received;
     54 }
     55 
     56 RunState global_state_get_runstate(void)
     57 {
     58     return global_state.state;
     59 }
     60 
     61 static bool global_state_needed(void *opaque)
     62 {
     63     GlobalState *s = opaque;
     64     char *runstate = (char *)s->runstate;
     65 
     66     /* If it is not optional, it is mandatory */
     67 
     68     if (migrate_get_current()->store_global_state) {
     69         return true;
     70     }
     71 
     72     /* If state is running or paused, it is not needed */
     73 
     74     if (strcmp(runstate, "running") == 0 ||
     75         strcmp(runstate, "paused") == 0) {
     76         return false;
     77     }
     78 
     79     /* for any other state it is needed */
     80     return true;
     81 }
     82 
     83 static int global_state_post_load(void *opaque, int version_id)
     84 {
     85     GlobalState *s = opaque;
     86     Error *local_err = NULL;
     87     int r;
     88     char *runstate = (char *)s->runstate;
     89 
     90     s->received = true;
     91     trace_migrate_global_state_post_load(runstate);
     92 
     93     if (strnlen((char *)s->runstate,
     94                 sizeof(s->runstate)) == sizeof(s->runstate)) {
     95         /*
     96          * This condition should never happen during migration, because
     97          * all runstate names are shorter than 100 bytes (the size of
     98          * s->runstate). However, a malicious stream could overflow
     99          * the qapi_enum_parse() call, so we force the last character
    100          * to a NUL byte.
    101          */
    102         s->runstate[sizeof(s->runstate) - 1] = '\0';
    103     }
    104     r = qapi_enum_parse(&RunState_lookup, runstate, -1, &local_err);
    105 
    106     if (r == -1) {
    107         if (local_err) {
    108             error_report_err(local_err);
    109         }
    110         return -EINVAL;
    111     }
    112     s->state = r;
    113 
    114     return 0;
    115 }
    116 
    117 static int global_state_pre_save(void *opaque)
    118 {
    119     GlobalState *s = opaque;
    120 
    121     trace_migrate_global_state_pre_save((char *)s->runstate);
    122     s->size = strnlen((char *)s->runstate, sizeof(s->runstate)) + 1;
    123     assert(s->size <= sizeof(s->runstate));
    124 
    125     return 0;
    126 }
    127 
    128 static const VMStateDescription vmstate_globalstate = {
    129     .name = "globalstate",
    130     .version_id = 1,
    131     .minimum_version_id = 1,
    132     .post_load = global_state_post_load,
    133     .pre_save = global_state_pre_save,
    134     .needed = global_state_needed,
    135     .fields = (VMStateField[]) {
    136         VMSTATE_UINT32(size, GlobalState),
    137         VMSTATE_BUFFER(runstate, GlobalState),
    138         VMSTATE_END_OF_LIST()
    139     },
    140 };
    141 
    142 void register_global_state(void)
    143 {
    144     /* We would use it independently that we receive it */
    145     strcpy((char *)&global_state.runstate, "");
    146     global_state.received = false;
    147     vmstate_register(NULL, 0, &vmstate_globalstate, &global_state);
    148 }