Blob Blame History Raw
#! /usr/bin/python
# SPDX-License-Identifier: CC0-1.0

import argparse
import errno
import fnmatch
import io
import itertools
import os
import re
import shutil
import struct
import sys
import tarfile
import tempfile
from subprocess import PIPE, Popen, STDOUT

# Python 3 shims
try:
    from functools import reduce
except:
    pass
try:
    from itertools import zip_longest as izip_longest
except:
    from itertools import izip_longest

# revs:
# [ { "path", "cpuid", "pf", "rev", "date" } ]

# artifacts:
#  * content summary (per-file)
#   * overlay summary (per-fms/pf)
#  * changelog (per-file?)
#  * discrepancies (per-fms/pf)

log_level = 0
print_date = False
file_glob = ["*??-??-??", "*microcode*.dat"]


def log_status(msg, level=0):
    global log_level

    if log_level >= level:
        sys.stderr.write(msg + "\n")


def log_info(msg, level=2):
    global log_level

    if log_level >= level:
        sys.stderr.write("INFO: " + msg + "\n")


def log_warn(msg, level=1):
    global log_level

    if log_level >= level:
        sys.stderr.write("WARNING: " + msg + "\n")


def log_error(msg, level=-1):
    global log_level

    if log_level >= level:
        sys.stderr.write("ERROR: " + msg + "\n")


def remove_prefix(text, prefix):
    if isinstance(prefix, str):
        prefix = [prefix, ]

    for p in prefix:
        pfx = p if p.endswith(os.sep) else p + os.sep
        if text.startswith(pfx):
            return text[len(pfx):]

    return text


def file_walk(args, yield_dirs=False):
    for content in args:
        if os.path.isdir(content):
            if yield_dirs:
                yield ("", content)
            for root, dirs, files in os.walk(content):
                if yield_dirs:
                    for f in dirs:
                        p = os.path.join(root, f)
                        yield (remove_prefix(p, content), p)
                for f in files:
                    p = os.path.join(root, f)
                    yield (remove_prefix(p, content), p)
        elif os.path.exists(content):
            yield ("", content)
        else:
            raise IOError(errno.ENOENT, os.strerror(errno.ENOENT), content)


def cpuid_fname(c):
    # Note that the Extended Family is summed up with the Family,
    # while the Extended Model is concatenated with the Model.
    return "%02x-%02x-%02x" % (
        ((c >> 20) & 0xff) + ((c >> 8) & 0xf),
        ((c >> 12) & 0xf0) + ((c >> 4) & 0xf),
        c & 0xf)


