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