]>
Commit | Line | Data |
---|---|---|
83de0ea4 | 1 | #!/usr/bin/env python3 |
b1742570 AG |
2 | # |
3 | # Migration Stream Analyzer | |
4 | # | |
5 | # Copyright (c) 2015 Alexander Graf <agraf@suse.de> | |
6 | # | |
7 | # This library is free software; you can redistribute it and/or | |
8 | # modify it under the terms of the GNU Lesser General Public | |
9 | # License as published by the Free Software Foundation; either | |
61f3c91a | 10 | # version 2.1 of the License, or (at your option) any later version. |
b1742570 AG |
11 | # |
12 | # This library is distributed in the hope that it will be useful, | |
13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | # Lesser General Public License for more details. | |
16 | # | |
17 | # You should have received a copy of the GNU Lesser General Public | |
18 | # License along with this library; if not, see <http://www.gnu.org/licenses/>. | |
19 | ||
b1742570 AG |
20 | import json |
21 | import os | |
22 | import argparse | |
23 | import collections | |
83de0ea4 MAL |
24 | import struct |
25 | import sys | |
26 | ||
27 | ||
b1742570 AG |
28 | def mkdir_p(path): |
29 | try: | |
30 | os.makedirs(path) | |
31 | except OSError: | |
32 | pass | |
33 | ||
83de0ea4 | 34 | |
b1742570 AG |
35 | class MigrationFile(object): |
36 | def __init__(self, filename): | |
37 | self.filename = filename | |
38 | self.file = open(self.filename, "rb") | |
39 | ||
40 | def read64(self): | |
caea0327 | 41 | return int.from_bytes(self.file.read(8), byteorder='big', signed=False) |
b1742570 AG |
42 | |
43 | def read32(self): | |
caea0327 | 44 | return int.from_bytes(self.file.read(4), byteorder='big', signed=False) |
b1742570 AG |
45 | |
46 | def read16(self): | |
caea0327 | 47 | return int.from_bytes(self.file.read(2), byteorder='big', signed=False) |
b1742570 AG |
48 | |
49 | def read8(self): | |
83de0ea4 | 50 | return int.from_bytes(self.file.read(1), byteorder='big', signed=True) |
b1742570 AG |
51 | |
52 | def readstr(self, len = None): | |
83de0ea4 | 53 | return self.readvar(len).decode('utf-8') |
b1742570 AG |
54 | |
55 | def readvar(self, size = None): | |
56 | if size is None: | |
57 | size = self.read8() | |
58 | if size == 0: | |
59 | return "" | |
60 | value = self.file.read(size) | |
61 | if len(value) != size: | |
62 | raise Exception("Unexpected end of %s at 0x%x" % (self.filename, self.file.tell())) | |
63 | return value | |
64 | ||
65 | def tell(self): | |
66 | return self.file.tell() | |
67 | ||
68 | # The VMSD description is at the end of the file, after EOF. Look for | |
69 | # the last NULL byte, then for the beginning brace of JSON. | |
70 | def read_migration_debug_json(self): | |
71 | QEMU_VM_VMDESCRIPTION = 0x06 | |
72 | ||
73 | # Remember the offset in the file when we started | |
74 | entrypos = self.file.tell() | |
75 | ||
76 | # Read the last 10MB | |
77 | self.file.seek(0, os.SEEK_END) | |
78 | endpos = self.file.tell() | |
79 | self.file.seek(max(-endpos, -10 * 1024 * 1024), os.SEEK_END) | |
80 | datapos = self.file.tell() | |
81 | data = self.file.read() | |
82 | # The full file read closed the file as well, reopen it | |
83 | self.file = open(self.filename, "rb") | |
84 | ||
85 | # Find the last NULL byte, then the first brace after that. This should | |
86 | # be the beginning of our JSON data. | |
13ae8cdb MAL |
87 | nulpos = data.rfind(b'\0') |
88 | jsonpos = data.find(b'{', nulpos) | |
b1742570 AG |
89 | |
90 | # Check backwards from there and see whether we guessed right | |
91 | self.file.seek(datapos + jsonpos - 5, 0) | |
92 | if self.read8() != QEMU_VM_VMDESCRIPTION: | |
93 | raise Exception("No Debug Migration device found") | |
94 | ||
95 | jsonlen = self.read32() | |
96 | ||
97 | # Seek back to where we were at the beginning | |
98 | self.file.seek(entrypos, 0) | |
99 | ||
14f9cec7 AK |
100 | # explicit decode() needed for Python 3.5 compatibility |
101 | return data[jsonpos:jsonpos + jsonlen].decode("utf-8") | |
b1742570 AG |
102 | |
103 | def close(self): | |
104 | self.file.close() | |
105 | ||
106 | class RamSection(object): | |
107 | RAM_SAVE_FLAG_COMPRESS = 0x02 | |
108 | RAM_SAVE_FLAG_MEM_SIZE = 0x04 | |
109 | RAM_SAVE_FLAG_PAGE = 0x08 | |
110 | RAM_SAVE_FLAG_EOS = 0x10 | |
111 | RAM_SAVE_FLAG_CONTINUE = 0x20 | |
112 | RAM_SAVE_FLAG_XBZRLE = 0x40 | |
113 | RAM_SAVE_FLAG_HOOK = 0x80 | |
f1de3097 MAL |
114 | RAM_SAVE_FLAG_COMPRESS_PAGE = 0x100 |
115 | RAM_SAVE_FLAG_MULTIFD_FLUSH = 0x200 | |
b1742570 AG |
116 | |
117 | def __init__(self, file, version_id, ramargs, section_key): | |
118 | if version_id != 4: | |
119 | raise Exception("Unknown RAM version %d" % version_id) | |
120 | ||
121 | self.file = file | |
122 | self.section_key = section_key | |
123 | self.TARGET_PAGE_SIZE = ramargs['page_size'] | |
124 | self.dump_memory = ramargs['dump_memory'] | |
125 | self.write_memory = ramargs['write_memory'] | |
ff40c7f0 | 126 | self.ignore_shared = ramargs['ignore_shared'] |
b1742570 AG |
127 | self.sizeinfo = collections.OrderedDict() |
128 | self.data = collections.OrderedDict() | |
129 | self.data['section sizes'] = self.sizeinfo | |
130 | self.name = '' | |
131 | if self.write_memory: | |
132 | self.files = { } | |
133 | if self.dump_memory: | |
134 | self.memory = collections.OrderedDict() | |
135 | self.data['memory'] = self.memory | |
136 | ||
137 | def __repr__(self): | |
138 | return self.data.__repr__() | |
139 | ||
140 | def __str__(self): | |
141 | return self.data.__str__() | |
142 | ||
143 | def getDict(self): | |
144 | return self.data | |
145 | ||
146 | def read(self): | |
147 | # Read all RAM sections | |
148 | while True: | |
149 | addr = self.file.read64() | |
150 | flags = addr & (self.TARGET_PAGE_SIZE - 1) | |
151 | addr &= ~(self.TARGET_PAGE_SIZE - 1) | |
152 | ||
153 | if flags & self.RAM_SAVE_FLAG_MEM_SIZE: | |
154 | while True: | |
155 | namelen = self.file.read8() | |
156 | # We assume that no RAM chunk is big enough to ever | |
157 | # hit the first byte of the address, so when we see | |
158 | # a zero here we know it has to be an address, not the | |
159 | # length of the next block. | |
160 | if namelen == 0: | |
161 | self.file.file.seek(-1, 1) | |
162 | break | |
163 | self.name = self.file.readstr(len = namelen) | |
164 | len = self.file.read64() | |
165 | self.sizeinfo[self.name] = '0x%016x' % len | |
166 | if self.write_memory: | |
f03868bd | 167 | print(self.name) |
b1742570 AG |
168 | mkdir_p('./' + os.path.dirname(self.name)) |
169 | f = open('./' + self.name, "wb") | |
170 | f.truncate(0) | |
171 | f.truncate(len) | |
172 | self.files[self.name] = f | |
ff40c7f0 FR |
173 | if self.ignore_shared: |
174 | mr_addr = self.file.read64() | |
b1742570 AG |
175 | flags &= ~self.RAM_SAVE_FLAG_MEM_SIZE |
176 | ||
177 | if flags & self.RAM_SAVE_FLAG_COMPRESS: | |
178 | if flags & self.RAM_SAVE_FLAG_CONTINUE: | |
179 | flags &= ~self.RAM_SAVE_FLAG_CONTINUE | |
180 | else: | |
181 | self.name = self.file.readstr() | |
182 | fill_char = self.file.read8() | |
183 | # The page in question is filled with fill_char now | |
184 | if self.write_memory and fill_char != 0: | |
185 | self.files[self.name].seek(addr, os.SEEK_SET) | |
186 | self.files[self.name].write(chr(fill_char) * self.TARGET_PAGE_SIZE) | |
187 | if self.dump_memory: | |
188 | self.memory['%s (0x%016x)' % (self.name, addr)] = 'Filled with 0x%02x' % fill_char | |
189 | flags &= ~self.RAM_SAVE_FLAG_COMPRESS | |
190 | elif flags & self.RAM_SAVE_FLAG_PAGE: | |
191 | if flags & self.RAM_SAVE_FLAG_CONTINUE: | |
192 | flags &= ~self.RAM_SAVE_FLAG_CONTINUE | |
193 | else: | |
194 | self.name = self.file.readstr() | |
195 | ||
196 | if self.write_memory or self.dump_memory: | |
197 | data = self.file.readvar(size = self.TARGET_PAGE_SIZE) | |
198 | else: # Just skip RAM data | |
199 | self.file.file.seek(self.TARGET_PAGE_SIZE, 1) | |
200 | ||
201 | if self.write_memory: | |
202 | self.files[self.name].seek(addr, os.SEEK_SET) | |
203 | self.files[self.name].write(data) | |
204 | if self.dump_memory: | |
205 | hexdata = " ".join("{0:02x}".format(ord(c)) for c in data) | |
206 | self.memory['%s (0x%016x)' % (self.name, addr)] = hexdata | |
207 | ||
208 | flags &= ~self.RAM_SAVE_FLAG_PAGE | |
209 | elif flags & self.RAM_SAVE_FLAG_XBZRLE: | |
210 | raise Exception("XBZRLE RAM compression is not supported yet") | |
211 | elif flags & self.RAM_SAVE_FLAG_HOOK: | |
212 | raise Exception("RAM hooks don't make sense with files") | |
f1de3097 MAL |
213 | if flags & self.RAM_SAVE_FLAG_MULTIFD_FLUSH: |
214 | continue | |
b1742570 AG |
215 | |
216 | # End of RAM section | |
217 | if flags & self.RAM_SAVE_FLAG_EOS: | |
218 | break | |
219 | ||
220 | if flags != 0: | |
221 | raise Exception("Unknown RAM flags: %x" % flags) | |
222 | ||
223 | def __del__(self): | |
224 | if self.write_memory: | |
225 | for key in self.files: | |
226 | self.files[key].close() | |
227 | ||
228 | ||
229 | class HTABSection(object): | |
230 | HASH_PTE_SIZE_64 = 16 | |
231 | ||
232 | def __init__(self, file, version_id, device, section_key): | |
233 | if version_id != 1: | |
234 | raise Exception("Unknown HTAB version %d" % version_id) | |
235 | ||
236 | self.file = file | |
237 | self.section_key = section_key | |
238 | ||
239 | def read(self): | |
240 | ||
241 | header = self.file.read32() | |
242 | ||
029ff892 LV |
243 | if (header == -1): |
244 | # "no HPT" encoding | |
245 | return | |
246 | ||
b1742570 AG |
247 | if (header > 0): |
248 | # First section, just the hash shift | |
249 | return | |
250 | ||
251 | # Read until end marker | |
252 | while True: | |
253 | index = self.file.read32() | |
254 | n_valid = self.file.read16() | |
255 | n_invalid = self.file.read16() | |
256 | ||
257 | if index == 0 and n_valid == 0 and n_invalid == 0: | |
258 | break | |
259 | ||
be7433ef | 260 | self.file.readvar(n_valid * self.HASH_PTE_SIZE_64) |
b1742570 AG |
261 | |
262 | def getDict(self): | |
263 | return "" | |
264 | ||
96e5c9bc | 265 | |
81c2c9dd TH |
266 | class S390StorageAttributes(object): |
267 | STATTR_FLAG_EOS = 0x01 | |
268 | STATTR_FLAG_MORE = 0x02 | |
269 | STATTR_FLAG_ERROR = 0x04 | |
270 | STATTR_FLAG_DONE = 0x08 | |
271 | ||
272 | def __init__(self, file, version_id, device, section_key): | |
273 | if version_id != 0: | |
274 | raise Exception("Unknown storage_attributes version %d" % version_id) | |
275 | ||
276 | self.file = file | |
277 | self.section_key = section_key | |
278 | ||
279 | def read(self): | |
280 | while True: | |
281 | addr_flags = self.file.read64() | |
282 | flags = addr_flags & 0xfff | |
283 | if (flags & (self.STATTR_FLAG_DONE | self.STATTR_FLAG_EOS)): | |
284 | return | |
285 | if (flags & self.STATTR_FLAG_ERROR): | |
286 | raise Exception("Error in migration stream") | |
287 | count = self.file.read64() | |
288 | self.file.readvar(count) | |
289 | ||
290 | def getDict(self): | |
291 | return "" | |
292 | ||
293 | ||
96e5c9bc | 294 | class ConfigurationSection(object): |
c36c31c8 | 295 | def __init__(self, file, desc): |
96e5c9bc | 296 | self.file = file |
c36c31c8 | 297 | self.desc = desc |
31499a9d FR |
298 | self.caps = [] |
299 | ||
300 | def parse_capabilities(self, vmsd_caps): | |
301 | if not vmsd_caps: | |
302 | return | |
303 | ||
304 | ncaps = vmsd_caps.data['caps_count'].data | |
305 | self.caps = vmsd_caps.data['capabilities'] | |
306 | ||
307 | if type(self.caps) != list: | |
308 | self.caps = [self.caps] | |
309 | ||
310 | if len(self.caps) != ncaps: | |
311 | raise Exception("Number of capabilities doesn't match " | |
312 | "caps_count field") | |
313 | ||
314 | def has_capability(self, cap): | |
315 | return any([str(c) == cap for c in self.caps]) | |
96e5c9bc MCA |
316 | |
317 | def read(self): | |
c36c31c8 FR |
318 | if self.desc: |
319 | version_id = self.desc['version'] | |
320 | section = VMSDSection(self.file, version_id, self.desc, | |
321 | 'configuration') | |
322 | section.read() | |
31499a9d FR |
323 | self.parse_capabilities( |
324 | section.data.get("configuration/capabilities")) | |
c36c31c8 FR |
325 | else: |
326 | # backward compatibility for older streams that don't have | |
327 | # the configuration section in the json | |
328 | name_len = self.file.read32() | |
329 | name = self.file.readstr(len = name_len) | |
96e5c9bc | 330 | |
b1742570 AG |
331 | class VMSDFieldGeneric(object): |
332 | def __init__(self, desc, file): | |
333 | self.file = file | |
334 | self.desc = desc | |
335 | self.data = "" | |
336 | ||
337 | def __repr__(self): | |
338 | return str(self.__str__()) | |
339 | ||
340 | def __str__(self): | |
83de0ea4 | 341 | return " ".join("{0:02x}".format(c) for c in self.data) |
b1742570 AG |
342 | |
343 | def getDict(self): | |
344 | return self.__str__() | |
345 | ||
346 | def read(self): | |
347 | size = int(self.desc['size']) | |
348 | self.data = self.file.readvar(size) | |
349 | return self.data | |
350 | ||
31499a9d FR |
351 | class VMSDFieldCap(object): |
352 | def __init__(self, desc, file): | |
353 | self.file = file | |
354 | self.desc = desc | |
355 | self.data = "" | |
356 | ||
357 | def __repr__(self): | |
358 | return self.data | |
359 | ||
360 | def __str__(self): | |
361 | return self.data | |
362 | ||
363 | def read(self): | |
364 | len = self.file.read8() | |
365 | self.data = self.file.readstr(len) | |
366 | ||
367 | ||
b1742570 AG |
368 | class VMSDFieldInt(VMSDFieldGeneric): |
369 | def __init__(self, desc, file): | |
370 | super(VMSDFieldInt, self).__init__(desc, file) | |
371 | self.size = int(desc['size']) | |
372 | self.format = '0x%%0%dx' % (self.size * 2) | |
373 | self.sdtype = '>i%d' % self.size | |
374 | self.udtype = '>u%d' % self.size | |
375 | ||
376 | def __repr__(self): | |
377 | if self.data < 0: | |
378 | return ('%s (%d)' % ((self.format % self.udata), self.data)) | |
379 | else: | |
380 | return self.format % self.data | |
381 | ||
382 | def __str__(self): | |
383 | return self.__repr__() | |
384 | ||
385 | def getDict(self): | |
386 | return self.__str__() | |
387 | ||
388 | def read(self): | |
389 | super(VMSDFieldInt, self).read() | |
83de0ea4 MAL |
390 | self.sdata = int.from_bytes(self.data, byteorder='big', signed=True) |
391 | self.udata = int.from_bytes(self.data, byteorder='big', signed=False) | |
b1742570 AG |
392 | self.data = self.sdata |
393 | return self.data | |
394 | ||
395 | class VMSDFieldUInt(VMSDFieldInt): | |
396 | def __init__(self, desc, file): | |
397 | super(VMSDFieldUInt, self).__init__(desc, file) | |
398 | ||
399 | def read(self): | |
400 | super(VMSDFieldUInt, self).read() | |
401 | self.data = self.udata | |
402 | return self.data | |
403 | ||
404 | class VMSDFieldIntLE(VMSDFieldInt): | |
405 | def __init__(self, desc, file): | |
406 | super(VMSDFieldIntLE, self).__init__(desc, file) | |
407 | self.dtype = '<i%d' % self.size | |
408 | ||
409 | class VMSDFieldBool(VMSDFieldGeneric): | |
410 | def __init__(self, desc, file): | |
411 | super(VMSDFieldBool, self).__init__(desc, file) | |
412 | ||
413 | def __repr__(self): | |
414 | return self.data.__repr__() | |
415 | ||
416 | def __str__(self): | |
417 | return self.data.__str__() | |
418 | ||
419 | def getDict(self): | |
420 | return self.data | |
421 | ||
422 | def read(self): | |
423 | super(VMSDFieldBool, self).read() | |
424 | if self.data[0] == 0: | |
425 | self.data = False | |
426 | else: | |
427 | self.data = True | |
428 | return self.data | |
429 | ||
430 | class VMSDFieldStruct(VMSDFieldGeneric): | |
431 | QEMU_VM_SUBSECTION = 0x05 | |
432 | ||
433 | def __init__(self, desc, file): | |
434 | super(VMSDFieldStruct, self).__init__(desc, file) | |
435 | self.data = collections.OrderedDict() | |
436 | ||
437 | # When we see compressed array elements, unfold them here | |
438 | new_fields = [] | |
439 | for field in self.desc['struct']['fields']: | |
440 | if not 'array_len' in field: | |
441 | new_fields.append(field) | |
442 | continue | |
443 | array_len = field.pop('array_len') | |
444 | field['index'] = 0 | |
445 | new_fields.append(field) | |
83de0ea4 | 446 | for i in range(1, array_len): |
b1742570 AG |
447 | c = field.copy() |
448 | c['index'] = i | |
449 | new_fields.append(c) | |
450 | ||
451 | self.desc['struct']['fields'] = new_fields | |
452 | ||
453 | def __repr__(self): | |
454 | return self.data.__repr__() | |
455 | ||
456 | def __str__(self): | |
457 | return self.data.__str__() | |
458 | ||
459 | def read(self): | |
460 | for field in self.desc['struct']['fields']: | |
461 | try: | |
462 | reader = vmsd_field_readers[field['type']] | |
463 | except: | |
464 | reader = VMSDFieldGeneric | |
465 | ||
466 | field['data'] = reader(field, self.file) | |
467 | field['data'].read() | |
468 | ||
469 | if 'index' in field: | |
470 | if field['name'] not in self.data: | |
471 | self.data[field['name']] = [] | |
472 | a = self.data[field['name']] | |
473 | if len(a) != int(field['index']): | |
474 | raise Exception("internal index of data field unmatched (%d/%d)" % (len(a), int(field['index']))) | |
475 | a.append(field['data']) | |
476 | else: | |
477 | self.data[field['name']] = field['data'] | |
478 | ||
479 | if 'subsections' in self.desc['struct']: | |
480 | for subsection in self.desc['struct']['subsections']: | |
481 | if self.file.read8() != self.QEMU_VM_SUBSECTION: | |
482 | raise Exception("Subsection %s not found at offset %x" % ( subsection['vmsd_name'], self.file.tell())) | |
483 | name = self.file.readstr() | |
484 | version_id = self.file.read32() | |
485 | self.data[name] = VMSDSection(self.file, version_id, subsection, (name, 0)) | |
486 | self.data[name].read() | |
487 | ||
488 | def getDictItem(self, value): | |
489 | # Strings would fall into the array category, treat | |
490 | # them specially | |
491 | if value.__class__ is ''.__class__: | |
492 | return value | |
493 | ||
494 | try: | |
495 | return self.getDictOrderedDict(value) | |
496 | except: | |
497 | try: | |
498 | return self.getDictArray(value) | |
499 | except: | |
500 | try: | |
501 | return value.getDict() | |
502 | except: | |
503 | return value | |
504 | ||
505 | def getDictArray(self, array): | |
506 | r = [] | |
507 | for value in array: | |
508 | r.append(self.getDictItem(value)) | |
509 | return r | |
510 | ||
511 | def getDictOrderedDict(self, dict): | |
512 | r = collections.OrderedDict() | |
513 | for (key, value) in dict.items(): | |
514 | r[key] = self.getDictItem(value) | |
515 | return r | |
516 | ||
517 | def getDict(self): | |
518 | return self.getDictOrderedDict(self.data) | |
519 | ||
520 | vmsd_field_readers = { | |
521 | "bool" : VMSDFieldBool, | |
522 | "int8" : VMSDFieldInt, | |
523 | "int16" : VMSDFieldInt, | |
524 | "int32" : VMSDFieldInt, | |
525 | "int32 equal" : VMSDFieldInt, | |
526 | "int32 le" : VMSDFieldIntLE, | |
527 | "int64" : VMSDFieldInt, | |
528 | "uint8" : VMSDFieldUInt, | |
529 | "uint16" : VMSDFieldUInt, | |
530 | "uint32" : VMSDFieldUInt, | |
531 | "uint32 equal" : VMSDFieldUInt, | |
532 | "uint64" : VMSDFieldUInt, | |
533 | "int64 equal" : VMSDFieldInt, | |
534 | "uint8 equal" : VMSDFieldInt, | |
535 | "uint16 equal" : VMSDFieldInt, | |
536 | "float64" : VMSDFieldGeneric, | |
537 | "timer" : VMSDFieldGeneric, | |
538 | "buffer" : VMSDFieldGeneric, | |
539 | "unused_buffer" : VMSDFieldGeneric, | |
540 | "bitmap" : VMSDFieldGeneric, | |
541 | "struct" : VMSDFieldStruct, | |
31499a9d | 542 | "capability": VMSDFieldCap, |
b1742570 AG |
543 | "unknown" : VMSDFieldGeneric, |
544 | } | |
545 | ||
546 | class VMSDSection(VMSDFieldStruct): | |
547 | def __init__(self, file, version_id, device, section_key): | |
548 | self.file = file | |
549 | self.data = "" | |
550 | self.vmsd_name = "" | |
551 | self.section_key = section_key | |
552 | desc = device | |
553 | if 'vmsd_name' in device: | |
554 | self.vmsd_name = device['vmsd_name'] | |
555 | ||
556 | # A section really is nothing but a FieldStruct :) | |
557 | super(VMSDSection, self).__init__({ 'struct' : desc }, file) | |
558 | ||
559 | ############################################################################### | |
560 | ||
561 | class MigrationDump(object): | |
562 | QEMU_VM_FILE_MAGIC = 0x5145564d | |
563 | QEMU_VM_FILE_VERSION = 0x00000003 | |
564 | QEMU_VM_EOF = 0x00 | |
565 | QEMU_VM_SECTION_START = 0x01 | |
566 | QEMU_VM_SECTION_PART = 0x02 | |
567 | QEMU_VM_SECTION_END = 0x03 | |
568 | QEMU_VM_SECTION_FULL = 0x04 | |
569 | QEMU_VM_SUBSECTION = 0x05 | |
570 | QEMU_VM_VMDESCRIPTION = 0x06 | |
96e5c9bc | 571 | QEMU_VM_CONFIGURATION = 0x07 |
73d9a796 | 572 | QEMU_VM_SECTION_FOOTER= 0x7e |
b1742570 AG |
573 | |
574 | def __init__(self, filename): | |
81c2c9dd TH |
575 | self.section_classes = { |
576 | ( 'ram', 0 ) : [ RamSection, None ], | |
577 | ( 's390-storage_attributes', 0 ) : [ S390StorageAttributes, None], | |
578 | ( 'spapr/htab', 0) : ( HTABSection, None ) | |
579 | } | |
b1742570 AG |
580 | self.filename = filename |
581 | self.vmsd_desc = None | |
582 | ||
583 | def read(self, desc_only = False, dump_memory = False, write_memory = False): | |
584 | # Read in the whole file | |
585 | file = MigrationFile(self.filename) | |
586 | ||
587 | # File magic | |
588 | data = file.read32() | |
589 | if data != self.QEMU_VM_FILE_MAGIC: | |
590 | raise Exception("Invalid file magic %x" % data) | |
591 | ||
592 | # Version (has to be v3) | |
593 | data = file.read32() | |
594 | if data != self.QEMU_VM_FILE_VERSION: | |
595 | raise Exception("Invalid version number %d" % data) | |
596 | ||
597 | self.load_vmsd_json(file) | |
598 | ||
599 | # Read sections | |
600 | self.sections = collections.OrderedDict() | |
601 | ||
602 | if desc_only: | |
603 | return | |
604 | ||
605 | ramargs = {} | |
606 | ramargs['page_size'] = self.vmsd_desc['page_size'] | |
607 | ramargs['dump_memory'] = dump_memory | |
608 | ramargs['write_memory'] = write_memory | |
ff40c7f0 | 609 | ramargs['ignore_shared'] = False |
b1742570 AG |
610 | self.section_classes[('ram',0)][1] = ramargs |
611 | ||
612 | while True: | |
613 | section_type = file.read8() | |
614 | if section_type == self.QEMU_VM_EOF: | |
615 | break | |
96e5c9bc | 616 | elif section_type == self.QEMU_VM_CONFIGURATION: |
c36c31c8 FR |
617 | config_desc = self.vmsd_desc.get('configuration') |
618 | section = ConfigurationSection(file, config_desc) | |
96e5c9bc | 619 | section.read() |
ff40c7f0 | 620 | ramargs['ignore_shared'] = section.has_capability('x-ignore-shared') |
b1742570 AG |
621 | elif section_type == self.QEMU_VM_SECTION_START or section_type == self.QEMU_VM_SECTION_FULL: |
622 | section_id = file.read32() | |
623 | name = file.readstr() | |
624 | instance_id = file.read32() | |
625 | version_id = file.read32() | |
626 | section_key = (name, instance_id) | |
627 | classdesc = self.section_classes[section_key] | |
628 | section = classdesc[0](file, version_id, classdesc[1], section_key) | |
629 | self.sections[section_id] = section | |
630 | section.read() | |
631 | elif section_type == self.QEMU_VM_SECTION_PART or section_type == self.QEMU_VM_SECTION_END: | |
632 | section_id = file.read32() | |
633 | self.sections[section_id].read() | |
73d9a796 DDAG |
634 | elif section_type == self.QEMU_VM_SECTION_FOOTER: |
635 | read_section_id = file.read32() | |
636 | if read_section_id != section_id: | |
637 | raise Exception("Mismatched section footer: %x vs %x" % (read_section_id, section_id)) | |
b1742570 AG |
638 | else: |
639 | raise Exception("Unknown section type: %d" % section_type) | |
640 | file.close() | |
641 | ||
642 | def load_vmsd_json(self, file): | |
643 | vmsd_json = file.read_migration_debug_json() | |
644 | self.vmsd_desc = json.loads(vmsd_json, object_pairs_hook=collections.OrderedDict) | |
645 | for device in self.vmsd_desc['devices']: | |
646 | key = (device['name'], device['instance_id']) | |
647 | value = ( VMSDSection, device ) | |
648 | self.section_classes[key] = value | |
649 | ||
650 | def getDict(self): | |
651 | r = collections.OrderedDict() | |
652 | for (key, value) in self.sections.items(): | |
653 | key = "%s (%d)" % ( value.section_key[0], key ) | |
654 | r[key] = value.getDict() | |
655 | return r | |
656 | ||
657 | ############################################################################### | |
658 | ||
659 | class JSONEncoder(json.JSONEncoder): | |
660 | def default(self, o): | |
661 | if isinstance(o, VMSDFieldGeneric): | |
662 | return str(o) | |
663 | return json.JSONEncoder.default(self, o) | |
664 | ||
665 | parser = argparse.ArgumentParser() | |
666 | parser.add_argument("-f", "--file", help='migration dump to read from', required=True) | |
667 | parser.add_argument("-m", "--memory", help='dump RAM contents as well', action='store_true') | |
668 | parser.add_argument("-d", "--dump", help='what to dump ("state" or "desc")', default='state') | |
669 | parser.add_argument("-x", "--extract", help='extract contents into individual files', action='store_true') | |
670 | args = parser.parse_args() | |
671 | ||
672 | jsonenc = JSONEncoder(indent=4, separators=(',', ': ')) | |
673 | ||
674 | if args.extract: | |
675 | dump = MigrationDump(args.file) | |
676 | ||
677 | dump.read(desc_only = True) | |
f03868bd | 678 | print("desc.json") |
2c92be50 | 679 | f = open("desc.json", "w") |
b1742570 AG |
680 | f.truncate() |
681 | f.write(jsonenc.encode(dump.vmsd_desc)) | |
682 | f.close() | |
683 | ||
684 | dump.read(write_memory = True) | |
685 | dict = dump.getDict() | |
f03868bd | 686 | print("state.json") |
2c92be50 | 687 | f = open("state.json", "w") |
b1742570 AG |
688 | f.truncate() |
689 | f.write(jsonenc.encode(dict)) | |
690 | f.close() | |
691 | elif args.dump == "state": | |
692 | dump = MigrationDump(args.file) | |
693 | dump.read(dump_memory = args.memory) | |
694 | dict = dump.getDict() | |
f03868bd | 695 | print(jsonenc.encode(dict)) |
b1742570 AG |
696 | elif args.dump == "desc": |
697 | dump = MigrationDump(args.file) | |
698 | dump.read(desc_only = True) | |
f03868bd | 699 | print(jsonenc.encode(dump.vmsd_desc)) |
b1742570 | 700 | else: |
f98d372a | 701 | raise Exception("Please specify either -x, -d state or -d desc") |