def read_revs_dir(path, args, src=None, ret=None):
    if ret is None:
        ret = []

    ucode_re = re.compile('[0-9a-f]{2}-[0-9a-f]{2}-0[0-9a-f]$')
    ucode_dat_re = re.compile('microcode.*\.dat$')

    for rp, ap in file_walk([path, ]):
        rp_fname = os.path.basename(rp)
        if not ucode_re.match(rp_fname) and not ucode_dat_re.match(rp_fname):
            continue

        # Text-based format
        data = None
        if ucode_dat_re.match(rp_fname):
            data = io.BytesIO()
            with open(ap, "r") as f:
                for line in f:
                    if line.startswith("/"):
                        continue
                    vals = line.split(",")
                    for val in vals:
                        val = val.strip()
                        if not val:
                            continue
                        data.write(struct.pack("<I", int(val, 16)))
            sz = data.seek(0, os.SEEK_CUR)
            data.seek(0, os.SEEK_SET)
        else:
            sz = os.stat(ap).st_size

        try:
            with data or open(ap, "rb") as f:
                log_info("Processing %s" % ap)
                offs = 0
                while offs < sz:
                    f.seek(offs, os.SEEK_SET)
                    hdr = struct.unpack("IiIIIIIIIIII", f.read(48))
                    ret.append({"path": rp, "src": src or path,
                                "cpuid": hdr[3], "pf": hdr[6], "rev": hdr[1],
                                "date": hdr[2], "offs": offs, "cksum": hdr[4],
                                "data_size": hdr[7], "total_size": hdr[8]})

                    if hdr[8] and hdr[8] - hdr[7] > 48:
                        f.seek(hdr[7], os.SEEK_CUR)
                        ext_tbl = struct.unpack("IIIII", f.read(20))
                        log_status("Found %u extended signatures for %s:%#x" %
                                   (ext_tbl[0], rp, offs), level=1)

                        cur_offs = offs + hdr[7] + 48 + 20
                        ext_sig_cnt = 0
                        while cur_offs < offs + hdr[8] \
                                and ext_sig_cnt <= ext_tbl[0]:
                            ext_sig = struct.unpack("III", f.read(12))
                            ignore = args.ignore_ext_dups and \
                                (ext_sig[0] == hdr[3])
                            if not ignore:
                                ret.append({"path": rp, "src": src or path,
                                            "cpuid": ext_sig[0],
                                            "pf": ext_sig[1],
                                            "rev": hdr[1], "date": hdr[2],
                                            "offs": offs, "ext_offs": cur_offs,
                                            "cksum": hdr[4],
                                            "ext_cksum": ext_sig[2],
                                            "data_size": hdr[7],
                                            "total_size": hdr[8]})
                            log_status(("Got ext sig %#x/%#x for " +
                                        "%s:%#x:%#x/%#x%s") %
                                       (ext_sig[0], ext_sig[1],
                                        rp, offs, hdr[3], hdr[6],
                                        " (ignored)" if ignore else ""),
                                       level=2)

                            cur_offs += 12
                            ext_sig_cnt += 1

                    offs += hdr[8] or 2048
        except Exception as e:
            log_error("a problem occurred while processing %s: %s" % (ap, e),
                      level=1)

    return ret


def read_revs_rpm(path, args, ret=None):
    if ret is None:
        ret = []

    dir_tmp = tempfile.mkdtemp()

    log_status("Trying to extract files from RPM \"%s\"..." % path,
               level=1)

    rpm2cpio = Popen(args=["rpm2cpio", path], stdout=PIPE, stderr=PIPE,
                     close_fds=True)
    cpio = Popen(args=["cpio", "-idmv"] + file_glob,
                 cwd=dir_tmp, stdin=rpm2cpio.stdout,
                 stdout=PIPE, stderr=STDOUT)
    out, cpio_stderr = cpio.communicate()
    rpm2cpio_out, rpm2cpio_err = rpm2cpio.communicate()

    rpm2cpio_ret = rpm2cpio.returncode
    cpio_ret = cpio.returncode

    log_info("rpm2cpio exit code: %d, cpio exit code: %d" %
             (rpm2cpio_ret, cpio_ret))
    if rpm2cpio_err:
        log_info("rpm2cpio stderr:\n%s" % rpm2cpio_err, level=3)
    if out:
        log_info("cpio output:\n%s" % out, level=3)
    if cpio_stderr:
        log_info("cpio stderr:\n%s" % cpio_stderr, level=3)

    if rpm2cpio_ret == 0 and cpio_ret == 0:
        ret = read_revs_dir(dir_tmp, args, path)

    shutil.rmtree(dir_tmp)

    return ret


def read_revs_tar(path, args, ret=None):
    if ret is None:
        ret = []

    dir_tmp = tempfile.mkdtemp()

    log_status("Trying to extract files from tarball \"%s\"..." % path,
               level=1)

    try:
        with tarfile.open(path, "r:*") as tar:
            for ti in tar:
                if any(fnmatch.fnmatchcase(ti.name, p) for p in file_glob):
                    d = os.path.normpath(os.path.join("/",
                                         os.path.dirname(ti.name)))
                    # For now, strip exactl one level
                    d = os.path.join(*(d.split(os.path.sep)[2:]))
                    n = os.path.join(d, os.path.basename(ti.name))

                    if not os.path.exists(d):
                        os.makedirs(d)
                    t = tar.extractfile(ti)
                    with open(n, "wb") as f:
                        shutil.copyfileobj(t, f)
                    t.close()

        ret = read_revs_dir(dir_tmp, args, path)
    except Exception as err:
        log_error("Error while reading \"%s\" as a tarball: \"%s\"" %
                  (path, str(err)))

    shutil.rmtree(dir_tmp)

    return ret


