xref: /qemu/scripts/vmstate-static-checker.py (revision 7a4e543d)
1#!/usr/bin/python
2#
3# Compares vmstate information stored in JSON format, obtained from
4# the -dump-vmstate QEMU command.
5#
6# Copyright 2014 Amit Shah <amit.shah@redhat.com>
7# Copyright 2014 Red Hat, Inc.
8#
9# This program is free software; you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation; either version 2 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License along
20# with this program; if not, see <http://www.gnu.org/licenses/>.
21
22import argparse
23import json
24import sys
25
26# Count the number of errors found
27taint = 0
28
29def bump_taint():
30    global taint
31
32    # Ensure we don't wrap around or reset to 0 -- the shell only has
33    # an 8-bit return value.
34    if taint < 255:
35        taint = taint + 1
36
37
38def check_fields_match(name, s_field, d_field):
39    if s_field == d_field:
40        return True
41
42    # Some fields changed names between qemu versions.  This list
43    # is used to whitelist such changes in each section / description.
44    changed_names = {
45        'apic': ['timer', 'timer_expiry'],
46        'e1000': ['dev', 'parent_obj'],
47        'ehci': ['dev', 'pcidev'],
48        'I440FX': ['dev', 'parent_obj'],
49        'ich9_ahci': ['card', 'parent_obj'],
50        'ich9-ahci': ['ahci', 'ich9_ahci'],
51        'ioh3420': ['PCIDevice', 'PCIEDevice'],
52        'ioh-3240-express-root-port': ['port.br.dev',
53                                       'parent_obj.parent_obj.parent_obj',
54                                       'port.br.dev.exp.aer_log',
55                                'parent_obj.parent_obj.parent_obj.exp.aer_log'],
56        'cirrus_vga': ['hw_cursor_x', 'vga.hw_cursor_x',
57                       'hw_cursor_y', 'vga.hw_cursor_y'],
58        'lsiscsi': ['dev', 'parent_obj'],
59        'mch': ['d', 'parent_obj'],
60        'pci_bridge': ['bridge.dev', 'parent_obj', 'bridge.dev.shpc', 'shpc'],
61        'pcnet': ['pci_dev', 'parent_obj'],
62        'PIIX3': ['pci_irq_levels', 'pci_irq_levels_vmstate'],
63        'piix4_pm': ['dev', 'parent_obj', 'pci0_status',
64                     'acpi_pci_hotplug.acpi_pcihp_pci_status[0x0]',
65                     'pm1a.sts', 'ar.pm1.evt.sts', 'pm1a.en', 'ar.pm1.evt.en',
66                     'pm1_cnt.cnt', 'ar.pm1.cnt.cnt',
67                     'tmr.timer', 'ar.tmr.timer',
68                     'tmr.overflow_time', 'ar.tmr.overflow_time',
69                     'gpe', 'ar.gpe'],
70        'rtl8139': ['dev', 'parent_obj'],
71        'qxl': ['num_surfaces', 'ssd.num_surfaces'],
72        'usb-ccid': ['abProtocolDataStructure', 'abProtocolDataStructure.data'],
73        'usb-host': ['dev', 'parent_obj'],
74        'usb-mouse': ['usb-ptr-queue', 'HIDPointerEventQueue'],
75        'usb-tablet': ['usb-ptr-queue', 'HIDPointerEventQueue'],
76        'vmware_vga': ['card', 'parent_obj'],
77        'vmware_vga_internal': ['depth', 'new_depth'],
78        'xhci': ['pci_dev', 'parent_obj'],
79        'x3130-upstream': ['PCIDevice', 'PCIEDevice'],
80        'xio3130-express-downstream-port': ['port.br.dev',
81                                            'parent_obj.parent_obj.parent_obj',
82                                            'port.br.dev.exp.aer_log',
83                                'parent_obj.parent_obj.parent_obj.exp.aer_log'],
84        'xio3130-downstream': ['PCIDevice', 'PCIEDevice'],
85        'xio3130-express-upstream-port': ['br.dev', 'parent_obj.parent_obj',
86                                          'br.dev.exp.aer_log',
87                                          'parent_obj.parent_obj.exp.aer_log'],
88    }
89
90    if not name in changed_names:
91        return False
92
93    if s_field in changed_names[name] and d_field in changed_names[name]:
94        return True
95
96    return False
97
98def get_changed_sec_name(sec):
99    # Section names can change -- see commit 292b1634 for an example.
100    changes = {
101        "ICH9 LPC": "ICH9-LPC",
102        "e1000-82540em": "e1000",
103    }
104
105    for item in changes:
106        if item == sec:
107            return changes[item]
108        if changes[item] == sec:
109            return item
110    return ""
111
112def exists_in_substruct(fields, item):
113    # Some QEMU versions moved a few fields inside a substruct.  This
114    # kept the on-wire format the same.  This function checks if
115    # something got shifted inside a substruct.  For example, the
116    # change in commit 1f42d22233b4f3d1a2933ff30e8d6a6d9ee2d08f
117
118    if not "Description" in fields:
119        return False
120
121    if not "Fields" in fields["Description"]:
122        return False
123
124    substruct_fields = fields["Description"]["Fields"]
125
126    if substruct_fields == []:
127        return False
128
129    return check_fields_match(fields["Description"]["name"],
130                              substruct_fields[0]["field"], item)
131
132
133def check_fields(src_fields, dest_fields, desc, sec):
134    # This function checks for all the fields in a section.  If some
135    # fields got embedded into a substruct, this function will also
136    # attempt to check inside the substruct.
137
138    d_iter = iter(dest_fields)
139    s_iter = iter(src_fields)
140
141    # Using these lists as stacks to store previous value of s_iter
142    # and d_iter, so that when time comes to exit out of a substruct,
143    # we can go back one level up and continue from where we left off.
144
145    s_iter_list = []
146    d_iter_list = []
147
148    advance_src = True
149    advance_dest = True
150    unused_count = 0
151
152    while True:
153        if advance_src:
154            try:
155                s_item = s_iter.next()
156            except StopIteration:
157                if s_iter_list == []:
158                    break
159
160                s_iter = s_iter_list.pop()
161                continue
162        else:
163            if unused_count == 0:
164                # We want to avoid advancing just once -- when entering a
165                # dest substruct, or when exiting one.
166                advance_src = True
167
168        if advance_dest:
169            try:
170                d_item = d_iter.next()
171            except StopIteration:
172                if d_iter_list == []:
173                    # We were not in a substruct
174                    print "Section \"" + sec + "\",",
175                    print "Description " + "\"" + desc + "\":",
176                    print "expected field \"" + s_item["field"] + "\",",
177                    print "while dest has no further fields"
178                    bump_taint()
179                    break
180
181                d_iter = d_iter_list.pop()
182                advance_src = False
183                continue
184        else:
185            if unused_count == 0:
186                advance_dest = True
187
188        if unused_count > 0:
189            if advance_dest == False:
190                unused_count = unused_count - s_item["size"]
191                if unused_count == 0:
192                    advance_dest = True
193                    continue
194                if unused_count < 0:
195                    print "Section \"" + sec + "\",",
196                    print "Description \"" + desc + "\":",
197                    print "unused size mismatch near \"",
198                    print s_item["field"] + "\""
199                    bump_taint()
200                    break
201                continue
202
203            if advance_src == False:
204                unused_count = unused_count - d_item["size"]
205                if unused_count == 0:
206                    advance_src = True
207                    continue
208                if unused_count < 0:
209                    print "Section \"" + sec + "\",",
210                    print "Description \"" + desc + "\":",
211                    print "unused size mismatch near \"",
212                    print d_item["field"] + "\""
213                    bump_taint()
214                    break
215                continue
216
217        if not check_fields_match(desc, s_item["field"], d_item["field"]):
218            # Some fields were put in substructs, keeping the
219            # on-wire format the same, but breaking static tools
220            # like this one.
221
222            # First, check if dest has a new substruct.
223            if exists_in_substruct(d_item, s_item["field"]):
224                # listiterators don't have a prev() function, so we
225                # have to store our current location, descend into the
226                # substruct, and ensure we come out as if nothing
227                # happened when the substruct is over.
228                #
229                # Essentially we're opening the substructs that got
230                # added which didn't change the wire format.
231                d_iter_list.append(d_iter)
232                substruct_fields = d_item["Description"]["Fields"]
233                d_iter = iter(substruct_fields)
234                advance_src = False
235                continue
236
237            # Next, check if src has substruct that dest removed
238            # (can happen in backward migration: 2.0 -> 1.5)
239            if exists_in_substruct(s_item, d_item["field"]):
240                s_iter_list.append(s_iter)
241                substruct_fields = s_item["Description"]["Fields"]
242                s_iter = iter(substruct_fields)
243                advance_dest = False
244                continue
245
246            if s_item["field"] == "unused" or d_item["field"] == "unused":
247                if s_item["size"] == d_item["size"]:
248                    continue
249
250                if d_item["field"] == "unused":
251                    advance_dest = False
252                    unused_count = d_item["size"] - s_item["size"]
253                    continue
254
255                if s_item["field"] == "unused":
256                    advance_src = False
257                    unused_count = s_item["size"] - d_item["size"]
258                    continue
259
260            print "Section \"" + sec + "\",",
261            print "Description \"" + desc + "\":",
262            print "expected field \"" + s_item["field"] + "\",",
263            print "got \"" + d_item["field"] + "\"; skipping rest"
264            bump_taint()
265            break
266
267        check_version(s_item, d_item, sec, desc)
268
269        if not "Description" in s_item:
270            # Check size of this field only if it's not a VMSTRUCT entry
271            check_size(s_item, d_item, sec, desc, s_item["field"])
272
273        check_description_in_list(s_item, d_item, sec, desc)
274
275
276def check_subsections(src_sub, dest_sub, desc, sec):
277    for s_item in src_sub:
278        found = False
279        for d_item in dest_sub:
280            if s_item["name"] != d_item["name"]:
281                continue
282
283            found = True
284            check_descriptions(s_item, d_item, sec)
285
286        if not found:
287            print "Section \"" + sec + "\", Description \"" + desc + "\":",
288            print "Subsection \"" + s_item["name"] + "\" not found"
289            bump_taint()
290
291
292def check_description_in_list(s_item, d_item, sec, desc):
293    if not "Description" in s_item:
294        return
295
296    if not "Description" in d_item:
297        print "Section \"" + sec + "\", Description \"" + desc + "\",",
298        print "Field \"" + s_item["field"] + "\": missing description"
299        bump_taint()
300        return
301
302    check_descriptions(s_item["Description"], d_item["Description"], sec)
303
304
305def check_descriptions(src_desc, dest_desc, sec):
306    check_version(src_desc, dest_desc, sec, src_desc["name"])
307
308    if not check_fields_match(sec, src_desc["name"], dest_desc["name"]):
309        print "Section \"" + sec + "\":",
310        print "Description \"" + src_desc["name"] + "\"",
311        print "missing, got \"" + dest_desc["name"] + "\" instead; skipping"
312        bump_taint()
313        return
314
315    for f in src_desc:
316        if not f in dest_desc:
317            print "Section \"" + sec + "\"",
318            print "Description \"" + src_desc["name"] + "\":",
319            print "Entry \"" + f + "\" missing"
320            bump_taint()
321            continue
322
323        if f == 'Fields':
324            check_fields(src_desc[f], dest_desc[f], src_desc["name"], sec)
325
326        if f == 'Subsections':
327            check_subsections(src_desc[f], dest_desc[f], src_desc["name"], sec)
328
329
330def check_version(s, d, sec, desc=None):
331    if s["version_id"] > d["version_id"]:
332        print "Section \"" + sec + "\"",
333        if desc:
334            print "Description \"" + desc + "\":",
335        print "version error:", s["version_id"], ">", d["version_id"]
336        bump_taint()
337
338    if not "minimum_version_id" in d:
339        return
340
341    if s["version_id"] < d["minimum_version_id"]:
342        print "Section \"" + sec + "\"",
343        if desc:
344            print "Description \"" + desc + "\":",
345            print "minimum version error:", s["version_id"], "<",
346            print d["minimum_version_id"]
347            bump_taint()
348
349
350def check_size(s, d, sec, desc=None, field=None):
351    if s["size"] != d["size"]:
352        print "Section \"" + sec + "\"",
353        if desc:
354            print "Description \"" + desc + "\"",
355        if field:
356            print "Field \"" + field + "\"",
357        print "size mismatch:", s["size"], ",", d["size"]
358        bump_taint()
359
360
361def check_machine_type(s, d):
362    if s["Name"] != d["Name"]:
363        print "Warning: checking incompatible machine types:",
364        print "\"" + s["Name"] + "\", \"" + d["Name"] + "\""
365    return
366
367
368def main():
369    help_text = "Parse JSON-formatted vmstate dumps from QEMU in files SRC and DEST.  Checks whether migration from SRC to DEST QEMU versions would break based on the VMSTATE information contained within the JSON outputs.  The JSON output is created from a QEMU invocation with the -dump-vmstate parameter and a filename argument to it.  Other parameters to QEMU do not matter, except the -M (machine type) parameter."
370
371    parser = argparse.ArgumentParser(description=help_text)
372    parser.add_argument('-s', '--src', type=file, required=True,
373                        help='json dump from src qemu')
374    parser.add_argument('-d', '--dest', type=file, required=True,
375                        help='json dump from dest qemu')
376    parser.add_argument('--reverse', required=False, default=False,
377                        action='store_true',
378                        help='reverse the direction')
379    args = parser.parse_args()
380
381    src_data = json.load(args.src)
382    dest_data = json.load(args.dest)
383    args.src.close()
384    args.dest.close()
385
386    if args.reverse:
387        temp = src_data
388        src_data = dest_data
389        dest_data = temp
390
391    for sec in src_data:
392        dest_sec = sec
393        if not dest_sec in dest_data:
394            # Either the section name got changed, or the section
395            # doesn't exist in dest.
396            dest_sec = get_changed_sec_name(sec)
397            if not dest_sec in dest_data:
398                print "Section \"" + sec + "\" does not exist in dest"
399                bump_taint()
400                continue
401
402        s = src_data[sec]
403        d = dest_data[dest_sec]
404
405        if sec == "vmschkmachine":
406            check_machine_type(s, d)
407            continue
408
409        check_version(s, d, sec)
410
411        for entry in s:
412            if not entry in d:
413                print "Section \"" + sec + "\": Entry \"" + entry + "\"",
414                print "missing"
415                bump_taint()
416                continue
417
418            if entry == "Description":
419                check_descriptions(s[entry], d[entry], sec)
420
421    return taint
422
423
424if __name__ == '__main__':
425    sys.exit(main())
426