cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

vmstate.c (17494B)

      1/*
      2 * VMState interpreter
      3 *
      4 * Copyright (c) 2009-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 "migration.h"
     15#include "migration/vmstate.h"
     16#include "savevm.h"
     17#include "qapi/qmp/json-writer.h"
     18#include "qemu-file.h"
     19#include "qemu/bitops.h"
     20#include "qemu/error-report.h"
     21#include "trace.h"
     22
     23static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
     24                                   void *opaque, JSONWriter *vmdesc);
     25static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
     26                                   void *opaque);
     27
     28static int vmstate_n_elems(void *opaque, const VMStateField *field)
     29{
     30    int n_elems = 1;
     31
     32    if (field->flags & VMS_ARRAY) {
     33        n_elems = field->num;
     34    } else if (field->flags & VMS_VARRAY_INT32) {
     35        n_elems = *(int32_t *)(opaque + field->num_offset);
     36    } else if (field->flags & VMS_VARRAY_UINT32) {
     37        n_elems = *(uint32_t *)(opaque + field->num_offset);
     38    } else if (field->flags & VMS_VARRAY_UINT16) {
     39        n_elems = *(uint16_t *)(opaque + field->num_offset);
     40    } else if (field->flags & VMS_VARRAY_UINT8) {
     41        n_elems = *(uint8_t *)(opaque + field->num_offset);
     42    }
     43
     44    if (field->flags & VMS_MULTIPLY_ELEMENTS) {
     45        n_elems *= field->num;
     46    }
     47
     48    trace_vmstate_n_elems(field->name, n_elems);
     49    return n_elems;
     50}
     51
     52static int vmstate_size(void *opaque, const VMStateField *field)
     53{
     54    int size = field->size;
     55
     56    if (field->flags & VMS_VBUFFER) {
     57        size = *(int32_t *)(opaque + field->size_offset);
     58        if (field->flags & VMS_MULTIPLY) {
     59            size *= field->size;
     60        }
     61    }
     62
     63    return size;
     64}
     65
     66static void vmstate_handle_alloc(void *ptr, const VMStateField *field,
     67                                 void *opaque)
     68{
     69    if (field->flags & VMS_POINTER && field->flags & VMS_ALLOC) {
     70        gsize size = vmstate_size(opaque, field);
     71        size *= vmstate_n_elems(opaque, field);
     72        if (size) {
     73            *(void **)ptr = g_malloc(size);
     74        }
     75    }
     76}
     77
     78int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
     79                       void *opaque, int version_id)
     80{
     81    const VMStateField *field = vmsd->fields;
     82    int ret = 0;
     83
     84    trace_vmstate_load_state(vmsd->name, version_id);
     85    if (version_id > vmsd->version_id) {
     86        error_report("%s: incoming version_id %d is too new "
     87                     "for local version_id %d",
     88                     vmsd->name, version_id, vmsd->version_id);
     89        trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
     90        return -EINVAL;
     91    }
     92    if  (version_id < vmsd->minimum_version_id) {
     93        if (vmsd->load_state_old &&
     94            version_id >= vmsd->minimum_version_id_old) {
     95            ret = vmsd->load_state_old(f, opaque, version_id);
     96            trace_vmstate_load_state_end(vmsd->name, "old path", ret);
     97            return ret;
     98        }
     99        error_report("%s: incoming version_id %d is too old "
    100                     "for local minimum version_id  %d",
    101                     vmsd->name, version_id, vmsd->minimum_version_id);
    102        trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
    103        return -EINVAL;
    104    }
    105    if (vmsd->pre_load) {
    106        int ret = vmsd->pre_load(opaque);
    107        if (ret) {
    108            return ret;
    109        }
    110    }
    111    while (field->name) {
    112        trace_vmstate_load_state_field(vmsd->name, field->name);
    113        if ((field->field_exists &&
    114             field->field_exists(opaque, version_id)) ||
    115            (!field->field_exists &&
    116             field->version_id <= version_id)) {
    117            void *first_elem = opaque + field->offset;
    118            int i, n_elems = vmstate_n_elems(opaque, field);
    119            int size = vmstate_size(opaque, field);
    120
    121            vmstate_handle_alloc(first_elem, field, opaque);
    122            if (field->flags & VMS_POINTER) {
    123                first_elem = *(void **)first_elem;
    124                assert(first_elem || !n_elems || !size);
    125            }
    126            for (i = 0; i < n_elems; i++) {
    127                void *curr_elem = first_elem + size * i;
    128
    129                if (field->flags & VMS_ARRAY_OF_POINTER) {
    130                    curr_elem = *(void **)curr_elem;
    131                }
    132                if (!curr_elem && size) {
    133                    /* if null pointer check placeholder and do not follow */
    134                    assert(field->flags & VMS_ARRAY_OF_POINTER);
    135                    ret = vmstate_info_nullptr.get(f, curr_elem, size, NULL);
    136                } else if (field->flags & VMS_STRUCT) {
    137                    ret = vmstate_load_state(f, field->vmsd, curr_elem,
    138                                             field->vmsd->version_id);
    139                } else if (field->flags & VMS_VSTRUCT) {
    140                    ret = vmstate_load_state(f, field->vmsd, curr_elem,
    141                                             field->struct_version_id);
    142                } else {
    143                    ret = field->info->get(f, curr_elem, size, field);
    144                }
    145                if (ret >= 0) {
    146                    ret = qemu_file_get_error(f);
    147                }
    148                if (ret < 0) {
    149                    qemu_file_set_error(f, ret);
    150                    error_report("Failed to load %s:%s", vmsd->name,
    151                                 field->name);
    152                    trace_vmstate_load_field_error(field->name, ret);
    153                    return ret;
    154                }
    155            }
    156        } else if (field->flags & VMS_MUST_EXIST) {
    157            error_report("Input validation failed: %s/%s",
    158                         vmsd->name, field->name);
    159            return -1;
    160        }
    161        field++;
    162    }
    163    ret = vmstate_subsection_load(f, vmsd, opaque);
    164    if (ret != 0) {
    165        return ret;
    166    }
    167    if (vmsd->post_load) {
    168        ret = vmsd->post_load(opaque, version_id);
    169    }
    170    trace_vmstate_load_state_end(vmsd->name, "end", ret);
    171    return ret;
    172}
    173
    174static int vmfield_name_num(const VMStateField *start,
    175                            const VMStateField *search)
    176{
    177    const VMStateField *field;
    178    int found = 0;
    179
    180    for (field = start; field->name; field++) {
    181        if (!strcmp(field->name, search->name)) {
    182            if (field == search) {
    183                return found;
    184            }
    185            found++;
    186        }
    187    }
    188
    189    return -1;
    190}
    191
    192static bool vmfield_name_is_unique(const VMStateField *start,
    193                                   const VMStateField *search)
    194{
    195    const VMStateField *field;
    196    int found = 0;
    197
    198    for (field = start; field->name; field++) {
    199        if (!strcmp(field->name, search->name)) {
    200            found++;
    201            /* name found more than once, so it's not unique */
    202            if (found > 1) {
    203                return false;
    204            }
    205        }
    206    }
    207
    208    return true;
    209}
    210
    211static const char *vmfield_get_type_name(const VMStateField *field)
    212{
    213    const char *type = "unknown";
    214
    215    if (field->flags & VMS_STRUCT) {
    216        type = "struct";
    217    } else if (field->flags & VMS_VSTRUCT) {
    218        type = "vstruct";
    219    } else if (field->info->name) {
    220        type = field->info->name;
    221    }
    222
    223    return type;
    224}
    225
    226static bool vmsd_can_compress(const VMStateField *field)
    227{
    228    if (field->field_exists) {
    229        /* Dynamically existing fields mess up compression */
    230        return false;
    231    }
    232
    233    if (field->flags & VMS_STRUCT) {
    234        const VMStateField *sfield = field->vmsd->fields;
    235        while (sfield->name) {
    236            if (!vmsd_can_compress(sfield)) {
    237                /* Child elements can't compress, so can't we */
    238                return false;
    239            }
    240            sfield++;
    241        }
    242
    243        if (field->vmsd->subsections) {
    244            /* Subsections may come and go, better don't compress */
    245            return false;
    246        }
    247    }
    248
    249    return true;
    250}
    251
    252static void vmsd_desc_field_start(const VMStateDescription *vmsd,
    253                                  JSONWriter *vmdesc,
    254                                  const VMStateField *field, int i, int max)
    255{
    256    char *name, *old_name;
    257    bool is_array = max > 1;
    258    bool can_compress = vmsd_can_compress(field);
    259
    260    if (!vmdesc) {
    261        return;
    262    }
    263
    264    name = g_strdup(field->name);
    265
    266    /* Field name is not unique, need to make it unique */
    267    if (!vmfield_name_is_unique(vmsd->fields, field)) {
    268        int num = vmfield_name_num(vmsd->fields, field);
    269        old_name = name;
    270        name = g_strdup_printf("%s[%d]", name, num);
    271        g_free(old_name);
    272    }
    273
    274    json_writer_start_object(vmdesc, NULL);
    275    json_writer_str(vmdesc, "name", name);
    276    if (is_array) {
    277        if (can_compress) {
    278            json_writer_int64(vmdesc, "array_len", max);
    279        } else {
    280            json_writer_int64(vmdesc, "index", i);
    281        }
    282    }
    283    json_writer_str(vmdesc, "type", vmfield_get_type_name(field));
    284
    285    if (field->flags & VMS_STRUCT) {
    286        json_writer_start_object(vmdesc, "struct");
    287    }
    288
    289    g_free(name);
    290}
    291
    292static void vmsd_desc_field_end(const VMStateDescription *vmsd,
    293                                JSONWriter *vmdesc,
    294                                const VMStateField *field, size_t size, int i)
    295{
    296    if (!vmdesc) {
    297        return;
    298    }
    299
    300    if (field->flags & VMS_STRUCT) {
    301        /* We printed a struct in between, close its child object */
    302        json_writer_end_object(vmdesc);
    303    }
    304
    305    json_writer_int64(vmdesc, "size", size);
    306    json_writer_end_object(vmdesc);
    307}
    308
    309
    310bool vmstate_save_needed(const VMStateDescription *vmsd, void *opaque)
    311{
    312    if (vmsd->needed && !vmsd->needed(opaque)) {
    313        /* optional section not needed */
    314        return false;
    315    }
    316    return true;
    317}
    318
    319
    320int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
    321                       void *opaque, JSONWriter *vmdesc_id)
    322{
    323    return vmstate_save_state_v(f, vmsd, opaque, vmdesc_id, vmsd->version_id);
    324}
    325
    326int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
    327                         void *opaque, JSONWriter *vmdesc, int version_id)
    328{
    329    int ret = 0;
    330    const VMStateField *field = vmsd->fields;
    331
    332    trace_vmstate_save_state_top(vmsd->name);
    333
    334    if (vmsd->pre_save) {
    335        ret = vmsd->pre_save(opaque);
    336        trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
    337        if (ret) {
    338            error_report("pre-save failed: %s", vmsd->name);
    339            return ret;
    340        }
    341    }
    342
    343    if (vmdesc) {
    344        json_writer_str(vmdesc, "vmsd_name", vmsd->name);
    345        json_writer_int64(vmdesc, "version", version_id);
    346        json_writer_start_array(vmdesc, "fields");
    347    }
    348
    349    while (field->name) {
    350        if ((field->field_exists &&
    351             field->field_exists(opaque, version_id)) ||
    352            (!field->field_exists &&
    353             field->version_id <= version_id)) {
    354            void *first_elem = opaque + field->offset;
    355            int i, n_elems = vmstate_n_elems(opaque, field);
    356            int size = vmstate_size(opaque, field);
    357            int64_t old_offset, written_bytes;
    358            JSONWriter *vmdesc_loop = vmdesc;
    359
    360            trace_vmstate_save_state_loop(vmsd->name, field->name, n_elems);
    361            if (field->flags & VMS_POINTER) {
    362                first_elem = *(void **)first_elem;
    363                assert(first_elem || !n_elems || !size);
    364            }
    365            for (i = 0; i < n_elems; i++) {
    366                void *curr_elem = first_elem + size * i;
    367
    368                vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems);
    369                old_offset = qemu_ftell_fast(f);
    370                if (field->flags & VMS_ARRAY_OF_POINTER) {
    371                    assert(curr_elem);
    372                    curr_elem = *(void **)curr_elem;
    373                }
    374                if (!curr_elem && size) {
    375                    /* if null pointer write placeholder and do not follow */
    376                    assert(field->flags & VMS_ARRAY_OF_POINTER);
    377                    ret = vmstate_info_nullptr.put(f, curr_elem, size, NULL,
    378                                                   NULL);
    379                } else if (field->flags & VMS_STRUCT) {
    380                    ret = vmstate_save_state(f, field->vmsd, curr_elem,
    381                                             vmdesc_loop);
    382                } else if (field->flags & VMS_VSTRUCT) {
    383                    ret = vmstate_save_state_v(f, field->vmsd, curr_elem,
    384                                               vmdesc_loop,
    385                                               field->struct_version_id);
    386                } else {
    387                    ret = field->info->put(f, curr_elem, size, field,
    388                                     vmdesc_loop);
    389                }
    390                if (ret) {
    391                    error_report("Save of field %s/%s failed",
    392                                 vmsd->name, field->name);
    393                    if (vmsd->post_save) {
    394                        vmsd->post_save(opaque);
    395                    }
    396                    return ret;
    397                }
    398
    399                written_bytes = qemu_ftell_fast(f) - old_offset;
    400                vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i);
    401
    402                /* Compressed arrays only care about the first element */
    403                if (vmdesc_loop && vmsd_can_compress(field)) {
    404                    vmdesc_loop = NULL;
    405                }
    406            }
    407        } else {
    408            if (field->flags & VMS_MUST_EXIST) {
    409                error_report("Output state validation failed: %s/%s",
    410                        vmsd->name, field->name);
    411                assert(!(field->flags & VMS_MUST_EXIST));
    412            }
    413        }
    414        field++;
    415    }
    416
    417    if (vmdesc) {
    418        json_writer_end_array(vmdesc);
    419    }
    420
    421    ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc);
    422
    423    if (vmsd->post_save) {
    424        int ps_ret = vmsd->post_save(opaque);
    425        if (!ret) {
    426            ret = ps_ret;
    427        }
    428    }
    429    return ret;
    430}
    431
    432static const VMStateDescription *
    433vmstate_get_subsection(const VMStateDescription **sub, char *idstr)
    434{
    435    while (sub && *sub) {
    436        if (strcmp(idstr, (*sub)->name) == 0) {
    437            return *sub;
    438        }
    439        sub++;
    440    }
    441    return NULL;
    442}
    443
    444static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
    445                                   void *opaque)
    446{
    447    trace_vmstate_subsection_load(vmsd->name);
    448
    449    while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
    450        char idstr[256], *idstr_ret;
    451        int ret;
    452        uint8_t version_id, len, size;
    453        const VMStateDescription *sub_vmsd;
    454
    455        len = qemu_peek_byte(f, 1);
    456        if (len < strlen(vmsd->name) + 1) {
    457            /* subsection name has be be "section_name/a" */
    458            trace_vmstate_subsection_load_bad(vmsd->name, "(short)", "");
    459            return 0;
    460        }
    461        size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2);
    462        if (size != len) {
    463            trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", "");
    464            return 0;
    465        }
    466        memcpy(idstr, idstr_ret, size);
    467        idstr[size] = 0;
    468
    469        if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
    470            trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)");
    471            /* it doesn't have a valid subsection name */
    472            return 0;
    473        }
    474        sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
    475        if (sub_vmsd == NULL) {
    476            trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
    477            return -ENOENT;
    478        }
    479        qemu_file_skip(f, 1); /* subsection */
    480        qemu_file_skip(f, 1); /* len */
    481        qemu_file_skip(f, len); /* idstr */
    482        version_id = qemu_get_be32(f);
    483
    484        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
    485        if (ret) {
    486            trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
    487            return ret;
    488        }
    489    }
    490
    491    trace_vmstate_subsection_load_good(vmsd->name);
    492    return 0;
    493}
    494
    495static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
    496                                   void *opaque, JSONWriter *vmdesc)
    497{
    498    const VMStateDescription **sub = vmsd->subsections;
    499    bool vmdesc_has_subsections = false;
    500    int ret = 0;
    501
    502    trace_vmstate_subsection_save_top(vmsd->name);
    503    while (sub && *sub) {
    504        if (vmstate_save_needed(*sub, opaque)) {
    505            const VMStateDescription *vmsdsub = *sub;
    506            uint8_t len;
    507
    508            trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name);
    509            if (vmdesc) {
    510                /* Only create subsection array when we have any */
    511                if (!vmdesc_has_subsections) {
    512                    json_writer_start_array(vmdesc, "subsections");
    513                    vmdesc_has_subsections = true;
    514                }
    515
    516                json_writer_start_object(vmdesc, NULL);
    517            }
    518
    519            qemu_put_byte(f, QEMU_VM_SUBSECTION);
    520            len = strlen(vmsdsub->name);
    521            qemu_put_byte(f, len);
    522            qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len);
    523            qemu_put_be32(f, vmsdsub->version_id);
    524            ret = vmstate_save_state(f, vmsdsub, opaque, vmdesc);
    525            if (ret) {
    526                return ret;
    527            }
    528
    529            if (vmdesc) {
    530                json_writer_end_object(vmdesc);
    531            }
    532        }
    533        sub++;
    534    }
    535
    536    if (vmdesc_has_subsections) {
    537        json_writer_end_array(vmdesc);
    538    }
    539
    540    return ret;
    541}