def read_revs(path, args, ret=None):
    if ret is None:
        ret = []
    if os.path.isdir(path):
        return read_revs_dir(path, args, ret)
    elif tarfile.is_tarfile(path):
        return read_revs_tar(path, args, ret)
    else:
        return read_revs_rpm(path, args, ret)


def gen_mc_map(mc_data, merge=False, merge_path=False):
    """
    Converts an array of microcode file information to a map with path/sig/pf
    as a key.

    merge: whether to leave only the newest mc variant in the map or leave all
           possible variants.
    """
    res = dict()

    for mc in mc_data:
        key = (None if merge_path else mc["path"], mc["cpuid"], mc["pf"])

        if key not in res:
            res[key] = dict()

        cpuid = mc["cpuid"]
        cur_pf = mc["pf"]
        pid = 1
        while cur_pf > 0:
            if cur_pf & 1 and not (merge and pid in res[key]
                                   and res[key][pid]["rev"][0] >= mc["rev"]):
                if pid not in res[cpuid] or merge:
                    res[cpuid][pid] = []
                res[cpuid][pid].append(mc)

            cur_pf = cur_pf / 2
            pid = pid * 2

    return res


def gen_fn_map(mc_data, merge=False, merge_path=False):
    res = dict()

    for mc in mc_data:
        key = (None if merge_path else mc["path"], mc["cpuid"], mc["pf"])
        if key in res:
            log_warn("Duplicate path/cpuid/pf: %s/%#x/%#x" % key)
        else:
            res[key] = []
        if merge and len(res[key]):
            if mc["rev"] > res[key][0]["rev"]:
                res[key][0] = mc
        else:
            res[key].append(mc)

    return res


def revcmp(a, b):
    return b["rev"] - a["rev"]


class ChangeLogEntry:
    ADDED = 0
    REMOVED = 1
    UPDATED = 2
    DOWNGRADED = 3
    OTHER = 4


def mc_stripped_path(mc):
    paths = ("usr/share/microcode_ctl/ucode_with_caveats/intel",
             "usr/share/microcode_ctl/ucode_with_caveats",
             "usr/share/microcode_ctl",
             "lib/firmware",
             "etc/firmware",
             )

    return remove_prefix(mc["path"], paths)


class mcnm:
    MCNM_ABBREV = 0
    MCNM_FAMILIES = 1
    MCNM_MODELS = 2
    MCNM_FAMILIES_MODELS = 3
    MCNM_CODENAME = 4


def get_mc_cnames(mc, cmap, mode=mcnm.MCNM_ABBREV, stringify=True,
                  segment=False):
    if not isinstance(mc, dict):
        mc = mc_from_mc_key(mc)
    sig = mc["cpuid"]
    pf = mc["pf"]
    res = []

    if not cmap:
        return None
    if sig not in cmap:
        log_info("No codename information for sig %#x" % sig)
        return None

    cnames = cmap[sig]

    if mode in (mcnm.MCNM_FAMILIES, mcnm.MCNM_MODELS,
                mcnm.MCNM_FAMILIES_MODELS):
        for c in cnames:
            if not (pf & c["pf_mask"]):
                continue
            for m, f in ((mcnm.MCNM_FAMILIES, "families"),
                         (mcnm.MCNM_MODELS, "models")):
                if m & mode == 0:
                    continue
                if f not in c or not c[f]:
                    log_info("No %s for sig %#x in %r" % (f, sig, c))
                    continue

                res.append(c[f])

        return ", ".join(res) or None

    steppings = dict()
    suffices = dict()
    for c in cnames:
        if pf and not (pf & c["pf_mask"]):
            continue

        if mode == mcnm.MCNM_ABBREV and "abbrev" in c and c["abbrev"]:
            cname = c["abbrev"]
        else:
            cname = c["codename"]

        if segment:
            cname = c["segment"] + " " + cname

        if cname not in suffices:
            suffices[cname] = set()
        if "variant" in c and c["variant"]:
            suffices[cname] |= set(c["variant"])

        if cname not in steppings:
            steppings[cname] = set()
        if c["stepping"]:
            steppings[cname] |= set(c["stepping"])

    for cname in sorted(steppings.keys()):
        cname_res = [cname]
        if len(suffices[cname]):
            cname_res[0] += "-" + "/".join(sorted(suffices[cname]))
        if len(steppings[cname]):
            cname_res.append("/".join(sorted(steppings[cname])))
        res.append(" ".join(cname_res) if stringify else cname_res)

    return (", ".join(res) or None) if stringify else res


