s390x/pci: Fix harmless mistake in zpci's property fid's setter
[qemu.git] / scripts / analyze-migration.py
1 #!/usr/bin/env python3
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
10 # version 2 of the License, or (at your option) any later version.
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
20 import json
21 import os
22 import argparse
23 import collections
24 import struct
25 import sys
26
27
28 def mkdir_p(path):
29 try:
30 os.makedirs(path)
31 except OSError:
32 pass
33
34
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):
41 return int.from_bytes(self.file.read(8), byteorder='big', signed=True)
42
43 def read32(self):
44 return int.from_bytes(self.file.read(4), byteorder='big', signed=True)
45
46 def read16(self):
47 return int.from_bytes(self.file.read(2), byteorder='big', signed=True)
48
49 def read8(self):
50 return int.from_bytes(self.file.read(1), byteorder='big', signed=True)
51
52 def readstr(self, len = None):
53 return self.readvar(len).decode('utf-8')
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.
87 nulpos = data.rfind(b'\0')
88 jsonpos = data.find(b'{', nulpos)
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
100 return data[jsonpos:jsonpos + jsonlen]
101
102 def close(self):
103 self.file.close()
104
105 class RamSection(object):
106 RAM_SAVE_FLAG_COMPRESS = 0x02
107 RAM_SAVE_FLAG_MEM_SIZE = 0x04
108 RAM_SAVE_FLAG_PAGE = 0x08
109 RAM_SAVE_FLAG_EOS = 0x10
110 RAM_SAVE_FLAG_CONTINUE = 0x20
111 RAM_SAVE_FLAG_XBZRLE = 0x40
112 RAM_SAVE_FLAG_HOOK = 0x80
113
114 def __init__(self, file, version_id, ramargs, section_key):
115 if version_id != 4:
116 raise Exception("Unknown RAM version %d" % version_id)
117
118 self.file = file
119 self.section_key = section_key
120 self.TARGET_PAGE_SIZE = ramargs['page_size']
121 self.dump_memory = ramargs['dump_memory']
122 self.write_memory = ramargs['write_memory']
123 self.sizeinfo = collections.OrderedDict()
124 self.data = collections.OrderedDict()
125 self.data['section sizes'] = self.sizeinfo
126 self.name = ''
127 if self.write_memory:
128 self.files = { }
129 if self.dump_memory:
130 self.memory = collections.OrderedDict()
131 self.data['memory'] = self.memory
132
133 def __repr__(self):
134 return self.data.__repr__()
135
136 def __str__(self):
137 return self.data.__str__()
138
139 def getDict(self):
140 return self.data
141
142 def read(self):
143 # Read all RAM sections
144 while True:
145 addr = self.file.read64()
146 flags = addr & (self.TARGET_PAGE_SIZE - 1)
147 addr &= ~(self.TARGET_PAGE_SIZE - 1)
148
149 if flags & self.RAM_SAVE_FLAG_MEM_SIZE:
150 while True:
151 namelen = self.file.read8()
152 # We assume that no RAM chunk is big enough to ever
153 # hit the first byte of the address, so when we see
154 # a zero here we know it has to be an address, not the
155 # length of the next block.
156 if namelen == 0:
157 self.file.file.seek(-1, 1)
158 break
159 self.name = self.file.readstr(len = namelen)
160 len = self.file.read64()
161 self.sizeinfo[self.name] = '0x%016x' % len
162 if self.write_memory:
163 print(self.name)
164 mkdir_p('./' + os.path.dirname(self.name))
165 f = open('./' + self.name, "wb")
166 f.truncate(0)
167 f.truncate(len)
168 self.files[self.name] = f
169 flags &= ~self.RAM_SAVE_FLAG_MEM_SIZE
170
171 if flags & self.RAM_SAVE_FLAG_COMPRESS:
172 if flags & self.RAM_SAVE_FLAG_CONTINUE:
173 flags &= ~self.RAM_SAVE_FLAG_CONTINUE
174 else:
175 self.name = self.file.readstr()
176 fill_char = self.file.read8()
177 # The page in question is filled with fill_char now
178 if self.write_memory and fill_char != 0:
179 self.files[self.name].seek(addr, os.SEEK_SET)
180 self.files[self.name].write(chr(fill_char) * self.TARGET_PAGE_SIZE)
181 if self.dump_memory:
182 self.memory['%s (0x%016x)' % (self.name, addr)] = 'Filled with 0x%02x' % fill_char
183 flags &= ~self.RAM_SAVE_FLAG_COMPRESS
184 elif flags & self.RAM_SAVE_FLAG_PAGE:
185 if flags & self.RAM_SAVE_FLAG_CONTINUE:
186 flags &= ~self.RAM_SAVE_FLAG_CONTINUE
187 else:
188 self.name = self.file.readstr()
189
190 if self.write_memory or self.dump_memory:
191 data = self.file.readvar(size = self.TARGET_PAGE_SIZE)
192 else: # Just skip RAM data
193 self.file.file.seek(self.TARGET_PAGE_SIZE, 1)
194
195 if self.write_memory:
196 self.files[self.name].seek(addr, os.SEEK_SET)
197 self.files[self.name].write(data)
198 if self.dump_memory:
199 hexdata = " ".join("{0:02x}".format(ord(c)) for c in data)
200 self.memory['%s (0x%016x)' % (self.name, addr)] = hexdata
201
202 flags &= ~self.RAM_SAVE_FLAG_PAGE
203 elif flags & self.RAM_SAVE_FLAG_XBZRLE:
204 raise Exception("XBZRLE RAM compression is not supported yet")
205 elif flags & self.RAM_SAVE_FLAG_HOOK:
206 raise Exception("RAM hooks don't make sense with files")
207
208 # End of RAM section
209 if flags & self.RAM_SAVE_FLAG_EOS:
210 break
211
212 if flags != 0:
213 raise Exception("Unknown RAM flags: %x" % flags)
214
215 def __del__(self):
216 if self.write_memory:
217 for key in self.files:
218 self.files[key].close()
219
220
221 class HTABSection(object):
222 HASH_PTE_SIZE_64 = 16
223
224 def __init__(self, file, version_id, device, section_key):
225 if version_id != 1:
226 raise Exception("Unknown HTAB version %d" % version_id)
227
228 self.file = file
229 self.section_key = section_key
230
231 def read(self):
232
233 header = self.file.read32()
234
235 if (header == -1):
236 # "no HPT" encoding
237 return
238
239 if (header > 0):
240 # First section, just the hash shift
241 return
242
243 # Read until end marker
244 while True:
245 index = self.file.read32()
246 n_valid = self.file.read16()
247 n_invalid = self.file.read16()
248
249 if index == 0 and n_valid == 0 and n_invalid == 0:
250 break
251
252 self.file.readvar(n_valid * self.HASH_PTE_SIZE_64)
253
254 def getDict(self):
255 return ""
256
257
258 class ConfigurationSection(object):
259 def __init__(self, file):
260 self.file = file
261
262 def read(self):
263 name_len = self.file.read32()
264 name = self.file.readstr(len = name_len)
265
266 class VMSDFieldGeneric(object):
267 def __init__(self, desc, file):
268 self.file = file
269 self.desc = desc
270 self.data = ""
271
272 def __repr__(self):
273 return str(self.__str__())
274
275 def __str__(self):
276 return " ".join("{0:02x}".format(c) for c in self.data)
277
278 def getDict(self):
279 return self.__str__()
280
281 def read(self):
282 size = int(self.desc['size'])
283 self.data = self.file.readvar(size)
284 return self.data
285
286 class VMSDFieldInt(VMSDFieldGeneric):
287 def __init__(self, desc, file):
288 super(VMSDFieldInt, self).__init__(desc, file)
289 self.size = int(desc['size'])
290 self.format = '0x%%0%dx' % (self.size * 2)
291 self.sdtype = '>i%d' % self.size
292 self.udtype = '>u%d' % self.size
293
294 def __repr__(self):
295 if self.data < 0:
296 return ('%s (%d)' % ((self.format % self.udata), self.data))
297 else:
298 return self.format % self.data
299
300 def __str__(self):
301 return self.__repr__()
302
303 def getDict(self):
304 return self.__str__()
305
306 def read(self):
307 super(VMSDFieldInt, self).read()
308 self.sdata = int.from_bytes(self.data, byteorder='big', signed=True)
309 self.udata = int.from_bytes(self.data, byteorder='big', signed=False)
310 self.data = self.sdata
311 return self.data
312
313 class VMSDFieldUInt(VMSDFieldInt):
314 def __init__(self, desc, file):
315 super(VMSDFieldUInt, self).__init__(desc, file)
316
317 def read(self):
318 super(VMSDFieldUInt, self).read()
319 self.data = self.udata
320 return self.data
321
322 class VMSDFieldIntLE(VMSDFieldInt):
323 def __init__(self, desc, file):
324 super(VMSDFieldIntLE, self).__init__(desc, file)
325 self.dtype = '<i%d' % self.size
326
327 class VMSDFieldBool(VMSDFieldGeneric):
328 def __init__(self, desc, file):
329 super(VMSDFieldBool, self).__init__(desc, file)
330
331 def __repr__(self):
332 return self.data.__repr__()
333
334 def __str__(self):
335 return self.data.__str__()
336
337 def getDict(self):
338 return self.data
339
340 def read(self):
341 super(VMSDFieldBool, self).read()
342 if self.data[0] == 0:
343 self.data = False
344 else:
345 self.data = True
346 return self.data
347
348 class VMSDFieldStruct(VMSDFieldGeneric):
349 QEMU_VM_SUBSECTION = 0x05
350
351 def __init__(self, desc, file):
352 super(VMSDFieldStruct, self).__init__(desc, file)
353 self.data = collections.OrderedDict()
354
355 # When we see compressed array elements, unfold them here
356 new_fields = []
357 for field in self.desc['struct']['fields']:
358 if not 'array_len' in field:
359 new_fields.append(field)
360 continue
361 array_len = field.pop('array_len')
362 field['index'] = 0
363 new_fields.append(field)
364 for i in range(1, array_len):
365 c = field.copy()
366 c['index'] = i
367 new_fields.append(c)
368
369 self.desc['struct']['fields'] = new_fields
370
371 def __repr__(self):
372 return self.data.__repr__()
373
374 def __str__(self):
375 return self.data.__str__()
376
377 def read(self):
378 for field in self.desc['struct']['fields']:
379 try:
380 reader = vmsd_field_readers[field['type']]
381 except:
382 reader = VMSDFieldGeneric
383
384 field['data'] = reader(field, self.file)
385 field['data'].read()
386
387 if 'index' in field:
388 if field['name'] not in self.data:
389 self.data[field['name']] = []
390 a = self.data[field['name']]
391 if len(a) != int(field['index']):
392 raise Exception("internal index of data field unmatched (%d/%d)" % (len(a), int(field['index'])))
393 a.append(field['data'])
394 else:
395 self.data[field['name']] = field['data']
396
397 if 'subsections' in self.desc['struct']:
398 for subsection in self.desc['struct']['subsections']:
399 if self.file.read8() != self.QEMU_VM_SUBSECTION:
400 raise Exception("Subsection %s not found at offset %x" % ( subsection['vmsd_name'], self.file.tell()))
401 name = self.file.readstr()
402 version_id = self.file.read32()
403 self.data[name] = VMSDSection(self.file, version_id, subsection, (name, 0))
404 self.data[name].read()
405
406 def getDictItem(self, value):
407 # Strings would fall into the array category, treat
408 # them specially
409 if value.__class__ is ''.__class__:
410 return value
411
412 try:
413 return self.getDictOrderedDict(value)
414 except:
415 try:
416 return self.getDictArray(value)
417 except:
418 try:
419 return value.getDict()
420 except:
421 return value
422
423 def getDictArray(self, array):
424 r = []
425 for value in array:
426 r.append(self.getDictItem(value))
427 return r
428
429 def getDictOrderedDict(self, dict):
430 r = collections.OrderedDict()
431 for (key, value) in dict.items():
432 r[key] = self.getDictItem(value)
433 return r
434
435 def getDict(self):
436 return self.getDictOrderedDict(self.data)
437
438 vmsd_field_readers = {
439 "bool" : VMSDFieldBool,
440 "int8" : VMSDFieldInt,
441 "int16" : VMSDFieldInt,
442 "int32" : VMSDFieldInt,
443 "int32 equal" : VMSDFieldInt,
444 "int32 le" : VMSDFieldIntLE,
445 "int64" : VMSDFieldInt,
446 "uint8" : VMSDFieldUInt,
447 "uint16" : VMSDFieldUInt,
448 "uint32" : VMSDFieldUInt,
449 "uint32 equal" : VMSDFieldUInt,
450 "uint64" : VMSDFieldUInt,
451 "int64 equal" : VMSDFieldInt,
452 "uint8 equal" : VMSDFieldInt,
453 "uint16 equal" : VMSDFieldInt,
454 "float64" : VMSDFieldGeneric,
455 "timer" : VMSDFieldGeneric,
456 "buffer" : VMSDFieldGeneric,
457 "unused_buffer" : VMSDFieldGeneric,
458 "bitmap" : VMSDFieldGeneric,
459 "struct" : VMSDFieldStruct,
460 "unknown" : VMSDFieldGeneric,
461 }
462
463 class VMSDSection(VMSDFieldStruct):
464 def __init__(self, file, version_id, device, section_key):
465 self.file = file
466 self.data = ""
467 self.vmsd_name = ""
468 self.section_key = section_key
469 desc = device
470 if 'vmsd_name' in device:
471 self.vmsd_name = device['vmsd_name']
472
473 # A section really is nothing but a FieldStruct :)
474 super(VMSDSection, self).__init__({ 'struct' : desc }, file)
475
476 ###############################################################################
477
478 class MigrationDump(object):
479 QEMU_VM_FILE_MAGIC = 0x5145564d
480 QEMU_VM_FILE_VERSION = 0x00000003
481 QEMU_VM_EOF = 0x00
482 QEMU_VM_SECTION_START = 0x01
483 QEMU_VM_SECTION_PART = 0x02
484 QEMU_VM_SECTION_END = 0x03
485 QEMU_VM_SECTION_FULL = 0x04
486 QEMU_VM_SUBSECTION = 0x05
487 QEMU_VM_VMDESCRIPTION = 0x06
488 QEMU_VM_CONFIGURATION = 0x07
489 QEMU_VM_SECTION_FOOTER= 0x7e
490
491 def __init__(self, filename):
492 self.section_classes = { ( 'ram', 0 ) : [ RamSection, None ],
493 ( 'spapr/htab', 0) : ( HTABSection, None ) }
494 self.filename = filename
495 self.vmsd_desc = None
496
497 def read(self, desc_only = False, dump_memory = False, write_memory = False):
498 # Read in the whole file
499 file = MigrationFile(self.filename)
500
501 # File magic
502 data = file.read32()
503 if data != self.QEMU_VM_FILE_MAGIC:
504 raise Exception("Invalid file magic %x" % data)
505
506 # Version (has to be v3)
507 data = file.read32()
508 if data != self.QEMU_VM_FILE_VERSION:
509 raise Exception("Invalid version number %d" % data)
510
511 self.load_vmsd_json(file)
512
513 # Read sections
514 self.sections = collections.OrderedDict()
515
516 if desc_only:
517 return
518
519 ramargs = {}
520 ramargs['page_size'] = self.vmsd_desc['page_size']
521 ramargs['dump_memory'] = dump_memory
522 ramargs['write_memory'] = write_memory
523 self.section_classes[('ram',0)][1] = ramargs
524
525 while True:
526 section_type = file.read8()
527 if section_type == self.QEMU_VM_EOF:
528 break
529 elif section_type == self.QEMU_VM_CONFIGURATION:
530 section = ConfigurationSection(file)
531 section.read()
532 elif section_type == self.QEMU_VM_SECTION_START or section_type == self.QEMU_VM_SECTION_FULL:
533 section_id = file.read32()
534 name = file.readstr()
535 instance_id = file.read32()
536 version_id = file.read32()
537 section_key = (name, instance_id)
538 classdesc = self.section_classes[section_key]
539 section = classdesc[0](file, version_id, classdesc[1], section_key)
540 self.sections[section_id] = section
541 section.read()
542 elif section_type == self.QEMU_VM_SECTION_PART or section_type == self.QEMU_VM_SECTION_END:
543 section_id = file.read32()
544 self.sections[section_id].read()
545 elif section_type == self.QEMU_VM_SECTION_FOOTER:
546 read_section_id = file.read32()
547 if read_section_id != section_id:
548 raise Exception("Mismatched section footer: %x vs %x" % (read_section_id, section_id))
549 else:
550 raise Exception("Unknown section type: %d" % section_type)
551 file.close()
552
553 def load_vmsd_json(self, file):
554 vmsd_json = file.read_migration_debug_json()
555 self.vmsd_desc = json.loads(vmsd_json, object_pairs_hook=collections.OrderedDict)
556 for device in self.vmsd_desc['devices']:
557 key = (device['name'], device['instance_id'])
558 value = ( VMSDSection, device )
559 self.section_classes[key] = value
560
561 def getDict(self):
562 r = collections.OrderedDict()
563 for (key, value) in self.sections.items():
564 key = "%s (%d)" % ( value.section_key[0], key )
565 r[key] = value.getDict()
566 return r
567
568 ###############################################################################
569
570 class JSONEncoder(json.JSONEncoder):
571 def default(self, o):
572 if isinstance(o, VMSDFieldGeneric):
573 return str(o)
574 return json.JSONEncoder.default(self, o)
575
576 parser = argparse.ArgumentParser()
577 parser.add_argument("-f", "--file", help='migration dump to read from', required=True)
578 parser.add_argument("-m", "--memory", help='dump RAM contents as well', action='store_true')
579 parser.add_argument("-d", "--dump", help='what to dump ("state" or "desc")', default='state')
580 parser.add_argument("-x", "--extract", help='extract contents into individual files', action='store_true')
581 args = parser.parse_args()
582
583 jsonenc = JSONEncoder(indent=4, separators=(',', ': '))
584
585 if args.extract:
586 dump = MigrationDump(args.file)
587
588 dump.read(desc_only = True)
589 print("desc.json")
590 f = open("desc.json", "wb")
591 f.truncate()
592 f.write(jsonenc.encode(dump.vmsd_desc))
593 f.close()
594
595 dump.read(write_memory = True)
596 dict = dump.getDict()
597 print("state.json")
598 f = open("state.json", "wb")
599 f.truncate()
600 f.write(jsonenc.encode(dict))
601 f.close()
602 elif args.dump == "state":
603 dump = MigrationDump(args.file)
604 dump.read(dump_memory = args.memory)
605 dict = dump.getDict()
606 print(jsonenc.encode(dict))
607 elif args.dump == "desc":
608 dump = MigrationDump(args.file)
609 dump.read(desc_only = True)
610 print(jsonenc.encode(dump.vmsd_desc))
611 else:
612 raise Exception("Please specify either -x, -d state or -d dump")