LXR qemu/scripts/analyze-migration.py

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