def mc_from_mc_key(k):
    return dict(zip(("path", "cpuid", "pf"), k))


def mc_path(mc, pf_sfx=True, midword=None, cmap=None, cname_segment=False):
    if not isinstance(mc, dict):
        mc = mc_from_mc_key(mc)
    path = mc_stripped_path(mc) if mc["path"] is not None else None
    cpuid_fn = cpuid_fname(mc["cpuid"])
    fname = os.path.basename(mc["path"] or cpuid_fn)
    midword = "" if midword is None else " " + midword
    cname = get_mc_cnames(mc, cmap, segment=cname_segment)
    cname_str = " (" + cname + ")" if cname else ""

    if pf_sfx:
        sfx = "/0x%02x" % mc["pf"]
    else:
        sfx = ""

    if not path or path == os.path.join("intel-ucode", cpuid_fn):
        return "%s%s%s%s" % (fname, sfx, cname_str, midword)
    else:
        return "%s%s%s%s (in %s)" % (cpuid_fn, sfx, cname_str, midword, path)


def gen_changelog_file(old, new):
    pass


def mc_cmp(old_mc, new_mc):
    res = []

    old_mc_revs = [x["rev"] for x in old_mc]
    new_mc_revs = [x["rev"] for x in new_mc]
    common = set(old_mc_revs) & set(new_mc_revs)
    old_rev_list = [x for x in sorted(old_mc_revs) if x not in common]
    new_rev_list = [x for x in sorted(new_mc_revs) if x not in common]

    if len(old_rev_list) != 1 or len(new_rev_list) != 1:
        for i in new_mc:
            if i["rev"] in new_rev_list:
                res.append((ChangeLogEntry.ADDED, None, i))
        for i in old_mc:
            if i["rev"] in old_rev_list:
                res.append((ChangeLogEntry.REMOVED, i, None))
    else:
        for old in old_mc:
            if old["rev"] == old_rev_list[0]:
                break
        for new in new_mc:
            if new["rev"] == new_rev_list[0]:
                break
        if new["rev"] > old["rev"]:
            res.append((ChangeLogEntry.UPDATED, old, new))
        elif new["rev"] < old["rev"]:
            res.append((ChangeLogEntry.DOWNGRADED, old, new))

    return res


def gen_changelog(old, new):
    res = []

    old_map = gen_fn_map(old)
    new_map = gen_fn_map(new)

    old_files = set(old_map.keys())
    new_files = set(new_map.keys())

    both = old_files & new_files
    added = new_files - old_files
    removed = old_files - new_files

    for f in sorted(added):
        p = mc_path(new_map[f][0])
        for old_f in sorted(removed):
            old_p = mc_path(old_map[old_f][0])
            if p == old_p and f[1] == old_f[1] and f[2] == old_f[2]:
                log_info("Matched %s (%s and %s)" %
                         (p, old_map[old_f][0]["path"], new_map[f][0]["path"]))
                added.remove(f)
                removed.remove(old_f)

                res += mc_cmp(old_map[old_f], new_map[f])

    for f in sorted(added):
        for i in new_map[f]:
            res.append((ChangeLogEntry.ADDED, None, i))
    for f in sorted(removed):
        for i in old_map[f]:
            res.append((ChangeLogEntry.REMOVED, i, None))
    for f in sorted(both):
        res += mc_cmp(old_map[f], new_map[f])

    return res


def mc_date(mc):
    if isinstance(mc, dict):
        mc = mc["date"]
    return "%04x-%02x-%02x" % (mc & 0xffff, mc >> 24, (mc >> 16) & 0xff)


