aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1 | /* |
| 2 | * QEMU System Emulator |
| 3 | * |
| 4 | * Copyright (c) 2003-2008 Fabrice Bellard |
Juan Quintela | 76cc7b5 | 2015-05-08 13:20:21 +0200 | [diff] [blame] | 5 | * Copyright (c) 2009-2015 Red Hat Inc |
| 6 | * |
| 7 | * Authors: |
| 8 | * Juan Quintela <quintela@redhat.com> |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 9 | * |
| 10 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 11 | * of this software and associated documentation files (the "Software"), to deal |
| 12 | * in the Software without restriction, including without limitation the rights |
| 13 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 14 | * copies of the Software, and to permit persons to whom the Software is |
| 15 | * furnished to do so, subject to the following conditions: |
| 16 | * |
| 17 | * The above copyright notice and this permission notice shall be included in |
| 18 | * all copies or substantial portions of the Software. |
| 19 | * |
| 20 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 21 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 22 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 23 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 24 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 25 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 26 | * THE SOFTWARE. |
| 27 | */ |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 28 | |
Peter Maydell | 1393a48 | 2016-01-26 18:16:54 +0000 | [diff] [blame] | 29 | #include "qemu/osdep.h" |
Paolo Bonzini | 33c1187 | 2016-03-15 16:58:45 +0100 | [diff] [blame] | 30 | #include "cpu.h" |
Amit Shah | abfd9ce | 2014-06-20 18:56:08 +0530 | [diff] [blame] | 31 | #include "hw/boards.h" |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 32 | #include "hw/hw.h" |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 33 | #include "hw/qdev.h" |
Wen Congyang | 88c1656 | 2016-06-03 17:58:34 +0800 | [diff] [blame] | 34 | #include "hw/xen/xen.h" |
Paolo Bonzini | 1422e32 | 2012-10-24 08:43:34 +0200 | [diff] [blame] | 35 | #include "net/net.h" |
Paolo Bonzini | 83c9089 | 2012-12-17 18:19:49 +0100 | [diff] [blame] | 36 | #include "monitor/monitor.h" |
Paolo Bonzini | 9c17d61 | 2012-12-17 18:20:04 +0100 | [diff] [blame] | 37 | #include "sysemu/sysemu.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 38 | #include "qemu/timer.h" |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 39 | #include "audio/audio.h" |
Paolo Bonzini | caf71f8 | 2012-12-17 18:19:50 +0100 | [diff] [blame] | 40 | #include "migration/migration.h" |
Dr. David Alan Gilbert | eb59db5 | 2015-11-05 18:10:55 +0000 | [diff] [blame] | 41 | #include "migration/postcopy-ram.h" |
Markus Armbruster | cc7a8ea | 2015-03-17 17:22:46 +0100 | [diff] [blame] | 42 | #include "qapi/qmp/qerror.h" |
Markus Armbruster | d49b683 | 2015-03-17 18:29:20 +0100 | [diff] [blame] | 43 | #include "qemu/error-report.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 44 | #include "qemu/sockets.h" |
| 45 | #include "qemu/queue.h" |
Paolo Bonzini | 9c17d61 | 2012-12-17 18:20:04 +0100 | [diff] [blame] | 46 | #include "sysemu/cpus.h" |
Paolo Bonzini | 022c62c | 2012-12-17 18:19:49 +0100 | [diff] [blame] | 47 | #include "exec/memory.h" |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 48 | #include "qmp-commands.h" |
Juan Quintela | 517a13c | 2012-05-21 23:46:44 +0200 | [diff] [blame] | 49 | #include "trace.h" |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 50 | #include "qemu/bitops.h" |
Orit Wasserman | 28085f7 | 2013-03-22 16:47:58 +0200 | [diff] [blame] | 51 | #include "qemu/iov.h" |
Wenchao Xia | de08c60 | 2013-05-25 11:09:43 +0800 | [diff] [blame] | 52 | #include "block/snapshot.h" |
Wenchao Xia | f364ec6 | 2013-05-25 11:09:44 +0800 | [diff] [blame] | 53 | #include "block/qapi.h" |
Veronia Bahaa | f348b6d | 2016-03-20 19:16:19 +0200 | [diff] [blame] | 54 | #include "qemu/cutils.h" |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 55 | #include "io/channel-buffer.h" |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 56 | #include "io/channel-file.h" |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 57 | |
Nolan | 18995b9 | 2009-10-15 16:53:55 -0700 | [diff] [blame] | 58 | #ifndef ETH_P_RARP |
Stefan Berger | f8778a7 | 2010-04-24 08:54:07 -0400 | [diff] [blame] | 59 | #define ETH_P_RARP 0x8035 |
Nolan | 18995b9 | 2009-10-15 16:53:55 -0700 | [diff] [blame] | 60 | #endif |
| 61 | #define ARP_HTYPE_ETH 0x0001 |
| 62 | #define ARP_PTYPE_IP 0x0800 |
| 63 | #define ARP_OP_REQUEST_REV 0x3 |
| 64 | |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 65 | const unsigned int postcopy_ram_discard_version = 0; |
| 66 | |
Dr. David Alan Gilbert | 37fb569 | 2015-05-19 12:29:51 +0100 | [diff] [blame] | 67 | static bool skip_section_footers; |
| 68 | |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 69 | static struct mig_cmd_args { |
| 70 | ssize_t len; /* -1 = variable */ |
| 71 | const char *name; |
| 72 | } mig_cmd_args[] = { |
| 73 | [MIG_CMD_INVALID] = { .len = -1, .name = "INVALID" }, |
Dr. David Alan Gilbert | 2e37701 | 2015-11-05 18:10:46 +0000 | [diff] [blame] | 74 | [MIG_CMD_OPEN_RETURN_PATH] = { .len = 0, .name = "OPEN_RETURN_PATH" }, |
| 75 | [MIG_CMD_PING] = { .len = sizeof(uint32_t), .name = "PING" }, |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 76 | [MIG_CMD_POSTCOPY_ADVISE] = { .len = 16, .name = "POSTCOPY_ADVISE" }, |
| 77 | [MIG_CMD_POSTCOPY_LISTEN] = { .len = 0, .name = "POSTCOPY_LISTEN" }, |
| 78 | [MIG_CMD_POSTCOPY_RUN] = { .len = 0, .name = "POSTCOPY_RUN" }, |
| 79 | [MIG_CMD_POSTCOPY_RAM_DISCARD] = { |
| 80 | .len = -1, .name = "POSTCOPY_RAM_DISCARD" }, |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 81 | [MIG_CMD_PACKAGED] = { .len = 4, .name = "PACKAGED" }, |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 82 | [MIG_CMD_MAX] = { .len = -1, .name = "MAX" }, |
| 83 | }; |
| 84 | |
Nolan | 18995b9 | 2009-10-15 16:53:55 -0700 | [diff] [blame] | 85 | static int announce_self_create(uint8_t *buf, |
Eduardo Habkost | 5cecf41 | 2013-11-28 12:01:12 -0200 | [diff] [blame] | 86 | uint8_t *mac_addr) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 87 | { |
Nolan | 18995b9 | 2009-10-15 16:53:55 -0700 | [diff] [blame] | 88 | /* Ethernet header. */ |
| 89 | memset(buf, 0xff, 6); /* destination MAC addr */ |
| 90 | memcpy(buf + 6, mac_addr, 6); /* source MAC addr */ |
| 91 | *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */ |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 92 | |
Nolan | 18995b9 | 2009-10-15 16:53:55 -0700 | [diff] [blame] | 93 | /* RARP header. */ |
| 94 | *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */ |
| 95 | *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */ |
| 96 | *(buf + 18) = 6; /* hardware addr length (ethernet) */ |
| 97 | *(buf + 19) = 4; /* protocol addr length (IPv4) */ |
| 98 | *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */ |
| 99 | memcpy(buf + 22, mac_addr, 6); /* source hw addr */ |
| 100 | memset(buf + 28, 0x00, 4); /* source protocol addr */ |
| 101 | memcpy(buf + 32, mac_addr, 6); /* target hw addr */ |
| 102 | memset(buf + 38, 0x00, 4); /* target protocol addr */ |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 103 | |
Nolan | 18995b9 | 2009-10-15 16:53:55 -0700 | [diff] [blame] | 104 | /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */ |
| 105 | memset(buf + 42, 0x00, 18); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 106 | |
Nolan | 18995b9 | 2009-10-15 16:53:55 -0700 | [diff] [blame] | 107 | return 60; /* len (FCS will be added by hardware) */ |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 108 | } |
| 109 | |
Mark McLoughlin | f401ca2 | 2009-11-25 18:49:32 +0000 | [diff] [blame] | 110 | static void qemu_announce_self_iter(NICState *nic, void *opaque) |
| 111 | { |
| 112 | uint8_t buf[60]; |
| 113 | int len; |
| 114 | |
Alexey Kardashevskiy | 9013dca | 2014-03-11 10:42:29 +1100 | [diff] [blame] | 115 | trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr)); |
Mark McLoughlin | f401ca2 | 2009-11-25 18:49:32 +0000 | [diff] [blame] | 116 | len = announce_self_create(buf, nic->conf->macaddr.a); |
| 117 | |
Jason Wang | b356f76 | 2013-01-30 19:12:22 +0800 | [diff] [blame] | 118 | qemu_send_packet_raw(qemu_get_queue(nic), buf, len); |
Mark McLoughlin | f401ca2 | 2009-11-25 18:49:32 +0000 | [diff] [blame] | 119 | } |
| 120 | |
| 121 | |
Gleb Natapov | ed8b330 | 2009-05-21 17:17:44 +0300 | [diff] [blame] | 122 | static void qemu_announce_self_once(void *opaque) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 123 | { |
Gleb Natapov | ed8b330 | 2009-05-21 17:17:44 +0300 | [diff] [blame] | 124 | static int count = SELF_ANNOUNCE_ROUNDS; |
| 125 | QEMUTimer *timer = *(QEMUTimer **)opaque; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 126 | |
Mark McLoughlin | f401ca2 | 2009-11-25 18:49:32 +0000 | [diff] [blame] | 127 | qemu_foreach_nic(qemu_announce_self_iter, NULL); |
| 128 | |
Nolan | 18995b9 | 2009-10-15 16:53:55 -0700 | [diff] [blame] | 129 | if (--count) { |
| 130 | /* delay 50ms, 150ms, 250ms, ... */ |
Alex Bligh | bc72ad6 | 2013-08-21 16:03:08 +0100 | [diff] [blame] | 131 | timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + |
Jason Wang | 508e118 | 2014-05-20 14:01:43 +0800 | [diff] [blame] | 132 | self_announce_delay(count)); |
Gleb Natapov | ed8b330 | 2009-05-21 17:17:44 +0300 | [diff] [blame] | 133 | } else { |
Eduardo Habkost | 5cecf41 | 2013-11-28 12:01:12 -0200 | [diff] [blame] | 134 | timer_del(timer); |
| 135 | timer_free(timer); |
Gleb Natapov | ed8b330 | 2009-05-21 17:17:44 +0300 | [diff] [blame] | 136 | } |
| 137 | } |
| 138 | |
| 139 | void qemu_announce_self(void) |
| 140 | { |
Eduardo Habkost | 5cecf41 | 2013-11-28 12:01:12 -0200 | [diff] [blame] | 141 | static QEMUTimer *timer; |
| 142 | timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer); |
| 143 | qemu_announce_self_once(&timer); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 144 | } |
| 145 | |
| 146 | /***********************************************************/ |
| 147 | /* savevm/loadvm support */ |
| 148 | |
Kevin Wolf | 05fcc84 | 2013-04-05 21:27:54 +0200 | [diff] [blame] | 149 | static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt, |
| 150 | int64_t pos) |
| 151 | { |
| 152 | int ret; |
| 153 | QEMUIOVector qiov; |
| 154 | |
| 155 | qemu_iovec_init_external(&qiov, iov, iovcnt); |
| 156 | ret = bdrv_writev_vmstate(opaque, &qiov, pos); |
| 157 | if (ret < 0) { |
| 158 | return ret; |
| 159 | } |
| 160 | |
| 161 | return qiov.size; |
| 162 | } |
| 163 | |
Dr. David Alan Gilbert | a202a4c | 2015-08-13 11:51:33 +0100 | [diff] [blame] | 164 | static ssize_t block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, |
| 165 | size_t size) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 166 | { |
Christoph Hellwig | 45566e9 | 2009-07-10 23:11:57 +0200 | [diff] [blame] | 167 | return bdrv_load_vmstate(opaque, buf, pos, size); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 168 | } |
| 169 | |
| 170 | static int bdrv_fclose(void *opaque) |
| 171 | { |
Paolo Bonzini | ad492c9 | 2012-06-06 00:04:50 +0200 | [diff] [blame] | 172 | return bdrv_flush(opaque); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 173 | } |
| 174 | |
Paolo Bonzini | 9229bf3 | 2012-08-08 10:15:15 +0200 | [diff] [blame] | 175 | static const QEMUFileOps bdrv_read_ops = { |
| 176 | .get_buffer = block_get_buffer, |
| 177 | .close = bdrv_fclose |
| 178 | }; |
| 179 | |
| 180 | static const QEMUFileOps bdrv_write_ops = { |
Kevin Wolf | 05fcc84 | 2013-04-05 21:27:54 +0200 | [diff] [blame] | 181 | .writev_buffer = block_writev_buffer, |
| 182 | .close = bdrv_fclose |
Paolo Bonzini | 9229bf3 | 2012-08-08 10:15:15 +0200 | [diff] [blame] | 183 | }; |
| 184 | |
Christoph Hellwig | 45566e9 | 2009-07-10 23:11:57 +0200 | [diff] [blame] | 185 | static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 186 | { |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 187 | if (is_writable) { |
Paolo Bonzini | 9229bf3 | 2012-08-08 10:15:15 +0200 | [diff] [blame] | 188 | return qemu_fopen_ops(bs, &bdrv_write_ops); |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 189 | } |
Paolo Bonzini | 9229bf3 | 2012-08-08 10:15:15 +0200 | [diff] [blame] | 190 | return qemu_fopen_ops(bs, &bdrv_read_ops); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 191 | } |
| 192 | |
Paolo Bonzini | 2ff68d0 | 2011-09-12 16:21:44 +0200 | [diff] [blame] | 193 | |
Eduardo Habkost | bb1a6d8 | 2013-11-29 12:26:02 -0200 | [diff] [blame] | 194 | /* QEMUFile timer support. |
| 195 | * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c |
| 196 | */ |
Paolo Bonzini | 2ff68d0 | 2011-09-12 16:21:44 +0200 | [diff] [blame] | 197 | |
Alex Bligh | 40daca5 | 2013-08-21 16:03:02 +0100 | [diff] [blame] | 198 | void timer_put(QEMUFile *f, QEMUTimer *ts) |
Paolo Bonzini | 2ff68d0 | 2011-09-12 16:21:44 +0200 | [diff] [blame] | 199 | { |
| 200 | uint64_t expire_time; |
| 201 | |
Alex Bligh | e93379b | 2013-08-21 16:02:39 +0100 | [diff] [blame] | 202 | expire_time = timer_expire_time_ns(ts); |
Paolo Bonzini | 2ff68d0 | 2011-09-12 16:21:44 +0200 | [diff] [blame] | 203 | qemu_put_be64(f, expire_time); |
| 204 | } |
| 205 | |
Alex Bligh | 40daca5 | 2013-08-21 16:03:02 +0100 | [diff] [blame] | 206 | void timer_get(QEMUFile *f, QEMUTimer *ts) |
Paolo Bonzini | 2ff68d0 | 2011-09-12 16:21:44 +0200 | [diff] [blame] | 207 | { |
| 208 | uint64_t expire_time; |
| 209 | |
| 210 | expire_time = qemu_get_be64(f); |
| 211 | if (expire_time != -1) { |
Alex Bligh | bc72ad6 | 2013-08-21 16:03:08 +0100 | [diff] [blame] | 212 | timer_mod_ns(ts, expire_time); |
Paolo Bonzini | 2ff68d0 | 2011-09-12 16:21:44 +0200 | [diff] [blame] | 213 | } else { |
Alex Bligh | bc72ad6 | 2013-08-21 16:03:08 +0100 | [diff] [blame] | 214 | timer_del(ts); |
Paolo Bonzini | 2ff68d0 | 2011-09-12 16:21:44 +0200 | [diff] [blame] | 215 | } |
| 216 | } |
| 217 | |
| 218 | |
Eduardo Habkost | bb1a6d8 | 2013-11-29 12:26:02 -0200 | [diff] [blame] | 219 | /* VMState timer support. |
| 220 | * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c |
| 221 | */ |
Juan Quintela | dde0463 | 2009-08-20 19:42:26 +0200 | [diff] [blame] | 222 | |
| 223 | static int get_timer(QEMUFile *f, void *pv, size_t size) |
| 224 | { |
| 225 | QEMUTimer *v = pv; |
Alex Bligh | 40daca5 | 2013-08-21 16:03:02 +0100 | [diff] [blame] | 226 | timer_get(f, v); |
Juan Quintela | dde0463 | 2009-08-20 19:42:26 +0200 | [diff] [blame] | 227 | return 0; |
| 228 | } |
| 229 | |
Juan Quintela | 84e2e3e | 2009-09-29 22:48:20 +0200 | [diff] [blame] | 230 | static void put_timer(QEMUFile *f, void *pv, size_t size) |
Juan Quintela | dde0463 | 2009-08-20 19:42:26 +0200 | [diff] [blame] | 231 | { |
Juan Quintela | 84e2e3e | 2009-09-29 22:48:20 +0200 | [diff] [blame] | 232 | QEMUTimer *v = pv; |
Alex Bligh | 40daca5 | 2013-08-21 16:03:02 +0100 | [diff] [blame] | 233 | timer_put(f, v); |
Juan Quintela | dde0463 | 2009-08-20 19:42:26 +0200 | [diff] [blame] | 234 | } |
| 235 | |
| 236 | const VMStateInfo vmstate_info_timer = { |
| 237 | .name = "timer", |
| 238 | .get = get_timer, |
| 239 | .put = put_timer, |
| 240 | }; |
| 241 | |
Peter Maydell | 08e99e2 | 2012-10-30 07:45:12 +0000 | [diff] [blame] | 242 | |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 243 | typedef struct CompatEntry { |
| 244 | char idstr[256]; |
| 245 | int instance_id; |
| 246 | } CompatEntry; |
| 247 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 248 | typedef struct SaveStateEntry { |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 249 | QTAILQ_ENTRY(SaveStateEntry) entry; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 250 | char idstr[256]; |
| 251 | int instance_id; |
Jan Kiszka | 4d2ffa0 | 2010-05-15 13:32:40 +0200 | [diff] [blame] | 252 | int alias_id; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 253 | int version_id; |
| 254 | int section_id; |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 255 | SaveVMHandlers *ops; |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 256 | const VMStateDescription *vmsd; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 257 | void *opaque; |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 258 | CompatEntry *compat; |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 259 | int is_ram; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 260 | } SaveStateEntry; |
| 261 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 262 | typedef struct SaveState { |
| 263 | QTAILQ_HEAD(, SaveStateEntry) handlers; |
| 264 | int global_section_id; |
Juan Quintela | 61964c2 | 2015-05-13 18:17:43 +0200 | [diff] [blame] | 265 | bool skip_configuration; |
| 266 | uint32_t len; |
| 267 | const char *name; |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 268 | } SaveState; |
lirans@il.ibm.com | c163b5c | 2009-11-02 15:40:58 +0200 | [diff] [blame] | 269 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 270 | static SaveState savevm_state = { |
| 271 | .handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers), |
| 272 | .global_section_id = 0, |
Juan Quintela | 61964c2 | 2015-05-13 18:17:43 +0200 | [diff] [blame] | 273 | .skip_configuration = false, |
| 274 | }; |
| 275 | |
| 276 | void savevm_skip_configuration(void) |
| 277 | { |
| 278 | savevm_state.skip_configuration = true; |
| 279 | } |
| 280 | |
| 281 | |
| 282 | static void configuration_pre_save(void *opaque) |
| 283 | { |
| 284 | SaveState *state = opaque; |
| 285 | const char *current_name = MACHINE_GET_CLASS(current_machine)->name; |
| 286 | |
| 287 | state->len = strlen(current_name); |
| 288 | state->name = current_name; |
| 289 | } |
| 290 | |
| 291 | static int configuration_post_load(void *opaque, int version_id) |
| 292 | { |
| 293 | SaveState *state = opaque; |
| 294 | const char *current_name = MACHINE_GET_CLASS(current_machine)->name; |
| 295 | |
| 296 | if (strncmp(state->name, current_name, state->len) != 0) { |
Greg Kurz | 15d6169 | 2016-02-05 09:33:26 +0100 | [diff] [blame] | 297 | error_report("Machine type received is '%.*s' and local is '%s'", |
| 298 | (int) state->len, state->name, current_name); |
Juan Quintela | 61964c2 | 2015-05-13 18:17:43 +0200 | [diff] [blame] | 299 | return -EINVAL; |
| 300 | } |
| 301 | return 0; |
| 302 | } |
| 303 | |
| 304 | static const VMStateDescription vmstate_configuration = { |
| 305 | .name = "configuration", |
| 306 | .version_id = 1, |
| 307 | .post_load = configuration_post_load, |
| 308 | .pre_save = configuration_pre_save, |
| 309 | .fields = (VMStateField[]) { |
| 310 | VMSTATE_UINT32(len, SaveState), |
| 311 | VMSTATE_VBUFFER_ALLOC_UINT32(name, SaveState, 0, NULL, 0, len), |
| 312 | VMSTATE_END_OF_LIST() |
| 313 | }, |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 314 | }; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 315 | |
Amit Shah | abfd9ce | 2014-06-20 18:56:08 +0530 | [diff] [blame] | 316 | static void dump_vmstate_vmsd(FILE *out_file, |
| 317 | const VMStateDescription *vmsd, int indent, |
| 318 | bool is_subsection); |
| 319 | |
| 320 | static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field, |
| 321 | int indent) |
| 322 | { |
| 323 | fprintf(out_file, "%*s{\n", indent, ""); |
| 324 | indent += 2; |
| 325 | fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name); |
| 326 | fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "", |
| 327 | field->version_id); |
| 328 | fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "", |
| 329 | field->field_exists ? "true" : "false"); |
| 330 | fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size); |
| 331 | if (field->vmsd != NULL) { |
| 332 | fprintf(out_file, ",\n"); |
| 333 | dump_vmstate_vmsd(out_file, field->vmsd, indent, false); |
| 334 | } |
| 335 | fprintf(out_file, "\n%*s}", indent - 2, ""); |
| 336 | } |
| 337 | |
| 338 | static void dump_vmstate_vmss(FILE *out_file, |
Juan Quintela | 5cd8cad | 2014-09-23 14:09:54 +0200 | [diff] [blame] | 339 | const VMStateDescription **subsection, |
Amit Shah | abfd9ce | 2014-06-20 18:56:08 +0530 | [diff] [blame] | 340 | int indent) |
| 341 | { |
Juan Quintela | 5cd8cad | 2014-09-23 14:09:54 +0200 | [diff] [blame] | 342 | if (*subsection != NULL) { |
| 343 | dump_vmstate_vmsd(out_file, *subsection, indent, true); |
Amit Shah | abfd9ce | 2014-06-20 18:56:08 +0530 | [diff] [blame] | 344 | } |
| 345 | } |
| 346 | |
| 347 | static void dump_vmstate_vmsd(FILE *out_file, |
| 348 | const VMStateDescription *vmsd, int indent, |
| 349 | bool is_subsection) |
| 350 | { |
| 351 | if (is_subsection) { |
| 352 | fprintf(out_file, "%*s{\n", indent, ""); |
| 353 | } else { |
| 354 | fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description"); |
| 355 | } |
| 356 | indent += 2; |
| 357 | fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name); |
| 358 | fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "", |
| 359 | vmsd->version_id); |
| 360 | fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "", |
| 361 | vmsd->minimum_version_id); |
| 362 | if (vmsd->fields != NULL) { |
| 363 | const VMStateField *field = vmsd->fields; |
| 364 | bool first; |
| 365 | |
| 366 | fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, ""); |
| 367 | first = true; |
| 368 | while (field->name != NULL) { |
| 369 | if (field->flags & VMS_MUST_EXIST) { |
| 370 | /* Ignore VMSTATE_VALIDATE bits; these don't get migrated */ |
| 371 | field++; |
| 372 | continue; |
| 373 | } |
| 374 | if (!first) { |
| 375 | fprintf(out_file, ",\n"); |
| 376 | } |
| 377 | dump_vmstate_vmsf(out_file, field, indent + 2); |
| 378 | field++; |
| 379 | first = false; |
| 380 | } |
| 381 | fprintf(out_file, "\n%*s]", indent, ""); |
| 382 | } |
| 383 | if (vmsd->subsections != NULL) { |
Juan Quintela | 5cd8cad | 2014-09-23 14:09:54 +0200 | [diff] [blame] | 384 | const VMStateDescription **subsection = vmsd->subsections; |
Amit Shah | abfd9ce | 2014-06-20 18:56:08 +0530 | [diff] [blame] | 385 | bool first; |
| 386 | |
| 387 | fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, ""); |
| 388 | first = true; |
Juan Quintela | 5cd8cad | 2014-09-23 14:09:54 +0200 | [diff] [blame] | 389 | while (*subsection != NULL) { |
Amit Shah | abfd9ce | 2014-06-20 18:56:08 +0530 | [diff] [blame] | 390 | if (!first) { |
| 391 | fprintf(out_file, ",\n"); |
| 392 | } |
| 393 | dump_vmstate_vmss(out_file, subsection, indent + 2); |
| 394 | subsection++; |
| 395 | first = false; |
| 396 | } |
| 397 | fprintf(out_file, "\n%*s]", indent, ""); |
| 398 | } |
| 399 | fprintf(out_file, "\n%*s}", indent - 2, ""); |
| 400 | } |
| 401 | |
| 402 | static void dump_machine_type(FILE *out_file) |
| 403 | { |
| 404 | MachineClass *mc; |
| 405 | |
| 406 | mc = MACHINE_GET_CLASS(current_machine); |
| 407 | |
| 408 | fprintf(out_file, " \"vmschkmachine\": {\n"); |
| 409 | fprintf(out_file, " \"Name\": \"%s\"\n", mc->name); |
| 410 | fprintf(out_file, " },\n"); |
| 411 | } |
| 412 | |
| 413 | void dump_vmstate_json_to_file(FILE *out_file) |
| 414 | { |
| 415 | GSList *list, *elt; |
| 416 | bool first; |
| 417 | |
| 418 | fprintf(out_file, "{\n"); |
| 419 | dump_machine_type(out_file); |
| 420 | |
| 421 | first = true; |
| 422 | list = object_class_get_list(TYPE_DEVICE, true); |
| 423 | for (elt = list; elt; elt = elt->next) { |
| 424 | DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data, |
| 425 | TYPE_DEVICE); |
| 426 | const char *name; |
| 427 | int indent = 2; |
| 428 | |
| 429 | if (!dc->vmsd) { |
| 430 | continue; |
| 431 | } |
| 432 | |
| 433 | if (!first) { |
| 434 | fprintf(out_file, ",\n"); |
| 435 | } |
| 436 | name = object_class_get_name(OBJECT_CLASS(dc)); |
| 437 | fprintf(out_file, "%*s\"%s\": {\n", indent, "", name); |
| 438 | indent += 2; |
| 439 | fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name); |
| 440 | fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "", |
| 441 | dc->vmsd->version_id); |
| 442 | fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "", |
| 443 | dc->vmsd->minimum_version_id); |
| 444 | |
| 445 | dump_vmstate_vmsd(out_file, dc->vmsd, indent, false); |
| 446 | |
| 447 | fprintf(out_file, "\n%*s}", indent - 2, ""); |
| 448 | first = false; |
| 449 | } |
| 450 | fprintf(out_file, "\n}\n"); |
| 451 | fclose(out_file); |
| 452 | } |
| 453 | |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 454 | static int calculate_new_instance_id(const char *idstr) |
| 455 | { |
| 456 | SaveStateEntry *se; |
| 457 | int instance_id = 0; |
| 458 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 459 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 460 | if (strcmp(idstr, se->idstr) == 0 |
| 461 | && instance_id <= se->instance_id) { |
| 462 | instance_id = se->instance_id + 1; |
| 463 | } |
| 464 | } |
| 465 | return instance_id; |
| 466 | } |
| 467 | |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 468 | static int calculate_compat_instance_id(const char *idstr) |
| 469 | { |
| 470 | SaveStateEntry *se; |
| 471 | int instance_id = 0; |
| 472 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 473 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 474 | if (!se->compat) { |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 475 | continue; |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 476 | } |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 477 | |
| 478 | if (strcmp(idstr, se->compat->idstr) == 0 |
| 479 | && instance_id <= se->compat->instance_id) { |
| 480 | instance_id = se->compat->instance_id + 1; |
| 481 | } |
| 482 | } |
| 483 | return instance_id; |
| 484 | } |
| 485 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 486 | /* TODO: Individual devices generally have very little idea about the rest |
| 487 | of the system, so instance_id should be removed/replaced. |
| 488 | Meanwhile pass -1 as instance_id if you do not already have a clearly |
| 489 | distinguishing id for all instances of your device class. */ |
Alex Williamson | 0be71e3 | 2010-06-25 11:09:07 -0600 | [diff] [blame] | 490 | int register_savevm_live(DeviceState *dev, |
| 491 | const char *idstr, |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 492 | int instance_id, |
| 493 | int version_id, |
Juan Quintela | 7908c78 | 2012-06-26 18:46:10 +0200 | [diff] [blame] | 494 | SaveVMHandlers *ops, |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 495 | void *opaque) |
| 496 | { |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 497 | SaveStateEntry *se; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 498 | |
Markus Armbruster | 97f3ad3 | 2015-09-14 13:51:31 +0200 | [diff] [blame] | 499 | se = g_new0(SaveStateEntry, 1); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 500 | se->version_id = version_id; |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 501 | se->section_id = savevm_state.global_section_id++; |
Juan Quintela | 7908c78 | 2012-06-26 18:46:10 +0200 | [diff] [blame] | 502 | se->ops = ops; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 503 | se->opaque = opaque; |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 504 | se->vmsd = NULL; |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 505 | /* if this is a live_savem then set is_ram */ |
Juan Quintela | 16310a3 | 2012-06-28 15:31:37 +0200 | [diff] [blame] | 506 | if (ops->save_live_setup != NULL) { |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 507 | se->is_ram = 1; |
| 508 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 509 | |
Anthony Liguori | 09e5ab6 | 2012-02-03 12:28:43 -0600 | [diff] [blame] | 510 | if (dev) { |
| 511 | char *id = qdev_get_dev_path(dev); |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 512 | if (id) { |
| 513 | pstrcpy(se->idstr, sizeof(se->idstr), id); |
| 514 | pstrcat(se->idstr, sizeof(se->idstr), "/"); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 515 | g_free(id); |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 516 | |
Markus Armbruster | 97f3ad3 | 2015-09-14 13:51:31 +0200 | [diff] [blame] | 517 | se->compat = g_new0(CompatEntry, 1); |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 518 | pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr); |
| 519 | se->compat->instance_id = instance_id == -1 ? |
| 520 | calculate_compat_instance_id(idstr) : instance_id; |
| 521 | instance_id = -1; |
| 522 | } |
| 523 | } |
| 524 | pstrcat(se->idstr, sizeof(se->idstr), idstr); |
| 525 | |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 526 | if (instance_id == -1) { |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 527 | se->instance_id = calculate_new_instance_id(se->idstr); |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 528 | } else { |
| 529 | se->instance_id = instance_id; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 530 | } |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 531 | assert(!se->compat || se->instance_id == 0); |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 532 | /* add at the end of list */ |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 533 | QTAILQ_INSERT_TAIL(&savevm_state.handlers, se, entry); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 534 | return 0; |
| 535 | } |
| 536 | |
Alex Williamson | 0be71e3 | 2010-06-25 11:09:07 -0600 | [diff] [blame] | 537 | int register_savevm(DeviceState *dev, |
| 538 | const char *idstr, |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 539 | int instance_id, |
| 540 | int version_id, |
| 541 | SaveStateHandler *save_state, |
| 542 | LoadStateHandler *load_state, |
| 543 | void *opaque) |
| 544 | { |
Markus Armbruster | 97f3ad3 | 2015-09-14 13:51:31 +0200 | [diff] [blame] | 545 | SaveVMHandlers *ops = g_new0(SaveVMHandlers, 1); |
Juan Quintela | 7908c78 | 2012-06-26 18:46:10 +0200 | [diff] [blame] | 546 | ops->save_state = save_state; |
| 547 | ops->load_state = load_state; |
Alex Williamson | 0be71e3 | 2010-06-25 11:09:07 -0600 | [diff] [blame] | 548 | return register_savevm_live(dev, idstr, instance_id, version_id, |
Juan Quintela | 7908c78 | 2012-06-26 18:46:10 +0200 | [diff] [blame] | 549 | ops, opaque); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 550 | } |
| 551 | |
Alex Williamson | 0be71e3 | 2010-06-25 11:09:07 -0600 | [diff] [blame] | 552 | void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque) |
aliguori | 41bd13a | 2009-04-17 17:10:59 +0000 | [diff] [blame] | 553 | { |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 554 | SaveStateEntry *se, *new_se; |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 555 | char id[256] = ""; |
| 556 | |
Anthony Liguori | 09e5ab6 | 2012-02-03 12:28:43 -0600 | [diff] [blame] | 557 | if (dev) { |
| 558 | char *path = qdev_get_dev_path(dev); |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 559 | if (path) { |
| 560 | pstrcpy(id, sizeof(id), path); |
| 561 | pstrcat(id, sizeof(id), "/"); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 562 | g_free(path); |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 563 | } |
| 564 | } |
| 565 | pstrcat(id, sizeof(id), idstr); |
aliguori | 41bd13a | 2009-04-17 17:10:59 +0000 | [diff] [blame] | 566 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 567 | QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) { |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 568 | if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) { |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 569 | QTAILQ_REMOVE(&savevm_state.handlers, se, entry); |
Daniel P. Berrange | ef1e1e0 | 2015-08-26 12:17:18 +0100 | [diff] [blame] | 570 | g_free(se->compat); |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 571 | g_free(se->ops); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 572 | g_free(se); |
aliguori | 41bd13a | 2009-04-17 17:10:59 +0000 | [diff] [blame] | 573 | } |
aliguori | 41bd13a | 2009-04-17 17:10:59 +0000 | [diff] [blame] | 574 | } |
| 575 | } |
| 576 | |
Alex Williamson | 0be71e3 | 2010-06-25 11:09:07 -0600 | [diff] [blame] | 577 | int vmstate_register_with_alias_id(DeviceState *dev, int instance_id, |
Jan Kiszka | 4d2ffa0 | 2010-05-15 13:32:40 +0200 | [diff] [blame] | 578 | const VMStateDescription *vmsd, |
| 579 | void *opaque, int alias_id, |
| 580 | int required_for_version) |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 581 | { |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 582 | SaveStateEntry *se; |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 583 | |
Jan Kiszka | 4d2ffa0 | 2010-05-15 13:32:40 +0200 | [diff] [blame] | 584 | /* If this triggers, alias support can be dropped for the vmsd. */ |
| 585 | assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id); |
| 586 | |
Markus Armbruster | 97f3ad3 | 2015-09-14 13:51:31 +0200 | [diff] [blame] | 587 | se = g_new0(SaveStateEntry, 1); |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 588 | se->version_id = vmsd->version_id; |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 589 | se->section_id = savevm_state.global_section_id++; |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 590 | se->opaque = opaque; |
| 591 | se->vmsd = vmsd; |
Jan Kiszka | 4d2ffa0 | 2010-05-15 13:32:40 +0200 | [diff] [blame] | 592 | se->alias_id = alias_id; |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 593 | |
Anthony Liguori | 09e5ab6 | 2012-02-03 12:28:43 -0600 | [diff] [blame] | 594 | if (dev) { |
| 595 | char *id = qdev_get_dev_path(dev); |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 596 | if (id) { |
| 597 | pstrcpy(se->idstr, sizeof(se->idstr), id); |
| 598 | pstrcat(se->idstr, sizeof(se->idstr), "/"); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 599 | g_free(id); |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 600 | |
Markus Armbruster | 97f3ad3 | 2015-09-14 13:51:31 +0200 | [diff] [blame] | 601 | se->compat = g_new0(CompatEntry, 1); |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 602 | pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name); |
| 603 | se->compat->instance_id = instance_id == -1 ? |
| 604 | calculate_compat_instance_id(vmsd->name) : instance_id; |
| 605 | instance_id = -1; |
| 606 | } |
| 607 | } |
| 608 | pstrcat(se->idstr, sizeof(se->idstr), vmsd->name); |
| 609 | |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 610 | if (instance_id == -1) { |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 611 | se->instance_id = calculate_new_instance_id(se->idstr); |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 612 | } else { |
| 613 | se->instance_id = instance_id; |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 614 | } |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 615 | assert(!se->compat || se->instance_id == 0); |
Juan Quintela | 8718e99 | 2009-09-01 02:12:31 +0200 | [diff] [blame] | 616 | /* add at the end of list */ |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 617 | QTAILQ_INSERT_TAIL(&savevm_state.handlers, se, entry); |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 618 | return 0; |
| 619 | } |
| 620 | |
Alex Williamson | 0be71e3 | 2010-06-25 11:09:07 -0600 | [diff] [blame] | 621 | void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd, |
| 622 | void *opaque) |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 623 | { |
Juan Quintela | 1eb7538 | 2009-09-10 03:04:29 +0200 | [diff] [blame] | 624 | SaveStateEntry *se, *new_se; |
| 625 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 626 | QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) { |
Juan Quintela | 1eb7538 | 2009-09-10 03:04:29 +0200 | [diff] [blame] | 627 | if (se->vmsd == vmsd && se->opaque == opaque) { |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 628 | QTAILQ_REMOVE(&savevm_state.handlers, se, entry); |
Daniel P. Berrange | ef1e1e0 | 2015-08-26 12:17:18 +0100 | [diff] [blame] | 629 | g_free(se->compat); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 630 | g_free(se); |
Juan Quintela | 1eb7538 | 2009-09-10 03:04:29 +0200 | [diff] [blame] | 631 | } |
| 632 | } |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 633 | } |
| 634 | |
Juan Quintela | 4082be4 | 2009-08-20 19:42:24 +0200 | [diff] [blame] | 635 | static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id) |
| 636 | { |
Alexey Kardashevskiy | 9013dca | 2014-03-11 10:42:29 +1100 | [diff] [blame] | 637 | trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)"); |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 638 | if (!se->vmsd) { /* Old style */ |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 639 | return se->ops->load_state(f, se->opaque, version_id); |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 640 | } |
| 641 | return vmstate_load_state(f, se->vmsd, se->opaque, version_id); |
Juan Quintela | 4082be4 | 2009-08-20 19:42:24 +0200 | [diff] [blame] | 642 | } |
| 643 | |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 644 | static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc) |
| 645 | { |
| 646 | int64_t old_offset, size; |
| 647 | |
| 648 | old_offset = qemu_ftell_fast(f); |
| 649 | se->ops->save_state(f, se->opaque); |
| 650 | size = qemu_ftell_fast(f) - old_offset; |
| 651 | |
| 652 | if (vmdesc) { |
| 653 | json_prop_int(vmdesc, "size", size); |
| 654 | json_start_array(vmdesc, "fields"); |
| 655 | json_start_object(vmdesc, NULL); |
| 656 | json_prop_str(vmdesc, "name", "data"); |
| 657 | json_prop_int(vmdesc, "size", size); |
| 658 | json_prop_str(vmdesc, "type", "buffer"); |
| 659 | json_end_object(vmdesc); |
| 660 | json_end_array(vmdesc); |
| 661 | } |
| 662 | } |
| 663 | |
| 664 | static void vmstate_save(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc) |
Juan Quintela | 4082be4 | 2009-08-20 19:42:24 +0200 | [diff] [blame] | 665 | { |
Alexey Kardashevskiy | 9013dca | 2014-03-11 10:42:29 +1100 | [diff] [blame] | 666 | trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)"); |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 667 | if (!se->vmsd) { |
| 668 | vmstate_save_old_style(f, se, vmdesc); |
Alex Williamson | dc91212 | 2011-01-11 14:39:43 -0700 | [diff] [blame] | 669 | return; |
Juan Quintela | 9ed7d6a | 2009-08-20 19:42:25 +0200 | [diff] [blame] | 670 | } |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 671 | vmstate_save_state(f, se->vmsd, se->opaque, vmdesc); |
Juan Quintela | 4082be4 | 2009-08-20 19:42:24 +0200 | [diff] [blame] | 672 | } |
| 673 | |
Dr. David Alan Gilbert | 37fb569 | 2015-05-19 12:29:51 +0100 | [diff] [blame] | 674 | void savevm_skip_section_footers(void) |
| 675 | { |
| 676 | skip_section_footers = true; |
| 677 | } |
| 678 | |
Dr. David Alan Gilbert | ce39bfc | 2015-05-19 12:29:50 +0100 | [diff] [blame] | 679 | /* |
| 680 | * Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL) |
| 681 | */ |
| 682 | static void save_section_header(QEMUFile *f, SaveStateEntry *se, |
| 683 | uint8_t section_type) |
| 684 | { |
| 685 | qemu_put_byte(f, section_type); |
| 686 | qemu_put_be32(f, se->section_id); |
| 687 | |
| 688 | if (section_type == QEMU_VM_SECTION_FULL || |
| 689 | section_type == QEMU_VM_SECTION_START) { |
| 690 | /* ID string */ |
| 691 | size_t len = strlen(se->idstr); |
| 692 | qemu_put_byte(f, len); |
| 693 | qemu_put_buffer(f, (uint8_t *)se->idstr, len); |
| 694 | |
| 695 | qemu_put_be32(f, se->instance_id); |
| 696 | qemu_put_be32(f, se->version_id); |
| 697 | } |
| 698 | } |
| 699 | |
Dr. David Alan Gilbert | f68945d | 2015-05-19 12:29:52 +0100 | [diff] [blame] | 700 | /* |
| 701 | * Write a footer onto device sections that catches cases misformatted device |
| 702 | * sections. |
| 703 | */ |
| 704 | static void save_section_footer(QEMUFile *f, SaveStateEntry *se) |
| 705 | { |
| 706 | if (!skip_section_footers) { |
| 707 | qemu_put_byte(f, QEMU_VM_SECTION_FOOTER); |
| 708 | qemu_put_be32(f, se->section_id); |
| 709 | } |
| 710 | } |
| 711 | |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 712 | /** |
| 713 | * qemu_savevm_command_send: Send a 'QEMU_VM_COMMAND' type element with the |
| 714 | * command and associated data. |
| 715 | * |
| 716 | * @f: File to send command on |
| 717 | * @command: Command type to send |
| 718 | * @len: Length of associated data |
| 719 | * @data: Data associated with command. |
| 720 | */ |
| 721 | void qemu_savevm_command_send(QEMUFile *f, |
| 722 | enum qemu_vm_cmd command, |
| 723 | uint16_t len, |
| 724 | uint8_t *data) |
| 725 | { |
| 726 | trace_savevm_command_send(command, len); |
| 727 | qemu_put_byte(f, QEMU_VM_COMMAND); |
| 728 | qemu_put_be16(f, (uint16_t)command); |
| 729 | qemu_put_be16(f, len); |
| 730 | qemu_put_buffer(f, data, len); |
| 731 | qemu_fflush(f); |
| 732 | } |
| 733 | |
Dr. David Alan Gilbert | 2e37701 | 2015-11-05 18:10:46 +0000 | [diff] [blame] | 734 | void qemu_savevm_send_ping(QEMUFile *f, uint32_t value) |
| 735 | { |
| 736 | uint32_t buf; |
| 737 | |
| 738 | trace_savevm_send_ping(value); |
| 739 | buf = cpu_to_be32(value); |
| 740 | qemu_savevm_command_send(f, MIG_CMD_PING, sizeof(value), (uint8_t *)&buf); |
| 741 | } |
| 742 | |
| 743 | void qemu_savevm_send_open_return_path(QEMUFile *f) |
| 744 | { |
| 745 | trace_savevm_send_open_return_path(); |
| 746 | qemu_savevm_command_send(f, MIG_CMD_OPEN_RETURN_PATH, 0, NULL); |
| 747 | } |
| 748 | |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 749 | /* We have a buffer of data to send; we don't want that all to be loaded |
| 750 | * by the command itself, so the command contains just the length of the |
| 751 | * extra buffer that we then send straight after it. |
| 752 | * TODO: Must be a better way to organise that |
| 753 | * |
| 754 | * Returns: |
| 755 | * 0 on success |
| 756 | * -ve on error |
| 757 | */ |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 758 | int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len) |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 759 | { |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 760 | uint32_t tmp; |
| 761 | |
| 762 | if (len > MAX_VM_CMD_PACKAGED_SIZE) { |
| 763 | error_report("%s: Unreasonably large packaged state: %zu", |
| 764 | __func__, len); |
| 765 | return -1; |
| 766 | } |
| 767 | |
| 768 | tmp = cpu_to_be32(len); |
| 769 | |
| 770 | trace_qemu_savevm_send_packaged(); |
| 771 | qemu_savevm_command_send(f, MIG_CMD_PACKAGED, 4, (uint8_t *)&tmp); |
| 772 | |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 773 | qemu_put_buffer(f, buf, len); |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 774 | |
| 775 | return 0; |
| 776 | } |
| 777 | |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 778 | /* Send prior to any postcopy transfer */ |
| 779 | void qemu_savevm_send_postcopy_advise(QEMUFile *f) |
| 780 | { |
| 781 | uint64_t tmp[2]; |
| 782 | tmp[0] = cpu_to_be64(getpagesize()); |
| 783 | tmp[1] = cpu_to_be64(1ul << qemu_target_page_bits()); |
| 784 | |
| 785 | trace_qemu_savevm_send_postcopy_advise(); |
| 786 | qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 16, (uint8_t *)tmp); |
| 787 | } |
| 788 | |
| 789 | /* Sent prior to starting the destination running in postcopy, discard pages |
| 790 | * that have already been sent but redirtied on the source. |
| 791 | * CMD_POSTCOPY_RAM_DISCARD consist of: |
| 792 | * byte version (0) |
| 793 | * byte Length of name field (not including 0) |
| 794 | * n x byte RAM block name |
| 795 | * byte 0 terminator (just for safety) |
| 796 | * n x Byte ranges within the named RAMBlock |
| 797 | * be64 Start of the range |
| 798 | * be64 Length |
| 799 | * |
| 800 | * name: RAMBlock name that these entries are part of |
| 801 | * len: Number of page entries |
| 802 | * start_list: 'len' addresses |
| 803 | * length_list: 'len' addresses |
| 804 | * |
| 805 | */ |
| 806 | void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name, |
| 807 | uint16_t len, |
| 808 | uint64_t *start_list, |
| 809 | uint64_t *length_list) |
| 810 | { |
| 811 | uint8_t *buf; |
| 812 | uint16_t tmplen; |
| 813 | uint16_t t; |
| 814 | size_t name_len = strlen(name); |
| 815 | |
| 816 | trace_qemu_savevm_send_postcopy_ram_discard(name, len); |
| 817 | assert(name_len < 256); |
| 818 | buf = g_malloc0(1 + 1 + name_len + 1 + (8 + 8) * len); |
| 819 | buf[0] = postcopy_ram_discard_version; |
| 820 | buf[1] = name_len; |
| 821 | memcpy(buf + 2, name, name_len); |
| 822 | tmplen = 2 + name_len; |
| 823 | buf[tmplen++] = '\0'; |
| 824 | |
| 825 | for (t = 0; t < len; t++) { |
Peter Maydell | 4d88513 | 2016-06-10 17:09:22 +0100 | [diff] [blame] | 826 | stq_be_p(buf + tmplen, start_list[t]); |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 827 | tmplen += 8; |
Peter Maydell | 4d88513 | 2016-06-10 17:09:22 +0100 | [diff] [blame] | 828 | stq_be_p(buf + tmplen, length_list[t]); |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 829 | tmplen += 8; |
| 830 | } |
| 831 | qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RAM_DISCARD, tmplen, buf); |
| 832 | g_free(buf); |
| 833 | } |
| 834 | |
| 835 | /* Get the destination into a state where it can receive postcopy data. */ |
| 836 | void qemu_savevm_send_postcopy_listen(QEMUFile *f) |
| 837 | { |
| 838 | trace_savevm_send_postcopy_listen(); |
| 839 | qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_LISTEN, 0, NULL); |
| 840 | } |
| 841 | |
| 842 | /* Kick the destination into running */ |
| 843 | void qemu_savevm_send_postcopy_run(QEMUFile *f) |
| 844 | { |
| 845 | trace_savevm_send_postcopy_run(); |
| 846 | qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RUN, 0, NULL); |
| 847 | } |
| 848 | |
Luiz Capitulino | e1c37d0 | 2011-12-05 14:48:01 -0200 | [diff] [blame] | 849 | bool qemu_savevm_state_blocked(Error **errp) |
Alex Williamson | dc91212 | 2011-01-11 14:39:43 -0700 | [diff] [blame] | 850 | { |
| 851 | SaveStateEntry *se; |
| 852 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 853 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Marcelo Tosatti | 7d854c4 | 2014-05-14 16:30:08 -0300 | [diff] [blame] | 854 | if (se->vmsd && se->vmsd->unmigratable) { |
Cole Robinson | f231b88 | 2014-03-21 19:42:26 -0400 | [diff] [blame] | 855 | error_setg(errp, "State blocked by non-migratable device '%s'", |
| 856 | se->idstr); |
Alex Williamson | dc91212 | 2011-01-11 14:39:43 -0700 | [diff] [blame] | 857 | return true; |
| 858 | } |
| 859 | } |
| 860 | return false; |
| 861 | } |
| 862 | |
Greg Kurz | 902c053 | 2016-02-18 12:32:25 +0100 | [diff] [blame] | 863 | static bool enforce_config_section(void) |
| 864 | { |
| 865 | MachineState *machine = MACHINE(qdev_get_machine()); |
| 866 | return machine->enforce_config_section; |
| 867 | } |
| 868 | |
Dr. David Alan Gilbert | f796baa | 2015-05-21 13:24:12 +0100 | [diff] [blame] | 869 | void qemu_savevm_state_header(QEMUFile *f) |
| 870 | { |
| 871 | trace_savevm_state_header(); |
| 872 | qemu_put_be32(f, QEMU_VM_FILE_MAGIC); |
| 873 | qemu_put_be32(f, QEMU_VM_FILE_VERSION); |
Dr. David Alan Gilbert | 172dfd4 | 2015-11-05 18:10:30 +0000 | [diff] [blame] | 874 | |
Greg Kurz | 902c053 | 2016-02-18 12:32:25 +0100 | [diff] [blame] | 875 | if (!savevm_state.skip_configuration || enforce_config_section()) { |
Dr. David Alan Gilbert | 172dfd4 | 2015-11-05 18:10:30 +0000 | [diff] [blame] | 876 | qemu_put_byte(f, QEMU_VM_CONFIGURATION); |
| 877 | vmstate_save_state(f, &vmstate_configuration, &savevm_state, 0); |
| 878 | } |
| 879 | |
Dr. David Alan Gilbert | f796baa | 2015-05-21 13:24:12 +0100 | [diff] [blame] | 880 | } |
| 881 | |
Paolo Bonzini | 47c8c17 | 2013-02-22 17:36:13 +0100 | [diff] [blame] | 882 | void qemu_savevm_state_begin(QEMUFile *f, |
| 883 | const MigrationParams *params) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 884 | { |
| 885 | SaveStateEntry *se; |
Juan Quintela | 3934638 | 2011-09-22 11:02:14 +0200 | [diff] [blame] | 886 | int ret; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 887 | |
Alexey Kardashevskiy | 9013dca | 2014-03-11 10:42:29 +1100 | [diff] [blame] | 888 | trace_savevm_state_begin(); |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 889 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 890 | if (!se->ops || !se->ops->set_params) { |
lirans@il.ibm.com | c163b5c | 2009-11-02 15:40:58 +0200 | [diff] [blame] | 891 | continue; |
Isaku Yamahata | 6607ae2 | 2012-06-19 18:43:09 +0300 | [diff] [blame] | 892 | } |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 893 | se->ops->set_params(params, se->opaque); |
lirans@il.ibm.com | c163b5c | 2009-11-02 15:40:58 +0200 | [diff] [blame] | 894 | } |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 895 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 896 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Juan Quintela | d1315aa | 2012-06-28 15:11:57 +0200 | [diff] [blame] | 897 | if (!se->ops || !se->ops->save_live_setup) { |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 898 | continue; |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 899 | } |
Juan Quintela | 6bd6878 | 2012-06-27 10:59:15 +0200 | [diff] [blame] | 900 | if (se->ops && se->ops->is_active) { |
| 901 | if (!se->ops->is_active(se->opaque)) { |
| 902 | continue; |
| 903 | } |
| 904 | } |
Dr. David Alan Gilbert | ce39bfc | 2015-05-19 12:29:50 +0100 | [diff] [blame] | 905 | save_section_header(f, se, QEMU_VM_SECTION_START); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 906 | |
Juan Quintela | d1315aa | 2012-06-28 15:11:57 +0200 | [diff] [blame] | 907 | ret = se->ops->save_live_setup(f, se->opaque); |
Dr. David Alan Gilbert | f68945d | 2015-05-19 12:29:52 +0100 | [diff] [blame] | 908 | save_section_footer(f, se); |
Juan Quintela | 2975725 | 2011-10-19 15:22:18 +0200 | [diff] [blame] | 909 | if (ret < 0) { |
Paolo Bonzini | 47c8c17 | 2013-02-22 17:36:13 +0100 | [diff] [blame] | 910 | qemu_file_set_error(f, ret); |
| 911 | break; |
Juan Quintela | 2975725 | 2011-10-19 15:22:18 +0200 | [diff] [blame] | 912 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 913 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 914 | } |
| 915 | |
Juan Quintela | 3934638 | 2011-09-22 11:02:14 +0200 | [diff] [blame] | 916 | /* |
Dong Xu Wang | 07f3507 | 2011-11-22 18:06:26 +0800 | [diff] [blame] | 917 | * this function has three return values: |
Juan Quintela | 3934638 | 2011-09-22 11:02:14 +0200 | [diff] [blame] | 918 | * negative: there was one error, and we have -errno. |
| 919 | * 0 : We haven't finished, caller have to go again |
| 920 | * 1 : We have finished, we can go to complete phase |
| 921 | */ |
Dr. David Alan Gilbert | 35ecd94 | 2015-11-05 18:11:14 +0000 | [diff] [blame] | 922 | int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 923 | { |
| 924 | SaveStateEntry *se; |
| 925 | int ret = 1; |
| 926 | |
Alexey Kardashevskiy | 9013dca | 2014-03-11 10:42:29 +1100 | [diff] [blame] | 927 | trace_savevm_state_iterate(); |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 928 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Juan Quintela | 16310a3 | 2012-06-28 15:31:37 +0200 | [diff] [blame] | 929 | if (!se->ops || !se->ops->save_live_iterate) { |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 930 | continue; |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 931 | } |
Juan Quintela | 6bd6878 | 2012-06-27 10:59:15 +0200 | [diff] [blame] | 932 | if (se->ops && se->ops->is_active) { |
| 933 | if (!se->ops->is_active(se->opaque)) { |
| 934 | continue; |
| 935 | } |
| 936 | } |
Dr. David Alan Gilbert | 35ecd94 | 2015-11-05 18:11:14 +0000 | [diff] [blame] | 937 | /* |
| 938 | * In the postcopy phase, any device that doesn't know how to |
| 939 | * do postcopy should have saved it's state in the _complete |
| 940 | * call that's already run, it might get confused if we call |
| 941 | * iterate afterwards. |
| 942 | */ |
| 943 | if (postcopy && !se->ops->save_live_complete_postcopy) { |
| 944 | continue; |
| 945 | } |
Juan Quintela | aac844e | 2012-05-22 00:38:26 +0200 | [diff] [blame] | 946 | if (qemu_file_rate_limit(f)) { |
| 947 | return 0; |
| 948 | } |
Alexey Kardashevskiy | 464400f | 2014-03-07 01:33:37 +0530 | [diff] [blame] | 949 | trace_savevm_section_start(se->idstr, se->section_id); |
Dr. David Alan Gilbert | ce39bfc | 2015-05-19 12:29:50 +0100 | [diff] [blame] | 950 | |
| 951 | save_section_header(f, se, QEMU_VM_SECTION_PART); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 952 | |
Juan Quintela | 16310a3 | 2012-06-28 15:31:37 +0200 | [diff] [blame] | 953 | ret = se->ops->save_live_iterate(f, se->opaque); |
Dr. David Alan Gilbert | a5df2a0 | 2015-01-21 10:14:48 +0000 | [diff] [blame] | 954 | trace_savevm_section_end(se->idstr, se->section_id, ret); |
Dr. David Alan Gilbert | f68945d | 2015-05-19 12:29:52 +0100 | [diff] [blame] | 955 | save_section_footer(f, se); |
Juan Quintela | 517a13c | 2012-05-21 23:46:44 +0200 | [diff] [blame] | 956 | |
Paolo Bonzini | 47c8c17 | 2013-02-22 17:36:13 +0100 | [diff] [blame] | 957 | if (ret < 0) { |
| 958 | qemu_file_set_error(f, ret); |
| 959 | } |
Juan Quintela | 2975725 | 2011-10-19 15:22:18 +0200 | [diff] [blame] | 960 | if (ret <= 0) { |
Jan Kiszka | 90697be | 2009-12-01 15:19:55 +0100 | [diff] [blame] | 961 | /* Do not proceed to the next vmstate before this one reported |
| 962 | completion of the current stage. This serializes the migration |
| 963 | and reduces the probability that a faster changing state is |
| 964 | synchronized over and over again. */ |
| 965 | break; |
| 966 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 967 | } |
Juan Quintela | 3934638 | 2011-09-22 11:02:14 +0200 | [diff] [blame] | 968 | return ret; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 969 | } |
| 970 | |
Alexander Graf | 9850c60 | 2015-02-23 13:56:42 +0100 | [diff] [blame] | 971 | static bool should_send_vmdesc(void) |
| 972 | { |
| 973 | MachineState *machine = MACHINE(qdev_get_machine()); |
Dr. David Alan Gilbert | 8421b20 | 2015-11-05 18:10:59 +0000 | [diff] [blame] | 974 | bool in_postcopy = migration_in_postcopy(migrate_get_current()); |
| 975 | return !machine->suppress_vmdesc && !in_postcopy; |
Alexander Graf | 9850c60 | 2015-02-23 13:56:42 +0100 | [diff] [blame] | 976 | } |
| 977 | |
Dr. David Alan Gilbert | 763c906 | 2015-11-05 18:11:00 +0000 | [diff] [blame] | 978 | /* |
| 979 | * Calls the save_live_complete_postcopy methods |
| 980 | * causing the last few pages to be sent immediately and doing any associated |
| 981 | * cleanup. |
| 982 | * Note postcopy also calls qemu_savevm_state_complete_precopy to complete |
| 983 | * all the other devices, but that happens at the point we switch to postcopy. |
| 984 | */ |
| 985 | void qemu_savevm_state_complete_postcopy(QEMUFile *f) |
| 986 | { |
| 987 | SaveStateEntry *se; |
| 988 | int ret; |
| 989 | |
| 990 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
| 991 | if (!se->ops || !se->ops->save_live_complete_postcopy) { |
| 992 | continue; |
| 993 | } |
| 994 | if (se->ops && se->ops->is_active) { |
| 995 | if (!se->ops->is_active(se->opaque)) { |
| 996 | continue; |
| 997 | } |
| 998 | } |
| 999 | trace_savevm_section_start(se->idstr, se->section_id); |
| 1000 | /* Section type */ |
| 1001 | qemu_put_byte(f, QEMU_VM_SECTION_END); |
| 1002 | qemu_put_be32(f, se->section_id); |
| 1003 | |
| 1004 | ret = se->ops->save_live_complete_postcopy(f, se->opaque); |
| 1005 | trace_savevm_section_end(se->idstr, se->section_id, ret); |
| 1006 | save_section_footer(f, se); |
| 1007 | if (ret < 0) { |
| 1008 | qemu_file_set_error(f, ret); |
| 1009 | return; |
| 1010 | } |
| 1011 | } |
| 1012 | |
| 1013 | qemu_put_byte(f, QEMU_VM_EOF); |
| 1014 | qemu_fflush(f); |
| 1015 | } |
| 1016 | |
Dr. David Alan Gilbert | 1c0d249 | 2015-11-11 14:02:27 +0000 | [diff] [blame] | 1017 | void qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1018 | { |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 1019 | QJSON *vmdesc; |
| 1020 | int vmdesc_len; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1021 | SaveStateEntry *se; |
Juan Quintela | 2975725 | 2011-10-19 15:22:18 +0200 | [diff] [blame] | 1022 | int ret; |
Dr. David Alan Gilbert | 763c906 | 2015-11-05 18:11:00 +0000 | [diff] [blame] | 1023 | bool in_postcopy = migration_in_postcopy(migrate_get_current()); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1024 | |
Dr. David Alan Gilbert | a3e06c3 | 2015-11-05 18:10:41 +0000 | [diff] [blame] | 1025 | trace_savevm_state_complete_precopy(); |
Alexey Kardashevskiy | 9013dca | 2014-03-11 10:42:29 +1100 | [diff] [blame] | 1026 | |
Jan Kiszka | ea375f9 | 2010-03-01 19:10:30 +0100 | [diff] [blame] | 1027 | cpu_synchronize_all_states(); |
| 1028 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 1029 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Dr. David Alan Gilbert | 763c906 | 2015-11-05 18:11:00 +0000 | [diff] [blame] | 1030 | if (!se->ops || |
| 1031 | (in_postcopy && se->ops->save_live_complete_postcopy) || |
Dr. David Alan Gilbert | 1c0d249 | 2015-11-11 14:02:27 +0000 | [diff] [blame] | 1032 | (in_postcopy && !iterable_only) || |
Dr. David Alan Gilbert | 763c906 | 2015-11-05 18:11:00 +0000 | [diff] [blame] | 1033 | !se->ops->save_live_complete_precopy) { |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1034 | continue; |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 1035 | } |
Dr. David Alan Gilbert | 1c0d249 | 2015-11-11 14:02:27 +0000 | [diff] [blame] | 1036 | |
Juan Quintela | 6bd6878 | 2012-06-27 10:59:15 +0200 | [diff] [blame] | 1037 | if (se->ops && se->ops->is_active) { |
| 1038 | if (!se->ops->is_active(se->opaque)) { |
| 1039 | continue; |
| 1040 | } |
| 1041 | } |
Alexey Kardashevskiy | 464400f | 2014-03-07 01:33:37 +0530 | [diff] [blame] | 1042 | trace_savevm_section_start(se->idstr, se->section_id); |
Dr. David Alan Gilbert | ce39bfc | 2015-05-19 12:29:50 +0100 | [diff] [blame] | 1043 | |
| 1044 | save_section_header(f, se, QEMU_VM_SECTION_END); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1045 | |
Dr. David Alan Gilbert | a3e06c3 | 2015-11-05 18:10:41 +0000 | [diff] [blame] | 1046 | ret = se->ops->save_live_complete_precopy(f, se->opaque); |
Dr. David Alan Gilbert | a5df2a0 | 2015-01-21 10:14:48 +0000 | [diff] [blame] | 1047 | trace_savevm_section_end(se->idstr, se->section_id, ret); |
Dr. David Alan Gilbert | f68945d | 2015-05-19 12:29:52 +0100 | [diff] [blame] | 1048 | save_section_footer(f, se); |
Juan Quintela | 2975725 | 2011-10-19 15:22:18 +0200 | [diff] [blame] | 1049 | if (ret < 0) { |
Paolo Bonzini | 47c8c17 | 2013-02-22 17:36:13 +0100 | [diff] [blame] | 1050 | qemu_file_set_error(f, ret); |
| 1051 | return; |
Juan Quintela | 2975725 | 2011-10-19 15:22:18 +0200 | [diff] [blame] | 1052 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1053 | } |
| 1054 | |
Dr. David Alan Gilbert | 1c0d249 | 2015-11-11 14:02:27 +0000 | [diff] [blame] | 1055 | if (iterable_only) { |
| 1056 | return; |
| 1057 | } |
| 1058 | |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 1059 | vmdesc = qjson_new(); |
| 1060 | json_prop_int(vmdesc, "page_size", TARGET_PAGE_SIZE); |
| 1061 | json_start_array(vmdesc, "devices"); |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 1062 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1063 | |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 1064 | if ((!se->ops || !se->ops->save_state) && !se->vmsd) { |
Eduardo Habkost | 5cecf41 | 2013-11-28 12:01:12 -0200 | [diff] [blame] | 1065 | continue; |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 1066 | } |
Juan Quintela | df89615 | 2014-10-15 09:39:14 +0200 | [diff] [blame] | 1067 | if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) { |
| 1068 | trace_savevm_section_skip(se->idstr, se->section_id); |
| 1069 | continue; |
| 1070 | } |
| 1071 | |
Alexey Kardashevskiy | 464400f | 2014-03-07 01:33:37 +0530 | [diff] [blame] | 1072 | trace_savevm_section_start(se->idstr, se->section_id); |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 1073 | |
| 1074 | json_start_object(vmdesc, NULL); |
| 1075 | json_prop_str(vmdesc, "name", se->idstr); |
| 1076 | json_prop_int(vmdesc, "instance_id", se->instance_id); |
| 1077 | |
Dr. David Alan Gilbert | ce39bfc | 2015-05-19 12:29:50 +0100 | [diff] [blame] | 1078 | save_section_header(f, se, QEMU_VM_SECTION_FULL); |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 1079 | vmstate_save(f, se, vmdesc); |
Dr. David Alan Gilbert | a5df2a0 | 2015-01-21 10:14:48 +0000 | [diff] [blame] | 1080 | trace_savevm_section_end(se->idstr, se->section_id, 0); |
Dr. David Alan Gilbert | f68945d | 2015-05-19 12:29:52 +0100 | [diff] [blame] | 1081 | save_section_footer(f, se); |
Wei Yang | bdf46d6 | 2016-02-04 22:50:30 +0000 | [diff] [blame] | 1082 | |
| 1083 | json_end_object(vmdesc); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1084 | } |
| 1085 | |
Dr. David Alan Gilbert | 763c906 | 2015-11-05 18:11:00 +0000 | [diff] [blame] | 1086 | if (!in_postcopy) { |
| 1087 | /* Postcopy stream will still be going */ |
| 1088 | qemu_put_byte(f, QEMU_VM_EOF); |
| 1089 | } |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 1090 | |
| 1091 | json_end_array(vmdesc); |
| 1092 | qjson_finish(vmdesc); |
| 1093 | vmdesc_len = strlen(qjson_get_str(vmdesc)); |
| 1094 | |
Alexander Graf | 9850c60 | 2015-02-23 13:56:42 +0100 | [diff] [blame] | 1095 | if (should_send_vmdesc()) { |
| 1096 | qemu_put_byte(f, QEMU_VM_VMDESCRIPTION); |
| 1097 | qemu_put_be32(f, vmdesc_len); |
| 1098 | qemu_put_buffer(f, (uint8_t *)qjson_get_str(vmdesc), vmdesc_len); |
| 1099 | } |
Markus Armbruster | b72fe9e | 2016-05-04 18:49:18 +0200 | [diff] [blame] | 1100 | qjson_destroy(vmdesc); |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 1101 | |
Paolo Bonzini | edaae61 | 2013-02-22 17:36:29 +0100 | [diff] [blame] | 1102 | qemu_fflush(f); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1103 | } |
| 1104 | |
Dr. David Alan Gilbert | c31b098 | 2015-11-05 18:10:54 +0000 | [diff] [blame] | 1105 | /* Give an estimate of the amount left to be transferred, |
| 1106 | * the result is split into the amount for units that can and |
| 1107 | * for units that can't do postcopy. |
| 1108 | */ |
| 1109 | void qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size, |
| 1110 | uint64_t *res_non_postcopiable, |
| 1111 | uint64_t *res_postcopiable) |
Juan Quintela | e4ed154 | 2012-09-21 11:18:18 +0200 | [diff] [blame] | 1112 | { |
| 1113 | SaveStateEntry *se; |
Dr. David Alan Gilbert | c31b098 | 2015-11-05 18:10:54 +0000 | [diff] [blame] | 1114 | |
| 1115 | *res_non_postcopiable = 0; |
| 1116 | *res_postcopiable = 0; |
| 1117 | |
Juan Quintela | e4ed154 | 2012-09-21 11:18:18 +0200 | [diff] [blame] | 1118 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 1119 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Juan Quintela | e4ed154 | 2012-09-21 11:18:18 +0200 | [diff] [blame] | 1120 | if (!se->ops || !se->ops->save_live_pending) { |
| 1121 | continue; |
| 1122 | } |
| 1123 | if (se->ops && se->ops->is_active) { |
| 1124 | if (!se->ops->is_active(se->opaque)) { |
| 1125 | continue; |
| 1126 | } |
| 1127 | } |
Dr. David Alan Gilbert | c31b098 | 2015-11-05 18:10:54 +0000 | [diff] [blame] | 1128 | se->ops->save_live_pending(f, se->opaque, max_size, |
| 1129 | res_non_postcopiable, res_postcopiable); |
Juan Quintela | e4ed154 | 2012-09-21 11:18:18 +0200 | [diff] [blame] | 1130 | } |
Juan Quintela | e4ed154 | 2012-09-21 11:18:18 +0200 | [diff] [blame] | 1131 | } |
| 1132 | |
Liang Li | ea7415f | 2015-11-02 15:37:01 +0800 | [diff] [blame] | 1133 | void qemu_savevm_state_cleanup(void) |
Jan Kiszka | 4ec7fcc | 2009-11-30 18:21:21 +0100 | [diff] [blame] | 1134 | { |
| 1135 | SaveStateEntry *se; |
| 1136 | |
Liang Li | ea7415f | 2015-11-02 15:37:01 +0800 | [diff] [blame] | 1137 | trace_savevm_state_cleanup(); |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 1138 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Liang Li | d1a8548 | 2015-11-02 15:37:02 +0800 | [diff] [blame] | 1139 | if (se->ops && se->ops->cleanup) { |
| 1140 | se->ops->cleanup(se->opaque); |
Jan Kiszka | 4ec7fcc | 2009-11-30 18:21:21 +0100 | [diff] [blame] | 1141 | } |
| 1142 | } |
| 1143 | } |
| 1144 | |
Kevin Wolf | 5d80448 | 2015-02-10 14:25:02 +0100 | [diff] [blame] | 1145 | static int qemu_savevm_state(QEMUFile *f, Error **errp) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1146 | { |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1147 | int ret; |
Isaku Yamahata | 6607ae2 | 2012-06-19 18:43:09 +0300 | [diff] [blame] | 1148 | MigrationParams params = { |
| 1149 | .blk = 0, |
| 1150 | .shared = 0 |
| 1151 | }; |
Dr. David Alan Gilbert | aefeb18 | 2015-11-05 18:10:40 +0000 | [diff] [blame] | 1152 | MigrationState *ms = migrate_init(¶ms); |
Denis V. Lunev | 6dcf666 | 2016-06-15 18:06:43 +0300 | [diff] [blame] | 1153 | MigrationStatus status; |
zhanghailiang | 89a02a9 | 2016-01-15 11:37:42 +0800 | [diff] [blame] | 1154 | ms->to_dst_file = f; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1155 | |
Greg Kurz | 24f3902 | 2016-05-04 21:44:19 +0200 | [diff] [blame] | 1156 | if (migration_is_blocked(errp)) { |
Denis V. Lunev | 6dcf666 | 2016-06-15 18:06:43 +0300 | [diff] [blame] | 1157 | ret = -EINVAL; |
| 1158 | goto done; |
Alex Williamson | dc91212 | 2011-01-11 14:39:43 -0700 | [diff] [blame] | 1159 | } |
| 1160 | |
Paolo Bonzini | 9b09503 | 2013-02-22 17:36:28 +0100 | [diff] [blame] | 1161 | qemu_mutex_unlock_iothread(); |
Dr. David Alan Gilbert | f796baa | 2015-05-21 13:24:12 +0100 | [diff] [blame] | 1162 | qemu_savevm_state_header(f); |
Paolo Bonzini | 47c8c17 | 2013-02-22 17:36:13 +0100 | [diff] [blame] | 1163 | qemu_savevm_state_begin(f, ¶ms); |
Paolo Bonzini | 9b09503 | 2013-02-22 17:36:28 +0100 | [diff] [blame] | 1164 | qemu_mutex_lock_iothread(); |
| 1165 | |
Paolo Bonzini | 47c8c17 | 2013-02-22 17:36:13 +0100 | [diff] [blame] | 1166 | while (qemu_file_get_error(f) == 0) { |
Dr. David Alan Gilbert | 35ecd94 | 2015-11-05 18:11:14 +0000 | [diff] [blame] | 1167 | if (qemu_savevm_state_iterate(f, false) > 0) { |
Paolo Bonzini | 47c8c17 | 2013-02-22 17:36:13 +0100 | [diff] [blame] | 1168 | break; |
| 1169 | } |
| 1170 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1171 | |
Paolo Bonzini | 47c8c17 | 2013-02-22 17:36:13 +0100 | [diff] [blame] | 1172 | ret = qemu_file_get_error(f); |
Juan Quintela | 3934638 | 2011-09-22 11:02:14 +0200 | [diff] [blame] | 1173 | if (ret == 0) { |
Dr. David Alan Gilbert | 1c0d249 | 2015-11-11 14:02:27 +0000 | [diff] [blame] | 1174 | qemu_savevm_state_complete_precopy(f, false); |
Juan Quintela | 624b9cc | 2011-10-05 01:02:52 +0200 | [diff] [blame] | 1175 | ret = qemu_file_get_error(f); |
Juan Quintela | 3934638 | 2011-09-22 11:02:14 +0200 | [diff] [blame] | 1176 | } |
Denis V. Lunev | 15b3b8e | 2015-11-09 10:24:04 +0300 | [diff] [blame] | 1177 | qemu_savevm_state_cleanup(); |
Paolo Bonzini | 04943eb | 2013-02-22 17:36:10 +0100 | [diff] [blame] | 1178 | if (ret != 0) { |
Kevin Wolf | 5d80448 | 2015-02-10 14:25:02 +0100 | [diff] [blame] | 1179 | error_setg_errno(errp, -ret, "Error while writing VM state"); |
Paolo Bonzini | 04943eb | 2013-02-22 17:36:10 +0100 | [diff] [blame] | 1180 | } |
Denis V. Lunev | 6dcf666 | 2016-06-15 18:06:43 +0300 | [diff] [blame] | 1181 | |
| 1182 | done: |
| 1183 | if (ret != 0) { |
| 1184 | status = MIGRATION_STATUS_FAILED; |
| 1185 | } else { |
| 1186 | status = MIGRATION_STATUS_COMPLETED; |
| 1187 | } |
| 1188 | migrate_set_state(&ms->state, MIGRATION_STATUS_SETUP, status); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1189 | return ret; |
| 1190 | } |
| 1191 | |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 1192 | static int qemu_save_device_state(QEMUFile *f) |
| 1193 | { |
| 1194 | SaveStateEntry *se; |
| 1195 | |
| 1196 | qemu_put_be32(f, QEMU_VM_FILE_MAGIC); |
| 1197 | qemu_put_be32(f, QEMU_VM_FILE_VERSION); |
| 1198 | |
| 1199 | cpu_synchronize_all_states(); |
| 1200 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 1201 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 1202 | if (se->is_ram) { |
| 1203 | continue; |
| 1204 | } |
Juan Quintela | 22ea40f | 2012-06-26 17:19:10 +0200 | [diff] [blame] | 1205 | if ((!se->ops || !se->ops->save_state) && !se->vmsd) { |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 1206 | continue; |
| 1207 | } |
Juan Quintela | df89615 | 2014-10-15 09:39:14 +0200 | [diff] [blame] | 1208 | if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) { |
| 1209 | continue; |
| 1210 | } |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 1211 | |
Dr. David Alan Gilbert | ce39bfc | 2015-05-19 12:29:50 +0100 | [diff] [blame] | 1212 | save_section_header(f, se, QEMU_VM_SECTION_FULL); |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 1213 | |
Alexander Graf | 8118f09 | 2015-01-22 15:01:39 +0100 | [diff] [blame] | 1214 | vmstate_save(f, se, NULL); |
Dr. David Alan Gilbert | f68945d | 2015-05-19 12:29:52 +0100 | [diff] [blame] | 1215 | |
| 1216 | save_section_footer(f, se); |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 1217 | } |
| 1218 | |
| 1219 | qemu_put_byte(f, QEMU_VM_EOF); |
| 1220 | |
| 1221 | return qemu_file_get_error(f); |
| 1222 | } |
| 1223 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1224 | static SaveStateEntry *find_se(const char *idstr, int instance_id) |
| 1225 | { |
| 1226 | SaveStateEntry *se; |
| 1227 | |
Juan Quintela | 0163a2e | 2015-05-13 13:37:04 +0200 | [diff] [blame] | 1228 | QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1229 | if (!strcmp(se->idstr, idstr) && |
Jan Kiszka | 4d2ffa0 | 2010-05-15 13:32:40 +0200 | [diff] [blame] | 1230 | (instance_id == se->instance_id || |
| 1231 | instance_id == se->alias_id)) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1232 | return se; |
Alex Williamson | 7685ee6 | 2010-06-25 11:09:14 -0600 | [diff] [blame] | 1233 | /* Migrating from an older version? */ |
| 1234 | if (strstr(se->idstr, idstr) && se->compat) { |
| 1235 | if (!strcmp(se->compat->idstr, idstr) && |
| 1236 | (instance_id == se->compat->instance_id || |
| 1237 | instance_id == se->alias_id)) |
| 1238 | return se; |
| 1239 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1240 | } |
| 1241 | return NULL; |
| 1242 | } |
| 1243 | |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1244 | enum LoadVMExitCodes { |
| 1245 | /* Allow a command to quit all layers of nested loadvm loops */ |
| 1246 | LOADVM_QUIT = 1, |
| 1247 | }; |
| 1248 | |
| 1249 | static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis); |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1250 | |
| 1251 | /* ------ incoming postcopy messages ------ */ |
| 1252 | /* 'advise' arrives before any transfers just to tell us that a postcopy |
| 1253 | * *might* happen - it might be skipped if precopy transferred everything |
| 1254 | * quickly. |
| 1255 | */ |
| 1256 | static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis) |
| 1257 | { |
| 1258 | PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE); |
| 1259 | uint64_t remote_hps, remote_tps; |
| 1260 | |
| 1261 | trace_loadvm_postcopy_handle_advise(); |
| 1262 | if (ps != POSTCOPY_INCOMING_NONE) { |
| 1263 | error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps); |
| 1264 | return -1; |
| 1265 | } |
| 1266 | |
Dr. David Alan Gilbert | eb59db5 | 2015-11-05 18:10:55 +0000 | [diff] [blame] | 1267 | if (!postcopy_ram_supported_by_host()) { |
| 1268 | return -1; |
| 1269 | } |
| 1270 | |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1271 | remote_hps = qemu_get_be64(mis->from_src_file); |
| 1272 | if (remote_hps != getpagesize()) { |
| 1273 | /* |
| 1274 | * Some combinations of mismatch are probably possible but it gets |
| 1275 | * a bit more complicated. In particular we need to place whole |
| 1276 | * host pages on the dest at once, and we need to ensure that we |
| 1277 | * handle dirtying to make sure we never end up sending part of |
| 1278 | * a hostpage on it's own. |
| 1279 | */ |
| 1280 | error_report("Postcopy needs matching host page sizes (s=%d d=%d)", |
| 1281 | (int)remote_hps, getpagesize()); |
| 1282 | return -1; |
| 1283 | } |
| 1284 | |
| 1285 | remote_tps = qemu_get_be64(mis->from_src_file); |
| 1286 | if (remote_tps != (1ul << qemu_target_page_bits())) { |
| 1287 | /* |
| 1288 | * Again, some differences could be dealt with, but for now keep it |
| 1289 | * simple. |
| 1290 | */ |
| 1291 | error_report("Postcopy needs matching target page sizes (s=%d d=%d)", |
| 1292 | (int)remote_tps, 1 << qemu_target_page_bits()); |
| 1293 | return -1; |
| 1294 | } |
| 1295 | |
Dr. David Alan Gilbert | 1caddf8 | 2015-11-05 18:11:03 +0000 | [diff] [blame] | 1296 | if (ram_postcopy_incoming_init(mis)) { |
| 1297 | return -1; |
| 1298 | } |
| 1299 | |
| 1300 | postcopy_state_set(POSTCOPY_INCOMING_ADVISE); |
| 1301 | |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1302 | return 0; |
| 1303 | } |
| 1304 | |
| 1305 | /* After postcopy we will be told to throw some pages away since they're |
| 1306 | * dirty and will have to be demand fetched. Must happen before CPU is |
| 1307 | * started. |
| 1308 | * There can be 0..many of these messages, each encoding multiple pages. |
| 1309 | */ |
| 1310 | static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis, |
| 1311 | uint16_t len) |
| 1312 | { |
| 1313 | int tmp; |
| 1314 | char ramid[256]; |
| 1315 | PostcopyState ps = postcopy_state_get(); |
| 1316 | |
| 1317 | trace_loadvm_postcopy_ram_handle_discard(); |
| 1318 | |
| 1319 | switch (ps) { |
| 1320 | case POSTCOPY_INCOMING_ADVISE: |
| 1321 | /* 1st discard */ |
Dr. David Alan Gilbert | f952710 | 2015-11-05 18:11:20 +0000 | [diff] [blame] | 1322 | tmp = postcopy_ram_prepare_discard(mis); |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1323 | if (tmp) { |
| 1324 | return tmp; |
| 1325 | } |
| 1326 | break; |
| 1327 | |
| 1328 | case POSTCOPY_INCOMING_DISCARD: |
| 1329 | /* Expected state */ |
| 1330 | break; |
| 1331 | |
| 1332 | default: |
| 1333 | error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)", |
| 1334 | ps); |
| 1335 | return -1; |
| 1336 | } |
| 1337 | /* We're expecting a |
| 1338 | * Version (0) |
| 1339 | * a RAM ID string (length byte, name, 0 term) |
| 1340 | * then at least 1 16 byte chunk |
| 1341 | */ |
| 1342 | if (len < (1 + 1 + 1 + 1 + 2 * 8)) { |
| 1343 | error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len); |
| 1344 | return -1; |
| 1345 | } |
| 1346 | |
| 1347 | tmp = qemu_get_byte(mis->from_src_file); |
| 1348 | if (tmp != postcopy_ram_discard_version) { |
| 1349 | error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp); |
| 1350 | return -1; |
| 1351 | } |
| 1352 | |
| 1353 | if (!qemu_get_counted_string(mis->from_src_file, ramid)) { |
| 1354 | error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID"); |
| 1355 | return -1; |
| 1356 | } |
| 1357 | tmp = qemu_get_byte(mis->from_src_file); |
| 1358 | if (tmp != 0) { |
| 1359 | error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp); |
| 1360 | return -1; |
| 1361 | } |
| 1362 | |
| 1363 | len -= 3 + strlen(ramid); |
| 1364 | if (len % 16) { |
| 1365 | error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len); |
| 1366 | return -1; |
| 1367 | } |
| 1368 | trace_loadvm_postcopy_ram_handle_discard_header(ramid, len); |
| 1369 | while (len) { |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1370 | uint64_t start_addr, block_length; |
| 1371 | start_addr = qemu_get_be64(mis->from_src_file); |
| 1372 | block_length = qemu_get_be64(mis->from_src_file); |
| 1373 | |
| 1374 | len -= 16; |
| 1375 | int ret = ram_discard_range(mis, ramid, start_addr, |
| 1376 | block_length); |
| 1377 | if (ret) { |
| 1378 | return ret; |
| 1379 | } |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1380 | } |
| 1381 | trace_loadvm_postcopy_ram_handle_discard_end(); |
| 1382 | |
| 1383 | return 0; |
| 1384 | } |
| 1385 | |
Dr. David Alan Gilbert | c76201a | 2015-11-05 18:11:18 +0000 | [diff] [blame] | 1386 | /* |
| 1387 | * Triggered by a postcopy_listen command; this thread takes over reading |
| 1388 | * the input stream, leaving the main thread free to carry on loading the rest |
| 1389 | * of the device state (from RAM). |
| 1390 | * (TODO:This could do with being in a postcopy file - but there again it's |
| 1391 | * just another input loop, not that postcopy specific) |
| 1392 | */ |
| 1393 | static void *postcopy_ram_listen_thread(void *opaque) |
| 1394 | { |
| 1395 | QEMUFile *f = opaque; |
| 1396 | MigrationIncomingState *mis = migration_incoming_get_current(); |
| 1397 | int load_res; |
| 1398 | |
Dr. David Alan Gilbert | 6ba996b | 2015-12-16 11:47:35 +0000 | [diff] [blame] | 1399 | migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE, |
| 1400 | MIGRATION_STATUS_POSTCOPY_ACTIVE); |
Dr. David Alan Gilbert | c76201a | 2015-11-05 18:11:18 +0000 | [diff] [blame] | 1401 | qemu_sem_post(&mis->listen_thread_sem); |
| 1402 | trace_postcopy_ram_listen_thread_start(); |
| 1403 | |
| 1404 | /* |
| 1405 | * Because we're a thread and not a coroutine we can't yield |
| 1406 | * in qemu_file, and thus we must be blocking now. |
| 1407 | */ |
| 1408 | qemu_file_set_blocking(f, true); |
| 1409 | load_res = qemu_loadvm_state_main(f, mis); |
| 1410 | /* And non-blocking again so we don't block in any cleanup */ |
| 1411 | qemu_file_set_blocking(f, false); |
| 1412 | |
| 1413 | trace_postcopy_ram_listen_thread_exit(); |
| 1414 | if (load_res < 0) { |
| 1415 | error_report("%s: loadvm failed: %d", __func__, load_res); |
| 1416 | qemu_file_set_error(f, load_res); |
Dr. David Alan Gilbert | 6ba996b | 2015-12-16 11:47:35 +0000 | [diff] [blame] | 1417 | migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE, |
| 1418 | MIGRATION_STATUS_FAILED); |
Dr. David Alan Gilbert | c76201a | 2015-11-05 18:11:18 +0000 | [diff] [blame] | 1419 | } else { |
| 1420 | /* |
| 1421 | * This looks good, but it's possible that the device loading in the |
| 1422 | * main thread hasn't finished yet, and so we might not be in 'RUN' |
| 1423 | * state yet; wait for the end of the main thread. |
| 1424 | */ |
| 1425 | qemu_event_wait(&mis->main_thread_load_event); |
| 1426 | } |
| 1427 | postcopy_ram_incoming_cleanup(mis); |
Dr. David Alan Gilbert | c76201a | 2015-11-05 18:11:18 +0000 | [diff] [blame] | 1428 | |
| 1429 | if (load_res < 0) { |
| 1430 | /* |
| 1431 | * If something went wrong then we have a bad state so exit; |
| 1432 | * depending how far we got it might be possible at this point |
| 1433 | * to leave the guest running and fire MCEs for pages that never |
| 1434 | * arrived as a desperate recovery step. |
| 1435 | */ |
| 1436 | exit(EXIT_FAILURE); |
| 1437 | } |
| 1438 | |
Dr. David Alan Gilbert | 6ba996b | 2015-12-16 11:47:35 +0000 | [diff] [blame] | 1439 | migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE, |
| 1440 | MIGRATION_STATUS_COMPLETED); |
| 1441 | /* |
| 1442 | * If everything has worked fine, then the main thread has waited |
| 1443 | * for us to start, and we're the last use of the mis. |
| 1444 | * (If something broke then qemu will have to exit anyway since it's |
| 1445 | * got a bad migration state). |
| 1446 | */ |
| 1447 | migration_incoming_state_destroy(); |
| 1448 | |
| 1449 | |
Dr. David Alan Gilbert | c76201a | 2015-11-05 18:11:18 +0000 | [diff] [blame] | 1450 | return NULL; |
| 1451 | } |
| 1452 | |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1453 | /* After this message we must be able to immediately receive postcopy data */ |
| 1454 | static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis) |
| 1455 | { |
| 1456 | PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING); |
| 1457 | trace_loadvm_postcopy_handle_listen(); |
| 1458 | if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) { |
| 1459 | error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps); |
| 1460 | return -1; |
| 1461 | } |
Dr. David Alan Gilbert | f952710 | 2015-11-05 18:11:20 +0000 | [diff] [blame] | 1462 | if (ps == POSTCOPY_INCOMING_ADVISE) { |
| 1463 | /* |
| 1464 | * A rare case, we entered listen without having to do any discards, |
| 1465 | * so do the setup that's normally done at the time of the 1st discard. |
| 1466 | */ |
| 1467 | postcopy_ram_prepare_discard(mis); |
| 1468 | } |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1469 | |
Dr. David Alan Gilbert | f0a227a | 2015-11-05 18:11:04 +0000 | [diff] [blame] | 1470 | /* |
| 1471 | * Sensitise RAM - can now generate requests for blocks that don't exist |
| 1472 | * However, at this point the CPU shouldn't be running, and the IO |
| 1473 | * shouldn't be doing anything yet so don't actually expect requests |
| 1474 | */ |
| 1475 | if (postcopy_ram_enable_notify(mis)) { |
| 1476 | return -1; |
| 1477 | } |
| 1478 | |
Dr. David Alan Gilbert | c76201a | 2015-11-05 18:11:18 +0000 | [diff] [blame] | 1479 | if (mis->have_listen_thread) { |
| 1480 | error_report("CMD_POSTCOPY_RAM_LISTEN already has a listen thread"); |
| 1481 | return -1; |
| 1482 | } |
| 1483 | |
| 1484 | mis->have_listen_thread = true; |
| 1485 | /* Start up the listening thread and wait for it to signal ready */ |
| 1486 | qemu_sem_init(&mis->listen_thread_sem, 0); |
| 1487 | qemu_thread_create(&mis->listen_thread, "postcopy/listen", |
| 1488 | postcopy_ram_listen_thread, mis->from_src_file, |
Dr. David Alan Gilbert | a587a3f | 2016-03-11 09:53:35 +0000 | [diff] [blame] | 1489 | QEMU_THREAD_DETACHED); |
Dr. David Alan Gilbert | c76201a | 2015-11-05 18:11:18 +0000 | [diff] [blame] | 1490 | qemu_sem_wait(&mis->listen_thread_sem); |
| 1491 | qemu_sem_destroy(&mis->listen_thread_sem); |
| 1492 | |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1493 | return 0; |
| 1494 | } |
| 1495 | |
Denis V. Lunev | 8646992 | 2016-03-09 18:35:08 +0300 | [diff] [blame] | 1496 | |
| 1497 | typedef struct { |
| 1498 | QEMUBH *bh; |
| 1499 | } HandleRunBhData; |
| 1500 | |
Denis V. Lunev | ea6a55b | 2016-02-24 11:53:39 +0300 | [diff] [blame] | 1501 | static void loadvm_postcopy_handle_run_bh(void *opaque) |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1502 | { |
Dr. David Alan Gilbert | 27c6825 | 2015-11-05 18:11:19 +0000 | [diff] [blame] | 1503 | Error *local_err = NULL; |
Denis V. Lunev | 8646992 | 2016-03-09 18:35:08 +0300 | [diff] [blame] | 1504 | HandleRunBhData *data = opaque; |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1505 | |
Dr. David Alan Gilbert | 27c6825 | 2015-11-05 18:11:19 +0000 | [diff] [blame] | 1506 | /* TODO we should move all of this lot into postcopy_ram.c or a shared code |
| 1507 | * in migration.c |
| 1508 | */ |
| 1509 | cpu_synchronize_all_post_init(); |
| 1510 | |
| 1511 | qemu_announce_self(); |
| 1512 | |
| 1513 | /* Make sure all file formats flush their mutable metadata */ |
| 1514 | bdrv_invalidate_cache_all(&local_err); |
| 1515 | if (local_err) { |
| 1516 | error_report_err(local_err); |
Dr. David Alan Gilbert | 27c6825 | 2015-11-05 18:11:19 +0000 | [diff] [blame] | 1517 | } |
| 1518 | |
| 1519 | trace_loadvm_postcopy_handle_run_cpu_sync(); |
| 1520 | cpu_synchronize_all_post_init(); |
| 1521 | |
| 1522 | trace_loadvm_postcopy_handle_run_vmstart(); |
| 1523 | |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1524 | if (autostart) { |
| 1525 | /* Hold onto your hats, starting the CPU */ |
| 1526 | vm_start(); |
| 1527 | } else { |
| 1528 | /* leave it paused and let management decide when to start the CPU */ |
| 1529 | runstate_set(RUN_STATE_PAUSED); |
| 1530 | } |
| 1531 | |
Denis V. Lunev | 8646992 | 2016-03-09 18:35:08 +0300 | [diff] [blame] | 1532 | qemu_bh_delete(data->bh); |
| 1533 | g_free(data); |
Denis V. Lunev | ea6a55b | 2016-02-24 11:53:39 +0300 | [diff] [blame] | 1534 | } |
| 1535 | |
| 1536 | /* After all discards we can start running and asking for pages */ |
| 1537 | static int loadvm_postcopy_handle_run(MigrationIncomingState *mis) |
| 1538 | { |
| 1539 | PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_RUNNING); |
Denis V. Lunev | 8646992 | 2016-03-09 18:35:08 +0300 | [diff] [blame] | 1540 | HandleRunBhData *data; |
Denis V. Lunev | ea6a55b | 2016-02-24 11:53:39 +0300 | [diff] [blame] | 1541 | |
| 1542 | trace_loadvm_postcopy_handle_run(); |
| 1543 | if (ps != POSTCOPY_INCOMING_LISTENING) { |
| 1544 | error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps); |
| 1545 | return -1; |
| 1546 | } |
| 1547 | |
Denis V. Lunev | 8646992 | 2016-03-09 18:35:08 +0300 | [diff] [blame] | 1548 | data = g_new(HandleRunBhData, 1); |
| 1549 | data->bh = qemu_bh_new(loadvm_postcopy_handle_run_bh, data); |
| 1550 | qemu_bh_schedule(data->bh); |
Denis V. Lunev | ea6a55b | 2016-02-24 11:53:39 +0300 | [diff] [blame] | 1551 | |
Dr. David Alan Gilbert | 27c6825 | 2015-11-05 18:11:19 +0000 | [diff] [blame] | 1552 | /* We need to finish reading the stream from the package |
| 1553 | * and also stop reading anything more from the stream that loaded the |
| 1554 | * package (since it's now being read by the listener thread). |
| 1555 | * LOADVM_QUIT will quit all the layers of nested loadvm loops. |
| 1556 | */ |
| 1557 | return LOADVM_QUIT; |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1558 | } |
| 1559 | |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 1560 | /** |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1561 | * Immediately following this command is a blob of data containing an embedded |
| 1562 | * chunk of migration stream; read it and load it. |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 1563 | * |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1564 | * @mis: Incoming state |
| 1565 | * @length: Length of packaged data to read |
| 1566 | * |
| 1567 | * Returns: Negative values on error |
| 1568 | * |
| 1569 | */ |
| 1570 | static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis) |
| 1571 | { |
| 1572 | int ret; |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 1573 | size_t length; |
| 1574 | QIOChannelBuffer *bioc; |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1575 | |
| 1576 | length = qemu_get_be32(mis->from_src_file); |
| 1577 | trace_loadvm_handle_cmd_packaged(length); |
| 1578 | |
| 1579 | if (length > MAX_VM_CMD_PACKAGED_SIZE) { |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 1580 | error_report("Unreasonably large packaged state: %zu", length); |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1581 | return -1; |
| 1582 | } |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 1583 | |
| 1584 | bioc = qio_channel_buffer_new(length); |
| 1585 | ret = qemu_get_buffer(mis->from_src_file, |
| 1586 | bioc->data, |
| 1587 | length); |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1588 | if (ret != length) { |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 1589 | object_unref(OBJECT(bioc)); |
| 1590 | error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu", |
Markus Armbruster | 9af9e0f | 2015-12-18 16:35:19 +0100 | [diff] [blame] | 1591 | ret, length); |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1592 | return (ret < 0) ? ret : -EAGAIN; |
| 1593 | } |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 1594 | bioc->usage += length; |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1595 | trace_loadvm_handle_cmd_packaged_received(ret); |
| 1596 | |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 1597 | QEMUFile *packf = qemu_fopen_channel_input(QIO_CHANNEL(bioc)); |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1598 | |
| 1599 | ret = qemu_loadvm_state_main(packf, mis); |
| 1600 | trace_loadvm_handle_cmd_packaged_main(ret); |
| 1601 | qemu_fclose(packf); |
Daniel P. Berrange | 61b67d4 | 2016-04-27 11:05:01 +0100 | [diff] [blame] | 1602 | object_unref(OBJECT(bioc)); |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1603 | |
| 1604 | return ret; |
| 1605 | } |
| 1606 | |
| 1607 | /* |
| 1608 | * Process an incoming 'QEMU_VM_COMMAND' |
| 1609 | * 0 just a normal return |
| 1610 | * LOADVM_QUIT All good, but exit the loop |
| 1611 | * <0 Error |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 1612 | */ |
| 1613 | static int loadvm_process_command(QEMUFile *f) |
| 1614 | { |
Dr. David Alan Gilbert | 2e37701 | 2015-11-05 18:10:46 +0000 | [diff] [blame] | 1615 | MigrationIncomingState *mis = migration_incoming_get_current(); |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 1616 | uint16_t cmd; |
| 1617 | uint16_t len; |
Dr. David Alan Gilbert | 2e37701 | 2015-11-05 18:10:46 +0000 | [diff] [blame] | 1618 | uint32_t tmp32; |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 1619 | |
| 1620 | cmd = qemu_get_be16(f); |
| 1621 | len = qemu_get_be16(f); |
| 1622 | |
| 1623 | trace_loadvm_process_command(cmd, len); |
| 1624 | if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) { |
| 1625 | error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len); |
| 1626 | return -EINVAL; |
| 1627 | } |
| 1628 | |
| 1629 | if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) { |
| 1630 | error_report("%s received with bad length - expecting %zu, got %d", |
| 1631 | mig_cmd_args[cmd].name, |
| 1632 | (size_t)mig_cmd_args[cmd].len, len); |
| 1633 | return -ERANGE; |
| 1634 | } |
| 1635 | |
| 1636 | switch (cmd) { |
Dr. David Alan Gilbert | 2e37701 | 2015-11-05 18:10:46 +0000 | [diff] [blame] | 1637 | case MIG_CMD_OPEN_RETURN_PATH: |
| 1638 | if (mis->to_src_file) { |
| 1639 | error_report("CMD_OPEN_RETURN_PATH called when RP already open"); |
| 1640 | /* Not really a problem, so don't give up */ |
| 1641 | return 0; |
| 1642 | } |
| 1643 | mis->to_src_file = qemu_file_get_return_path(f); |
| 1644 | if (!mis->to_src_file) { |
| 1645 | error_report("CMD_OPEN_RETURN_PATH failed"); |
| 1646 | return -1; |
| 1647 | } |
| 1648 | break; |
| 1649 | |
| 1650 | case MIG_CMD_PING: |
| 1651 | tmp32 = qemu_get_be32(f); |
| 1652 | trace_loadvm_process_command_ping(tmp32); |
| 1653 | if (!mis->to_src_file) { |
| 1654 | error_report("CMD_PING (0x%x) received with no return path", |
| 1655 | tmp32); |
| 1656 | return -1; |
| 1657 | } |
Dr. David Alan Gilbert | 6decec9 | 2015-11-05 18:10:47 +0000 | [diff] [blame] | 1658 | migrate_send_rp_pong(mis, tmp32); |
Dr. David Alan Gilbert | 2e37701 | 2015-11-05 18:10:46 +0000 | [diff] [blame] | 1659 | break; |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1660 | |
Dr. David Alan Gilbert | 11cf1d9 | 2015-11-05 18:10:53 +0000 | [diff] [blame] | 1661 | case MIG_CMD_PACKAGED: |
| 1662 | return loadvm_handle_cmd_packaged(mis); |
| 1663 | |
Dr. David Alan Gilbert | 093e3c4 | 2015-11-05 18:10:52 +0000 | [diff] [blame] | 1664 | case MIG_CMD_POSTCOPY_ADVISE: |
| 1665 | return loadvm_postcopy_handle_advise(mis); |
| 1666 | |
| 1667 | case MIG_CMD_POSTCOPY_LISTEN: |
| 1668 | return loadvm_postcopy_handle_listen(mis); |
| 1669 | |
| 1670 | case MIG_CMD_POSTCOPY_RUN: |
| 1671 | return loadvm_postcopy_handle_run(mis); |
| 1672 | |
| 1673 | case MIG_CMD_POSTCOPY_RAM_DISCARD: |
| 1674 | return loadvm_postcopy_ram_handle_discard(mis, len); |
Dr. David Alan Gilbert | c76ca18 | 2015-11-05 18:10:45 +0000 | [diff] [blame] | 1675 | } |
| 1676 | |
| 1677 | return 0; |
| 1678 | } |
| 1679 | |
Dr. David Alan Gilbert | 1a8f46f | 2015-05-21 13:24:16 +0100 | [diff] [blame] | 1680 | struct LoadStateEntry { |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1681 | QLIST_ENTRY(LoadStateEntry) entry; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1682 | SaveStateEntry *se; |
| 1683 | int section_id; |
| 1684 | int version_id; |
Dr. David Alan Gilbert | 1a8f46f | 2015-05-21 13:24:16 +0100 | [diff] [blame] | 1685 | }; |
| 1686 | |
Dr. David Alan Gilbert | 59f39a4 | 2015-07-02 09:22:03 +0100 | [diff] [blame] | 1687 | /* |
| 1688 | * Read a footer off the wire and check that it matches the expected section |
| 1689 | * |
| 1690 | * Returns: true if the footer was good |
| 1691 | * false if there is a problem (and calls error_report to say why) |
| 1692 | */ |
| 1693 | static bool check_section_footer(QEMUFile *f, LoadStateEntry *le) |
| 1694 | { |
| 1695 | uint8_t read_mark; |
| 1696 | uint32_t read_section_id; |
| 1697 | |
| 1698 | if (skip_section_footers) { |
| 1699 | /* No footer to check */ |
| 1700 | return true; |
| 1701 | } |
| 1702 | |
| 1703 | read_mark = qemu_get_byte(f); |
| 1704 | |
| 1705 | if (read_mark != QEMU_VM_SECTION_FOOTER) { |
| 1706 | error_report("Missing section footer for %s", le->se->idstr); |
| 1707 | return false; |
| 1708 | } |
| 1709 | |
| 1710 | read_section_id = qemu_get_be32(f); |
| 1711 | if (read_section_id != le->section_id) { |
| 1712 | error_report("Mismatched section id in footer for %s -" |
| 1713 | " read 0x%x expected 0x%x", |
| 1714 | le->se->idstr, read_section_id, le->section_id); |
| 1715 | return false; |
| 1716 | } |
| 1717 | |
| 1718 | /* All good */ |
| 1719 | return true; |
| 1720 | } |
| 1721 | |
Dr. David Alan Gilbert | 1a8f46f | 2015-05-21 13:24:16 +0100 | [diff] [blame] | 1722 | void loadvm_free_handlers(MigrationIncomingState *mis) |
| 1723 | { |
| 1724 | LoadStateEntry *le, *new_le; |
| 1725 | |
| 1726 | QLIST_FOREACH_SAFE(le, &mis->loadvm_handlers, entry, new_le) { |
| 1727 | QLIST_REMOVE(le, entry); |
| 1728 | g_free(le); |
| 1729 | } |
| 1730 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1731 | |
zhanghailiang | fb3520a | 2016-01-15 11:37:43 +0800 | [diff] [blame] | 1732 | static int |
| 1733 | qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis) |
| 1734 | { |
| 1735 | uint32_t instance_id, version_id, section_id; |
| 1736 | SaveStateEntry *se; |
| 1737 | LoadStateEntry *le; |
| 1738 | char idstr[256]; |
| 1739 | int ret; |
| 1740 | |
| 1741 | /* Read section start */ |
| 1742 | section_id = qemu_get_be32(f); |
| 1743 | if (!qemu_get_counted_string(f, idstr)) { |
| 1744 | error_report("Unable to read ID string for section %u", |
| 1745 | section_id); |
| 1746 | return -EINVAL; |
| 1747 | } |
| 1748 | instance_id = qemu_get_be32(f); |
| 1749 | version_id = qemu_get_be32(f); |
| 1750 | |
| 1751 | trace_qemu_loadvm_state_section_startfull(section_id, idstr, |
| 1752 | instance_id, version_id); |
| 1753 | /* Find savevm section */ |
| 1754 | se = find_se(idstr, instance_id); |
| 1755 | if (se == NULL) { |
| 1756 | error_report("Unknown savevm section or instance '%s' %d", |
| 1757 | idstr, instance_id); |
| 1758 | return -EINVAL; |
| 1759 | } |
| 1760 | |
| 1761 | /* Validate version */ |
| 1762 | if (version_id > se->version_id) { |
| 1763 | error_report("savevm: unsupported version %d for '%s' v%d", |
| 1764 | version_id, idstr, se->version_id); |
| 1765 | return -EINVAL; |
| 1766 | } |
| 1767 | |
Wen Congyang | 88c1656 | 2016-06-03 17:58:34 +0800 | [diff] [blame] | 1768 | /* Validate if it is a device's state */ |
| 1769 | if (xen_enabled() && se->is_ram) { |
| 1770 | error_report("loadvm: %s RAM loading not allowed on Xen", idstr); |
| 1771 | return -EINVAL; |
| 1772 | } |
| 1773 | |
zhanghailiang | fb3520a | 2016-01-15 11:37:43 +0800 | [diff] [blame] | 1774 | /* Add entry */ |
| 1775 | le = g_malloc0(sizeof(*le)); |
| 1776 | |
| 1777 | le->se = se; |
| 1778 | le->section_id = section_id; |
| 1779 | le->version_id = version_id; |
| 1780 | QLIST_INSERT_HEAD(&mis->loadvm_handlers, le, entry); |
| 1781 | |
| 1782 | ret = vmstate_load(f, le->se, le->version_id); |
| 1783 | if (ret < 0) { |
| 1784 | error_report("error while loading state for instance 0x%x of" |
| 1785 | " device '%s'", instance_id, idstr); |
| 1786 | return ret; |
| 1787 | } |
| 1788 | if (!check_section_footer(f, le)) { |
| 1789 | return -EINVAL; |
| 1790 | } |
| 1791 | |
| 1792 | return 0; |
| 1793 | } |
| 1794 | |
| 1795 | static int |
| 1796 | qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis) |
| 1797 | { |
| 1798 | uint32_t section_id; |
| 1799 | LoadStateEntry *le; |
| 1800 | int ret; |
| 1801 | |
| 1802 | section_id = qemu_get_be32(f); |
| 1803 | |
| 1804 | trace_qemu_loadvm_state_section_partend(section_id); |
| 1805 | QLIST_FOREACH(le, &mis->loadvm_handlers, entry) { |
| 1806 | if (le->section_id == section_id) { |
| 1807 | break; |
| 1808 | } |
| 1809 | } |
| 1810 | if (le == NULL) { |
| 1811 | error_report("Unknown savevm section %d", section_id); |
| 1812 | return -EINVAL; |
| 1813 | } |
| 1814 | |
| 1815 | ret = vmstate_load(f, le->se, le->version_id); |
| 1816 | if (ret < 0) { |
| 1817 | error_report("error while loading state section id %d(%s)", |
| 1818 | section_id, le->se->idstr); |
| 1819 | return ret; |
| 1820 | } |
| 1821 | if (!check_section_footer(f, le)) { |
| 1822 | return -EINVAL; |
| 1823 | } |
| 1824 | |
| 1825 | return 0; |
| 1826 | } |
| 1827 | |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1828 | static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis) |
| 1829 | { |
| 1830 | uint8_t section_type; |
| 1831 | int ret; |
| 1832 | |
| 1833 | while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) { |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1834 | |
| 1835 | trace_qemu_loadvm_state_section(section_type); |
| 1836 | switch (section_type) { |
| 1837 | case QEMU_VM_SECTION_START: |
| 1838 | case QEMU_VM_SECTION_FULL: |
zhanghailiang | fb3520a | 2016-01-15 11:37:43 +0800 | [diff] [blame] | 1839 | ret = qemu_loadvm_section_start_full(f, mis); |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1840 | if (ret < 0) { |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1841 | return ret; |
| 1842 | } |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1843 | break; |
| 1844 | case QEMU_VM_SECTION_PART: |
| 1845 | case QEMU_VM_SECTION_END: |
zhanghailiang | fb3520a | 2016-01-15 11:37:43 +0800 | [diff] [blame] | 1846 | ret = qemu_loadvm_section_part_end(f, mis); |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1847 | if (ret < 0) { |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1848 | return ret; |
| 1849 | } |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1850 | break; |
| 1851 | case QEMU_VM_COMMAND: |
| 1852 | ret = loadvm_process_command(f); |
| 1853 | trace_qemu_loadvm_state_section_command(ret); |
| 1854 | if ((ret < 0) || (ret & LOADVM_QUIT)) { |
| 1855 | return ret; |
| 1856 | } |
| 1857 | break; |
| 1858 | default: |
| 1859 | error_report("Unknown savevm section type %d", section_type); |
| 1860 | return -EINVAL; |
| 1861 | } |
| 1862 | } |
| 1863 | |
| 1864 | return 0; |
| 1865 | } |
| 1866 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1867 | int qemu_loadvm_state(QEMUFile *f) |
| 1868 | { |
Dr. David Alan Gilbert | 1a8f46f | 2015-05-21 13:24:16 +0100 | [diff] [blame] | 1869 | MigrationIncomingState *mis = migration_incoming_get_current(); |
Dr. David Alan Gilbert | 0457d07 | 2015-01-21 10:14:49 +0000 | [diff] [blame] | 1870 | Error *local_err = NULL; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1871 | unsigned int v; |
| 1872 | int ret; |
| 1873 | |
Dr. David Alan Gilbert | 0457d07 | 2015-01-21 10:14:49 +0000 | [diff] [blame] | 1874 | if (qemu_savevm_state_blocked(&local_err)) { |
zhanghailiang | 1986754 | 2015-03-04 18:25:54 +0800 | [diff] [blame] | 1875 | error_report_err(local_err); |
Alex Williamson | dc91212 | 2011-01-11 14:39:43 -0700 | [diff] [blame] | 1876 | return -EINVAL; |
| 1877 | } |
| 1878 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1879 | v = qemu_get_be32(f); |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 1880 | if (v != QEMU_VM_FILE_MAGIC) { |
Dr. David Alan Gilbert | 0457d07 | 2015-01-21 10:14:49 +0000 | [diff] [blame] | 1881 | error_report("Not a migration stream"); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1882 | return -EINVAL; |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 1883 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1884 | |
| 1885 | v = qemu_get_be32(f); |
Juan Quintela | bbfe140 | 2009-09-10 03:04:24 +0200 | [diff] [blame] | 1886 | if (v == QEMU_VM_FILE_VERSION_COMPAT) { |
Dr. David Alan Gilbert | 6a64b64 | 2015-01-21 10:14:47 +0000 | [diff] [blame] | 1887 | error_report("SaveVM v2 format is obsolete and don't work anymore"); |
Juan Quintela | bbfe140 | 2009-09-10 03:04:24 +0200 | [diff] [blame] | 1888 | return -ENOTSUP; |
| 1889 | } |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 1890 | if (v != QEMU_VM_FILE_VERSION) { |
Dr. David Alan Gilbert | 0457d07 | 2015-01-21 10:14:49 +0000 | [diff] [blame] | 1891 | error_report("Unsupported migration stream version"); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1892 | return -ENOTSUP; |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 1893 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1894 | |
Greg Kurz | 902c053 | 2016-02-18 12:32:25 +0100 | [diff] [blame] | 1895 | if (!savevm_state.skip_configuration || enforce_config_section()) { |
Juan Quintela | 61964c2 | 2015-05-13 18:17:43 +0200 | [diff] [blame] | 1896 | if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) { |
| 1897 | error_report("Configuration section missing"); |
| 1898 | return -EINVAL; |
| 1899 | } |
| 1900 | ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0); |
| 1901 | |
| 1902 | if (ret) { |
| 1903 | return ret; |
| 1904 | } |
| 1905 | } |
| 1906 | |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1907 | ret = qemu_loadvm_state_main(f, mis); |
| 1908 | qemu_event_set(&mis->main_thread_load_event); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1909 | |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1910 | trace_qemu_loadvm_state_post_main(ret); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1911 | |
Dr. David Alan Gilbert | c76201a | 2015-11-05 18:11:18 +0000 | [diff] [blame] | 1912 | if (mis->have_listen_thread) { |
| 1913 | /* Listen thread still going, can't clean up yet */ |
| 1914 | return ret; |
| 1915 | } |
| 1916 | |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1917 | if (ret == 0) { |
| 1918 | ret = qemu_file_get_error(f); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1919 | } |
| 1920 | |
Alexander Graf | 1925ceb | 2015-02-23 13:56:41 +0100 | [diff] [blame] | 1921 | /* |
| 1922 | * Try to read in the VMDESC section as well, so that dumping tools that |
| 1923 | * intercept our migration stream have the chance to see it. |
| 1924 | */ |
Alexander Graf | 1925ceb | 2015-02-23 13:56:41 +0100 | [diff] [blame] | 1925 | |
Dr. David Alan Gilbert | 1aca9a5 | 2015-06-23 17:34:35 +0100 | [diff] [blame] | 1926 | /* We've got to be careful; if we don't read the data and just shut the fd |
| 1927 | * then the sender can error if we close while it's still sending. |
| 1928 | * We also mustn't read data that isn't there; some transports (RDMA) |
| 1929 | * will stall waiting for that data when the source has already closed. |
| 1930 | */ |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1931 | if (ret == 0 && should_send_vmdesc()) { |
Dr. David Alan Gilbert | 1aca9a5 | 2015-06-23 17:34:35 +0100 | [diff] [blame] | 1932 | uint8_t *buf; |
| 1933 | uint32_t size; |
Dr. David Alan Gilbert | 7b89bf2 | 2015-11-05 18:10:50 +0000 | [diff] [blame] | 1934 | uint8_t section_type = qemu_get_byte(f); |
Dr. David Alan Gilbert | 1aca9a5 | 2015-06-23 17:34:35 +0100 | [diff] [blame] | 1935 | |
| 1936 | if (section_type != QEMU_VM_VMDESCRIPTION) { |
| 1937 | error_report("Expected vmdescription section, but got %d", |
| 1938 | section_type); |
| 1939 | /* |
| 1940 | * It doesn't seem worth failing at this point since |
| 1941 | * we apparently have an otherwise valid VM state |
| 1942 | */ |
| 1943 | } else { |
| 1944 | buf = g_malloc(0x1000); |
| 1945 | size = qemu_get_be32(f); |
| 1946 | |
| 1947 | while (size > 0) { |
| 1948 | uint32_t read_chunk = MIN(size, 0x1000); |
| 1949 | qemu_get_buffer(f, buf, read_chunk); |
| 1950 | size -= read_chunk; |
| 1951 | } |
| 1952 | g_free(buf); |
Alexander Graf | 1925ceb | 2015-02-23 13:56:41 +0100 | [diff] [blame] | 1953 | } |
Alexander Graf | 1925ceb | 2015-02-23 13:56:41 +0100 | [diff] [blame] | 1954 | } |
| 1955 | |
Jan Kiszka | ea375f9 | 2010-03-01 19:10:30 +0100 | [diff] [blame] | 1956 | cpu_synchronize_all_post_init(); |
| 1957 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1958 | return ret; |
| 1959 | } |
| 1960 | |
Markus Armbruster | 3e5a50d | 2015-02-06 13:55:43 +0100 | [diff] [blame] | 1961 | void hmp_savevm(Monitor *mon, const QDict *qdict) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1962 | { |
| 1963 | BlockDriverState *bs, *bs1; |
| 1964 | QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1; |
Kevin Wolf | cb499fb | 2009-11-03 17:34:37 +0100 | [diff] [blame] | 1965 | int ret; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1966 | QEMUFile *f; |
| 1967 | int saved_vm_running; |
Kevin Wolf | c2c9a46 | 2011-11-16 11:35:54 +0100 | [diff] [blame] | 1968 | uint64_t vm_state_size; |
Stefan Weil | 68b891e | 2013-01-07 22:20:27 +0100 | [diff] [blame] | 1969 | qemu_timeval tv; |
Miguel Di Ciurcio Filho | 7d631a1 | 2010-08-04 14:55:49 -0300 | [diff] [blame] | 1970 | struct tm tm; |
Luiz Capitulino | d54908a | 2009-08-28 15:27:13 -0300 | [diff] [blame] | 1971 | const char *name = qdict_get_try_str(qdict, "name"); |
Kevin Wolf | 5d80448 | 2015-02-10 14:25:02 +0100 | [diff] [blame] | 1972 | Error *local_err = NULL; |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 1973 | AioContext *aio_context; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1974 | |
Denis V. Lunev | e9ff957 | 2015-11-19 09:42:01 +0300 | [diff] [blame] | 1975 | if (!bdrv_all_can_snapshot(&bs)) { |
| 1976 | monitor_printf(mon, "Device '%s' is writable but does not " |
| 1977 | "support snapshots.\n", bdrv_get_device_name(bs)); |
| 1978 | return; |
Miguel Di Ciurcio Filho | feeee5a | 2010-06-08 10:40:55 -0300 | [diff] [blame] | 1979 | } |
| 1980 | |
Denis V. Lunev | 0b46160 | 2015-11-19 09:42:09 +0300 | [diff] [blame] | 1981 | /* Delete old snapshots of the same name */ |
| 1982 | if (name && bdrv_all_delete_snapshot(name, &bs1, &local_err) < 0) { |
Markus Armbruster | d410fe1 | 2015-12-18 16:35:17 +0100 | [diff] [blame] | 1983 | error_reportf_err(local_err, |
| 1984 | "Error while deleting snapshot on device '%s': ", |
| 1985 | bdrv_get_device_name(bs1)); |
Denis V. Lunev | 0b46160 | 2015-11-19 09:42:09 +0300 | [diff] [blame] | 1986 | return; |
| 1987 | } |
| 1988 | |
Denis V. Lunev | 7cb1448 | 2015-11-19 09:42:10 +0300 | [diff] [blame] | 1989 | bs = bdrv_all_find_vmstate_bs(); |
| 1990 | if (bs == NULL) { |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1991 | monitor_printf(mon, "No block device can accept snapshots\n"); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1992 | return; |
| 1993 | } |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 1994 | aio_context = bdrv_get_aio_context(bs); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 1995 | |
Luiz Capitulino | 1354869 | 2011-07-29 15:36:43 -0300 | [diff] [blame] | 1996 | saved_vm_running = runstate_is_running(); |
Juan Quintela | 560d027 | 2015-07-15 09:53:46 +0200 | [diff] [blame] | 1997 | |
| 1998 | ret = global_state_store(); |
| 1999 | if (ret) { |
| 2000 | monitor_printf(mon, "Error saving global state\n"); |
| 2001 | return; |
| 2002 | } |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 2003 | vm_stop(RUN_STATE_SAVE_VM); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2004 | |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2005 | aio_context_acquire(aio_context); |
| 2006 | |
Kevin Wolf | cb499fb | 2009-11-03 17:34:37 +0100 | [diff] [blame] | 2007 | memset(sn, 0, sizeof(*sn)); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2008 | |
| 2009 | /* fill auxiliary fields */ |
Stefan Weil | 68b891e | 2013-01-07 22:20:27 +0100 | [diff] [blame] | 2010 | qemu_gettimeofday(&tv); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2011 | sn->date_sec = tv.tv_sec; |
| 2012 | sn->date_nsec = tv.tv_usec * 1000; |
Alex Bligh | bc72ad6 | 2013-08-21 16:03:08 +0100 | [diff] [blame] | 2013 | sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2014 | |
Miguel Di Ciurcio Filho | 7d631a1 | 2010-08-04 14:55:49 -0300 | [diff] [blame] | 2015 | if (name) { |
| 2016 | ret = bdrv_snapshot_find(bs, old_sn, name); |
| 2017 | if (ret >= 0) { |
| 2018 | pstrcpy(sn->name, sizeof(sn->name), old_sn->name); |
| 2019 | pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str); |
| 2020 | } else { |
| 2021 | pstrcpy(sn->name, sizeof(sn->name), name); |
| 2022 | } |
| 2023 | } else { |
Blue Swirl | d7d9b52 | 2010-09-09 19:13:04 +0000 | [diff] [blame] | 2024 | /* cast below needed for OpenBSD where tv_sec is still 'long' */ |
| 2025 | localtime_r((const time_t *)&tv.tv_sec, &tm); |
Miguel Di Ciurcio Filho | 7d631a1 | 2010-08-04 14:55:49 -0300 | [diff] [blame] | 2026 | strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm); |
Miguel Di Ciurcio Filho | 7d631a1 | 2010-08-04 14:55:49 -0300 | [diff] [blame] | 2027 | } |
| 2028 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2029 | /* save the VM state */ |
Christoph Hellwig | 45566e9 | 2009-07-10 23:11:57 +0200 | [diff] [blame] | 2030 | f = qemu_fopen_bdrv(bs, 1); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2031 | if (!f) { |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 2032 | monitor_printf(mon, "Could not open VM state file\n"); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2033 | goto the_end; |
| 2034 | } |
Kevin Wolf | 5d80448 | 2015-02-10 14:25:02 +0100 | [diff] [blame] | 2035 | ret = qemu_savevm_state(f, &local_err); |
aliguori | 2d22b18 | 2008-12-11 21:06:49 +0000 | [diff] [blame] | 2036 | vm_state_size = qemu_ftell(f); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2037 | qemu_fclose(f); |
| 2038 | if (ret < 0) { |
Markus Armbruster | 193227f | 2015-12-18 16:35:06 +0100 | [diff] [blame] | 2039 | error_report_err(local_err); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2040 | goto the_end; |
| 2041 | } |
| 2042 | |
Denis V. Lunev | a9085f9 | 2015-11-19 09:42:08 +0300 | [diff] [blame] | 2043 | ret = bdrv_all_create_snapshot(sn, bs, vm_state_size, &bs); |
| 2044 | if (ret < 0) { |
| 2045 | monitor_printf(mon, "Error while creating snapshot on '%s'\n", |
| 2046 | bdrv_get_device_name(bs)); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2047 | } |
| 2048 | |
| 2049 | the_end: |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2050 | aio_context_release(aio_context); |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 2051 | if (saved_vm_running) { |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2052 | vm_start(); |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 2053 | } |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2054 | } |
| 2055 | |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 2056 | void qmp_xen_save_devices_state(const char *filename, Error **errp) |
| 2057 | { |
| 2058 | QEMUFile *f; |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 2059 | QIOChannelFile *ioc; |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 2060 | int saved_vm_running; |
| 2061 | int ret; |
| 2062 | |
| 2063 | saved_vm_running = runstate_is_running(); |
| 2064 | vm_stop(RUN_STATE_SAVE_VM); |
Anthony PERARD | c69adea | 2015-08-03 15:29:19 +0100 | [diff] [blame] | 2065 | global_state_store_running(); |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 2066 | |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 2067 | ioc = qio_channel_file_new_path(filename, O_WRONLY | O_CREAT, 0660, errp); |
| 2068 | if (!ioc) { |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 2069 | goto the_end; |
| 2070 | } |
Daniel P. Berrange | 8925839 | 2016-04-27 11:05:08 +0100 | [diff] [blame] | 2071 | f = qemu_fopen_channel_output(QIO_CHANNEL(ioc)); |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 2072 | ret = qemu_save_device_state(f); |
| 2073 | qemu_fclose(f); |
| 2074 | if (ret < 0) { |
Markus Armbruster | c6bd8c7 | 2015-03-17 11:54:50 +0100 | [diff] [blame] | 2075 | error_setg(errp, QERR_IO_ERROR); |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 2076 | } |
| 2077 | |
| 2078 | the_end: |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 2079 | if (saved_vm_running) { |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 2080 | vm_start(); |
Eduardo Habkost | 38ff78d | 2013-11-28 12:01:13 -0200 | [diff] [blame] | 2081 | } |
Stefano Stabellini | a7ae835 | 2012-01-25 12:24:51 +0000 | [diff] [blame] | 2082 | } |
| 2083 | |
Wen Congyang | 88c1656 | 2016-06-03 17:58:34 +0800 | [diff] [blame] | 2084 | void qmp_xen_load_devices_state(const char *filename, Error **errp) |
| 2085 | { |
| 2086 | QEMUFile *f; |
| 2087 | QIOChannelFile *ioc; |
| 2088 | int ret; |
| 2089 | |
| 2090 | /* Guest must be paused before loading the device state; the RAM state |
| 2091 | * will already have been loaded by xc |
| 2092 | */ |
| 2093 | if (runstate_is_running()) { |
| 2094 | error_setg(errp, "Cannot update device state while vm is running"); |
| 2095 | return; |
| 2096 | } |
| 2097 | vm_stop(RUN_STATE_RESTORE_VM); |
| 2098 | |
| 2099 | ioc = qio_channel_file_new_path(filename, O_RDONLY | O_BINARY, 0, errp); |
| 2100 | if (!ioc) { |
| 2101 | return; |
| 2102 | } |
| 2103 | f = qemu_fopen_channel_input(QIO_CHANNEL(ioc)); |
| 2104 | |
| 2105 | migration_incoming_state_new(f); |
| 2106 | ret = qemu_loadvm_state(f); |
| 2107 | qemu_fclose(f); |
| 2108 | if (ret < 0) { |
| 2109 | error_setg(errp, QERR_IO_ERROR); |
| 2110 | } |
| 2111 | migration_incoming_state_destroy(); |
| 2112 | } |
| 2113 | |
Markus Armbruster | 03cd465 | 2010-02-17 16:24:10 +0100 | [diff] [blame] | 2114 | int load_vmstate(const char *name) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2115 | { |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2116 | BlockDriverState *bs, *bs_vm_state; |
aliguori | 2d22b18 | 2008-12-11 21:06:49 +0000 | [diff] [blame] | 2117 | QEMUSnapshotInfo sn; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2118 | QEMUFile *f; |
Gerd Hoffmann | 751c6a1 | 2009-07-22 16:42:57 +0200 | [diff] [blame] | 2119 | int ret; |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2120 | AioContext *aio_context; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2121 | |
Denis V. Lunev | 849f96e | 2015-11-19 09:42:05 +0300 | [diff] [blame] | 2122 | if (!bdrv_all_can_snapshot(&bs)) { |
| 2123 | error_report("Device '%s' is writable but does not support snapshots.", |
| 2124 | bdrv_get_device_name(bs)); |
| 2125 | return -ENOTSUP; |
| 2126 | } |
Denis V. Lunev | 723ccda | 2015-11-19 09:42:06 +0300 | [diff] [blame] | 2127 | ret = bdrv_all_find_snapshot(name, &bs); |
| 2128 | if (ret < 0) { |
| 2129 | error_report("Device '%s' does not have the requested snapshot '%s'", |
| 2130 | bdrv_get_device_name(bs), name); |
| 2131 | return ret; |
| 2132 | } |
Denis V. Lunev | 849f96e | 2015-11-19 09:42:05 +0300 | [diff] [blame] | 2133 | |
Denis V. Lunev | 7cb1448 | 2015-11-19 09:42:10 +0300 | [diff] [blame] | 2134 | bs_vm_state = bdrv_all_find_vmstate_bs(); |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2135 | if (!bs_vm_state) { |
| 2136 | error_report("No block device supports snapshots"); |
| 2137 | return -ENOTSUP; |
| 2138 | } |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2139 | aio_context = bdrv_get_aio_context(bs_vm_state); |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2140 | |
| 2141 | /* Don't even try to load empty VM states */ |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2142 | aio_context_acquire(aio_context); |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2143 | ret = bdrv_snapshot_find(bs_vm_state, &sn, name); |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2144 | aio_context_release(aio_context); |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2145 | if (ret < 0) { |
| 2146 | return ret; |
| 2147 | } else if (sn.vm_state_size == 0) { |
Kevin Wolf | e11480d | 2011-03-01 10:48:12 +0100 | [diff] [blame] | 2148 | error_report("This is a disk-only snapshot. Revert to it offline " |
| 2149 | "using qemu-img."); |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2150 | return -EINVAL; |
| 2151 | } |
| 2152 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2153 | /* Flush all IO requests so they don't interfere with the new state. */ |
Stefan Hajnoczi | 922453b | 2011-11-30 12:23:43 +0000 | [diff] [blame] | 2154 | bdrv_drain_all(); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2155 | |
Denis V. Lunev | 4c1cdba | 2015-11-19 09:42:04 +0300 | [diff] [blame] | 2156 | ret = bdrv_all_goto_snapshot(name, &bs); |
| 2157 | if (ret < 0) { |
| 2158 | error_report("Error %d while activating snapshot '%s' on '%s'", |
| 2159 | ret, name, bdrv_get_device_name(bs)); |
| 2160 | return ret; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2161 | } |
| 2162 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2163 | /* restore the VM state */ |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2164 | f = qemu_fopen_bdrv(bs_vm_state, 0); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2165 | if (!f) { |
Markus Armbruster | 1ecda02 | 2010-02-18 17:25:24 +0100 | [diff] [blame] | 2166 | error_report("Could not open VM state file"); |
Juan Quintela | 05f2401 | 2009-08-20 19:42:22 +0200 | [diff] [blame] | 2167 | return -EINVAL; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2168 | } |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2169 | |
Jan Kiszka | 5a8a49d | 2011-06-14 18:29:45 +0200 | [diff] [blame] | 2170 | qemu_system_reset(VMRESET_SILENT); |
Dr. David Alan Gilbert | bca7856 | 2015-05-21 13:24:14 +0100 | [diff] [blame] | 2171 | migration_incoming_state_new(f); |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2172 | |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2173 | aio_context_acquire(aio_context); |
| 2174 | ret = qemu_loadvm_state(f); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2175 | qemu_fclose(f); |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2176 | aio_context_release(aio_context); |
| 2177 | |
Dr. David Alan Gilbert | bca7856 | 2015-05-21 13:24:14 +0100 | [diff] [blame] | 2178 | migration_incoming_state_destroy(); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2179 | if (ret < 0) { |
Markus Armbruster | 1ecda02 | 2010-02-18 17:25:24 +0100 | [diff] [blame] | 2180 | error_report("Error %d while loading VM state", ret); |
Juan Quintela | 05f2401 | 2009-08-20 19:42:22 +0200 | [diff] [blame] | 2181 | return ret; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2182 | } |
Miguel Di Ciurcio Filho | f0aa7a8 | 2010-07-19 15:25:01 -0300 | [diff] [blame] | 2183 | |
Juan Quintela | 05f2401 | 2009-08-20 19:42:22 +0200 | [diff] [blame] | 2184 | return 0; |
Juan Quintela | 7b63034 | 2009-08-20 19:42:20 +0200 | [diff] [blame] | 2185 | } |
| 2186 | |
Markus Armbruster | 3e5a50d | 2015-02-06 13:55:43 +0100 | [diff] [blame] | 2187 | void hmp_delvm(Monitor *mon, const QDict *qdict) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2188 | { |
Zhang Haoyu | af95738 | 2014-09-29 16:38:02 +0800 | [diff] [blame] | 2189 | BlockDriverState *bs; |
Chris Spiegel | ba2b228 | 2014-10-06 09:33:45 -0700 | [diff] [blame] | 2190 | Error *err; |
Luiz Capitulino | d54908a | 2009-08-28 15:27:13 -0300 | [diff] [blame] | 2191 | const char *name = qdict_get_str(qdict, "name"); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2192 | |
Denis V. Lunev | 9b00ea3 | 2015-11-19 09:42:03 +0300 | [diff] [blame] | 2193 | if (bdrv_all_delete_snapshot(name, &bs, &err) < 0) { |
Markus Armbruster | d410fe1 | 2015-12-18 16:35:17 +0100 | [diff] [blame] | 2194 | error_reportf_err(err, |
| 2195 | "Error while deleting snapshot on device '%s': ", |
| 2196 | bdrv_get_device_name(bs)); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2197 | } |
| 2198 | } |
| 2199 | |
Markus Armbruster | 1ce6be2 | 2015-02-06 14:18:24 +0100 | [diff] [blame] | 2200 | void hmp_info_snapshots(Monitor *mon, const QDict *qdict) |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2201 | { |
| 2202 | BlockDriverState *bs, *bs1; |
Denis V. Lunev | 723ccda | 2015-11-19 09:42:06 +0300 | [diff] [blame] | 2203 | QEMUSnapshotInfo *sn_tab, *sn; |
| 2204 | int nb_sns, i; |
Miguel Di Ciurcio Filho | f920991 | 2010-08-04 14:55:48 -0300 | [diff] [blame] | 2205 | int total; |
| 2206 | int *available_snapshots; |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2207 | AioContext *aio_context; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2208 | |
Denis V. Lunev | 7cb1448 | 2015-11-19 09:42:10 +0300 | [diff] [blame] | 2209 | bs = bdrv_all_find_vmstate_bs(); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2210 | if (!bs) { |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 2211 | monitor_printf(mon, "No available block device supports snapshots\n"); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2212 | return; |
| 2213 | } |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2214 | aio_context = bdrv_get_aio_context(bs); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2215 | |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2216 | aio_context_acquire(aio_context); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2217 | nb_sns = bdrv_snapshot_list(bs, &sn_tab); |
Denis V. Lunev | 79b3c12 | 2015-11-19 09:42:11 +0300 | [diff] [blame] | 2218 | aio_context_release(aio_context); |
| 2219 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2220 | if (nb_sns < 0) { |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 2221 | monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns); |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2222 | return; |
| 2223 | } |
Miguel Di Ciurcio Filho | f920991 | 2010-08-04 14:55:48 -0300 | [diff] [blame] | 2224 | |
| 2225 | if (nb_sns == 0) { |
| 2226 | monitor_printf(mon, "There is no snapshot available.\n"); |
| 2227 | return; |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2228 | } |
Miguel Di Ciurcio Filho | f920991 | 2010-08-04 14:55:48 -0300 | [diff] [blame] | 2229 | |
Markus Armbruster | 97f3ad3 | 2015-09-14 13:51:31 +0200 | [diff] [blame] | 2230 | available_snapshots = g_new0(int, nb_sns); |
Miguel Di Ciurcio Filho | f920991 | 2010-08-04 14:55:48 -0300 | [diff] [blame] | 2231 | total = 0; |
| 2232 | for (i = 0; i < nb_sns; i++) { |
Denis V. Lunev | 723ccda | 2015-11-19 09:42:06 +0300 | [diff] [blame] | 2233 | if (bdrv_all_find_snapshot(sn_tab[i].id_str, &bs1) == 0) { |
Miguel Di Ciurcio Filho | f920991 | 2010-08-04 14:55:48 -0300 | [diff] [blame] | 2234 | available_snapshots[total] = i; |
| 2235 | total++; |
| 2236 | } |
| 2237 | } |
| 2238 | |
| 2239 | if (total > 0) { |
Wenchao Xia | 5b91704 | 2013-05-25 11:09:45 +0800 | [diff] [blame] | 2240 | bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, NULL); |
| 2241 | monitor_printf(mon, "\n"); |
Miguel Di Ciurcio Filho | f920991 | 2010-08-04 14:55:48 -0300 | [diff] [blame] | 2242 | for (i = 0; i < total; i++) { |
| 2243 | sn = &sn_tab[available_snapshots[i]]; |
Wenchao Xia | 5b91704 | 2013-05-25 11:09:45 +0800 | [diff] [blame] | 2244 | bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, sn); |
| 2245 | monitor_printf(mon, "\n"); |
Miguel Di Ciurcio Filho | f920991 | 2010-08-04 14:55:48 -0300 | [diff] [blame] | 2246 | } |
| 2247 | } else { |
| 2248 | monitor_printf(mon, "There is no suitable snapshot available\n"); |
| 2249 | } |
| 2250 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 2251 | g_free(sn_tab); |
| 2252 | g_free(available_snapshots); |
Miguel Di Ciurcio Filho | f920991 | 2010-08-04 14:55:48 -0300 | [diff] [blame] | 2253 | |
aliguori | a672b46 | 2008-11-11 21:33:36 +0000 | [diff] [blame] | 2254 | } |
Avi Kivity | c5705a7 | 2011-12-20 15:59:12 +0200 | [diff] [blame] | 2255 | |
| 2256 | void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev) |
| 2257 | { |
Gonglei | fa53a0e | 2016-05-10 10:04:59 +0800 | [diff] [blame] | 2258 | qemu_ram_set_idstr(mr->ram_block, |
Avi Kivity | c5705a7 | 2011-12-20 15:59:12 +0200 | [diff] [blame] | 2259 | memory_region_name(mr), dev); |
| 2260 | } |
| 2261 | |
| 2262 | void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev) |
| 2263 | { |
Gonglei | fa53a0e | 2016-05-10 10:04:59 +0800 | [diff] [blame] | 2264 | qemu_ram_unset_idstr(mr->ram_block); |
Avi Kivity | c5705a7 | 2011-12-20 15:59:12 +0200 | [diff] [blame] | 2265 | } |
| 2266 | |
| 2267 | void vmstate_register_ram_global(MemoryRegion *mr) |
| 2268 | { |
| 2269 | vmstate_register_ram(mr, NULL); |
| 2270 | } |