def mc_rev(mc, date=None):
    '''
    While revision is signed for comparison purposes, historically
    it is printed as unsigned,  Oh well.
    '''
    global print_date

    if mc["rev"] < 0:
        rev = 2**32 + mc["rev"]
    else:
        rev = mc["rev"]

    if date if date is not None else print_date:
        return "%#x (%s)" % (rev, mc_date(mc))
    else:
        return "%#x" % rev


def print_changelog_rpm(clog, cmap, args):
    for e, old, new in clog:
        mc_str = mc_path(new if e == ChangeLogEntry.ADDED else old,
                         midword="microcode",
                         cmap=cmap, cname_segment=args.segment)

        if e == ChangeLogEntry.ADDED:
            print("Addition of %s at revision %s" % (mc_str, mc_rev(new)))
        elif e == ChangeLogEntry.REMOVED:
            print("Removal of %s at revision %s" % (mc_str, mc_rev(old)))
        elif e == ChangeLogEntry.UPDATED:
            print("Update of %s from revision %s up to %s" %
                  (mc_str, mc_rev(old), mc_rev(new)))
        elif e == ChangeLogEntry.DOWNGRADED:
                print("Downgrade of %s from revision %s down to %s" %
                      (mc_str, mc_rev(old), mc_rev(new)))
        elif e == ChangeLogEntry.OTHER:
            print("Other change in %s:" % old["path"])
            print("  old: %#x/%#x: rev %s (offs %#x)" %
                  (old["cpuid"], old["pf"], mc_rev(old), old["offs"]))
            print("  new: %#x/%#x: rev %s (offs %#x)" %
                  (new["cpuid"], new["pf"], mc_rev(new), new["offs"]))


def print_changelog_intel(clog, cmap, args):
    def clog_sort_key(x):
        res = str(x[0])

        if x[0] != ChangeLogEntry.ADDED:
            res += "%08x%02x" % (x[1]["cpuid"], x[1]["pf"])
        else:
            res += "0" * 10

        if x[0] != ChangeLogEntry.REMOVED:
            res += "%08x%02x" % (x[2]["cpuid"], x[2]["pf"])
        else:
            res += "0" * 10

        return res

    sorted_clog = sorted(clog, key=clog_sort_key)
    sections = (("New Platforms",     (ChangeLogEntry.ADDED, )),
                ("Updated Platforms", (ChangeLogEntry.UPDATED,
                                       ChangeLogEntry.DOWNGRADED)),
                ("Removed Platforms", (ChangeLogEntry.REMOVED, )))

    def print_line(e, old, new, types):
        if e not in types:
            return

        if not print_line.hdr:
            print("""
| Processor      | Stepping | F-M-S/PI    | Old Ver  | New Ver  | Products
|:---------------|:---------|:------------|:---------|:---------|:---------""")
            print_line.hdr = True

        mc = new if e == ChangeLogEntry.ADDED else old
        cnames = get_mc_cnames(mc, cmap, stringify=False,
                               segment=args.segment) or (("???", ""), )
        for cn in cnames:
            cname = cn[0]
            stepping = cn[1] if len(cn) > 1 else ""
        print("| %-14s | %-8s | %8s/%02x | %8s | %8s | %s" %
              (cname,
               stepping,
               cpuid_fname(mc["cpuid"]), mc["pf"],
               ("%08x" % old["rev"]) if e != ChangeLogEntry.ADDED else "",
               ("%08x" % new["rev"]) if e != ChangeLogEntry.REMOVED else "",
               get_mc_cnames(mc, cmap, mode=mcnm.MCNM_FAMILIES,
                             segment=args.segment) or ""))

    for h, types in sections:
        print("\n### %s" % h)
        print_line.hdr = False
        for e, old, new in sorted_clog:
            print_line(e, old, new, types)


def print_changelog(clog, cmap, args):
    if args.format == "rpm":
        print_changelog_rpm(clog, cmap, args)
    elif args.format == "intel":
        print_changelog_intel(clog, cmap, args)
    else:
        log_error(("unknown changelog format: \"%s\". " +
                   "Supported formats are: rpm, intel.") % args.format)


class TableStyles:
    TS_CSV = 0
    TS_FANCY = 1


def print_line(line, column_sz):
    print(" | ".join([str(x).ljust(column_sz[i])
                      for i, x in zip(itertools.count(),
                                      itertools.chain(line,
                                      [""] * (len(column_sz) -
                                              len(line))))]).rstrip())


def print_table(items, header=[], style=TableStyles.TS_CSV):
    if style == TableStyles.TS_CSV:
        for i in items:
            print(";".join(i))
    elif style == TableStyles.TS_FANCY:
        column_sz = list(reduce(lambda x, y:
                                map(max, izip_longest(x, y, fillvalue=0)),
                                [[len(x) for x in i]
                                 for i in itertools.chain(header, items)]))
        for i in header:
            print_line(i, column_sz)
        if header:
            print("-+-".join(["-" * x for x in column_sz]))
        for i in items:
            print_line(i, column_sz)


def print_summary(revs, cmap, args):
    m = gen_fn_map(revs)
    cnames_mode = mcnm.MCNM_ABBREV if args.abbrev else mcnm.MCNM_CODENAME

    header = []
    if args.header:
        header.append(["Path", "Offset", "Ext. Offset", "Data Size",
                       "Total Size", "CPUID", "Platform ID Mask", "Revision",
                       "Date", "Checksum", "Codenames"] +
                      (["Models"] if args.models else []))
    tbl = []
    for k in sorted(m.keys()):
        for mc in m[k]:
            tbl.append([mc_stripped_path(mc),
                        "0x%x" % mc["offs"],
                        "0x%x" % mc["ext_offs"] if "ext_offs" in mc else "-",
                        "0x%05x" % mc["data_size"],
                        "0x%05x" % mc["total_size"],
                        "0x%05x" % mc["cpuid"],
                        "0x%02x" % mc["pf"],
                        mc_rev(mc, date=False),
                        mc_date(mc),
                        "0x%08x" % (mc["ext_cksum"]
                                    if "ext_cksum" in mc else mc["cksum"]),
                        get_mc_cnames(mc, cmap, cnames_mode,
                                      segment=args.segment) or ""] +
                       ([get_mc_cnames(mc, cmap,
                                       mcnm.MCNM_FAMILIES_MODELS,
                                       segment=args.segment)]
                        if args.models else []))

    print_table(tbl, header, style=TableStyles.TS_FANCY)


def read_codenames_file(path):
    '''
    Supports two formats: new and old
     * old: tab-separated. Field order:
       Segment, (unused), Codename, (dash-separated) Stepping,
       Platform ID mask, CPUID, (unused) Update link, (unused) Specs link
     * new: semicolon-separated; support comments.  Distinguished
       by the first line that starts with octothorp.  Field order:
       Segment, Unused, Codename, Stepping, Platform ID mask, CPUID,
       Abbreviation, Variant(s), Families, Models
    '''
    old_fields = ["segment", "_", "codename", "stepping", "pf_mask", "sig",
                  "_update", "_specs"]
    new_fields = ["segment", "_", "codename", "stepping", "pf_mask", "sig",
                  "abbrev", "variant", "families", "models"]
    new_fmt = False
    field_names = old_fields

    res = dict()

    try:
        with open(path, "r") as f:
            for line in f:
                line = line.strip()
                if len(line) == 0:
                    continue
                if line[0] == '#':
                    new_fmt = True
                    field_names = new_fields
                    continue

                fields = line.split(";" if new_fmt else "\t",
                                    1 + len(field_names))
                fields = dict(zip(field_names, fields))
                if "sig" not in fields:
                    log_warn("Skipping %r (from \"%s\")" % (fields, line))
                    continue

                sig = fields["sig"] = int(fields["sig"], 16)
                fields["pf_mask"] = int(fields["pf_mask"], 16)
                fields["stepping"] = fields["stepping"].split(",")
                if "variant" in fields:
                    if fields["variant"]:
                        fields["variant"] = fields["variant"].split(",")
                    else:
                        fields["variant"] = []

                if sig not in res:
                    res[sig] = list()
                res[sig].append(fields)
    except Exception as e:
        log_error("a problem occurred while reading code names: %s" % e)

    return res


def print_discrepancies(rev_map, deps, cmap, args):
    """
    rev_map: dict "name": revs
    deps: list of tuples (name, parent/None)
    """
    sigs = set()

    for p, r in rev_map.items():
        sigs |= set(r.keys())

    if args.header:
        header1 = ["sig"]
        if args.print_vs:
            header2 = [""]
        for p, n, d in deps:
            header1.append(n)
            if args.print_vs:
                add = ""
                if d:
                    for pd, nd, dd in deps:
                        if pd == d:
                            add = "(vs. %s)" % nd
                            break
                header2.append(add)
        if args.models:
            header1.append("Model names")
            if args.print_vs:
                header2.append("")
    header = [header1] + ([header2] if args.print_vs else [])

    tbl = []
    for s in sorted(sigs):
        out = [mc_path(s)]
        print_out = not args.print_filter
        print_date = args.min_date is None

        for p, n, d in deps:
            cur = dict([(x["rev"], x) for x in rev_map[p][s]]) \
                  if s in rev_map[p] else []
            v = "/".join([mc_rev(y) for x, y in sorted(cur.items())]) \
                if cur else "-"
            if d is not None:
                prev = [x["rev"] for x in rev_map[d][s]] if s in rev_map[d] \
                        else []
                if [x for x in cur if x not in prev]:
                    v += " (*)"
                    print_out = True
            if args.min_date is not None and s in rev_map[p]:
                for x in rev_map[p][s]:
                    print_date |= mc_date(x) > args.min_date
            out.append(v)

        if print_out and print_date:
            if args.models:
                out.append(get_mc_cnames(s, cmap, segment=args.segment) or "")
            tbl.append(out)

    print_table(tbl, header, style=TableStyles.TS_FANCY)


def cmd_summary(args):
    revs = []
    for p in args.filelist:
        revs = read_revs(p, args, ret=revs)

    codenames_map = read_codenames_file(args.codenames)

    print_summary(revs, codenames_map, args)

    return 0


def cmd_changelog(args):
    codenames_map = read_codenames_file(args.codenames)
    base_path = args.filelist[0]
    upd_path = args.filelist[1]

    base = read_revs(base_path, args)
    upd = read_revs(upd_path, args)

    print_changelog(gen_changelog(base, upd), codenames_map, args)

    return 0


def cmd_discrepancies(args):
    """
    filenames:
     * "<" prefix (possibly multiple times) to refer to a previous entry
       to compare against
     * "[name]" prefix is a name reference
    """
    codenames_map = read_codenames_file(args.codenames)
    rev_map = dict()
    deps = list()
    cur = -1

    for path in args.filelist:
        orig_path = path
        name = None
        cur += 1
        dep = None
        while True:
            if path[0] == '<':
                path = path[1:]
                dep = cur - 1 if dep is None else dep - 1
            elif path[0] == '[' and path.find(']') > 0:
                pos = path.find(']')
                name = path[1:pos]
                path = path[pos + 1:]
            else:
                break
        if name is None:
            name = path
        if dep is not None and dep < 0:
            log_error("Incorrect dep reference for '%s' (points to index %d)" %
                      (orig_path, dep))
            return 1
        deps.append((path, name, deps[dep][0] if dep is not None else None))
        rev_map[path] = gen_fn_map(read_revs(path, args), merge=args.merge,
                                   merge_path=True)

    print_discrepancies(rev_map, deps, codenames_map, args)

    return 0


def parse_cli():
    root_parser = argparse.ArgumentParser(prog="gen_updates",
                                          description="Intel CPU Microcode " +
                                          "parser")
    root_parser.add_argument("-C", "--codenames", default='codenames',
                             help="Code names file")
    root_parser.add_argument("-v", "--verbose", action="count", default=0,
                             help="Increase output verbosity")
    root_parser.add_argument("-E", "--no-ignore-ext-duplicates",
                             action="store_const", dest="ignore_ext_dups",
                             default=False, const=False,
                             help="Do not ignore duplicates of the main " +
                                  "signature in the extended signature header")
    root_parser.add_argument("-e", "--ignore-ext-duplicates",
                             action="store_const", dest="ignore_ext_dups",
                             const=True,
                             help="Ignore duplicates of the main signature " +
                                   "in the extended signature header")
    root_parser.add_argument("-t", "--print-segment", action="store_const",
                             dest="segment", const=True,
                             help="Print model segment")
    root_parser.add_argument("-T", "--no-print-segment", action="store_const",
                             dest="segment", const=False, default=False,
                             help="Do not print model segment")

    cmdparsers = root_parser.add_subparsers(title="Commands",
                                            help="main gen_updates commands")

    parser_s = cmdparsers.add_parser("summary",
                                     help="Generate microcode summary")
    parser_s.add_argument("-a", "--abbreviate", action="store_const",
                          dest="abbrev", const=True, default=True,
                          help="Abbreviate code names")
    parser_s.add_argument("-A", "--no-abbreviate", action="store_const",
                          dest="abbrev", const=False,
                          help="Do not abbreviate code names")
    parser_s.add_argument("-m", "--print-models", action="store_const",
                          dest="models", const=True, default=False,
                          help="Print models")
    parser_s.add_argument("-M", "--no-print-models",
                          action="store_const", dest="models",
                          const=False, help="Do not print models")
    parser_s.add_argument("-H", "--no-print-header",
                          action="store_const", dest="header",
                          const=False, default=True,
                          help="Do not print hader")
    parser_s.add_argument("filelist", nargs="*", default=[],
                          help="List or RPMs/directories to process")
    parser_s.set_defaults(func=cmd_summary)

    parser_c = cmdparsers.add_parser("changelog",
                                     help="Generate changelog")
    parser_c.add_argument("-F", "--format", choices=["rpm", "intel"],
                          default="rpm", help="Changelog format")
    parser_c.add_argument("filelist", nargs=2,
                          help="RPMs/directories to compare")
    parser_c.set_defaults(func=cmd_changelog)

    parser_d = cmdparsers.add_parser("discrepancies",
                                     help="Generate discrepancies")
    parser_d.add_argument("-s", "--merge-revs", action="store_const",
                          dest="merge", const=True, default=False,
                          help="Merge revisions that come" +
                               " from different files")
    parser_d.add_argument("-S", "--no-merge-revs", action="store_const",
                          dest="merge", const=False,
                          help="Do not Merge revisions that come" +
                               " from different files")
    parser_d.add_argument("-v", "--print-vs", action="store_const",
                          dest="print_vs", const=True, default=False,
                          help="Print base version ")
    parser_d.add_argument("-V", "--no-print-vs", action="store_const",
                          dest="print_vs", const=False,
                          help="Do not Merge revisions that come" +
                               " from different files")
    parser_d.add_argument("-m", "--print-models", action="store_const",
                          dest="models", const=True, default=True,
                          help="Print model names")
    parser_d.add_argument("-M", "--no-print-models", action="store_const",
                          dest="models", const=False,
                          help="Do not print model names")
    parser_d.add_argument("-H", "--no-print-header", action="store_const",
                          dest="header", const=False, default=True,
                          help="Do not print hader")
    parser_d.add_argument("-a", "--print-all-files", action="store_const",
                          dest="print_filter", const=False, default=True,
                          help="Print all files")
    parser_d.add_argument("-c", "--print-changed-files", action="store_const",
                          dest="print_filter", const=True,
                          help="Print only changed files")
    parser_d.add_argument("-d", "--min-date", action="store",
                          help="Minimum date filter")
    parser_d.add_argument("filelist", nargs='*',
                          help="RPMs/directories to compare")
    parser_d.set_defaults(func=cmd_discrepancies)

    args = root_parser.parse_args()
    if not hasattr(args, "func"):
        root_parser.print_help()
        return None

    global log_level
    log_level = args.verbose

    return args


def main():
    args = parse_cli()
    if args is None:
        return 1

    return args.func(args)


if __name__ == "__main__":
    sys.exit(main())