pungi/pungi/arch_utils.py

# A copy of some necessary parts from yum.rpmUtils.arch, with slightly changes:
# 1. _ppc64_native_is_best changed to True
# 2. code style fixes for flake8 reported errors

import os
import rpm
import ctypes
import struct

# _ppc64_native_is_best is False in yum's source code, but patched with a
# separate patch when built from source rpm, so we set it to True here.
_ppc64_native_is_best = True

# dict mapping arch -> ( multicompat, best personality, biarch personality )
multilibArches = {
    "x86_64": ("athlon", "x86_64", "athlon"),
    "sparc64v": ("sparcv9v", "sparcv9v", "sparc64v"),
    "sparc64": ("sparcv9", "sparcv9", "sparc64"),
    "ppc64": ("ppc", "ppc", "ppc64"),
    "s390x": ("s390", "s390x", "s390"),
}
if _ppc64_native_is_best:
    multilibArches["ppc64"] = ("ppc", "ppc64", "ppc64")

arches = {
    # ia32
    "athlon": "i686",
    "i686": "i586",
    "geode": "i586",
    "i586": "i486",
    "i486": "i386",
    "i386": "noarch",
    # amd64
    "x86_64": "athlon",
    "amd64": "x86_64",
    "ia32e": "x86_64",
    # ppc64le
    "ppc64le": "noarch",
    # ppc
    "ppc64p7": "ppc64",
    "ppc64pseries": "ppc64",
    "ppc64iseries": "ppc64",
    "ppc64": "ppc",
    "ppc": "noarch",
    # s390{,x}
    "s390x": "s390",
    "s390": "noarch",
    # sparc
    "sparc64v": "sparcv9v",
    "sparc64": "sparcv9",
    "sparcv9v": "sparcv9",
    "sparcv9": "sparcv8",
    "sparcv8": "sparc",
    "sparc": "noarch",
    # alpha
    "alphaev7": "alphaev68",
    "alphaev68": "alphaev67",
    "alphaev67": "alphaev6",
    "alphaev6": "alphapca56",
    "alphapca56": "alphaev56",
    "alphaev56": "alphaev5",
    "alphaev5": "alphaev45",
    "alphaev45": "alphaev4",
    "alphaev4": "alpha",
    "alpha": "noarch",
    # arm
    "armv7l": "armv6l",
    "armv6l": "armv5tejl",
    "armv5tejl": "armv5tel",
    "armv5tel": "noarch",
    # arm hardware floating point
    "armv7hnl": "armv7hl",
    "armv7hl": "armv6hl",
    "armv6hl": "noarch",
    # arm64
    "arm64": "noarch",
    # aarch64
    "aarch64": "noarch",
    # super-h
    "sh4a": "sh4",
    "sh4": "noarch",
    "sh3": "noarch",
    # itanium
    "ia64": "noarch",
}

#  Will contain information parsed from /proc/self/auxv via _parse_auxv().
# Should move into rpm really.
_aux_vector = {
    "platform": "",
    "hwcap": 0,
}


def isMultiLibArch(arch=None):  # pragma: no cover
    """returns true if arch is a multilib arch, false if not"""
    if arch is None:
        arch = canonArch

    if arch not in arches:  # or we could check if it is noarch
        return 0

    if arch in multilibArches:
        return 1

    if arches[arch] in multilibArches:
        return 1

    return 0


def getArchList(thisarch=None):  # pragma: no cover
    # this returns a list of archs that are compatible with arch given
    if not thisarch:
        thisarch = canonArch

    archlist = [thisarch]
    while thisarch in arches:
        thisarch = arches[thisarch]
        archlist.append(thisarch)

    # hack hack hack
    # sparc64v is also sparc64 compat
    if archlist[0] == "sparc64v":
        archlist.insert(1, "sparc64")

    # if we're a weirdo arch - add noarch on there.
    if len(archlist) == 1 and archlist[0] == thisarch:
        archlist.append("noarch")
    return archlist


def _try_read_cpuinfo():  # pragma: no cover
    """Try to read /proc/cpuinfo ... if we can't ignore errors (ie. proc not
    mounted)."""
    try:
        with open("/proc/cpuinfo", "r") as f:
            return f.readlines()
    except Exception:
        return []


def _parse_auxv():  # pragma: no cover
    """Read /proc/self/auxv and parse it into global dict for easier access
    later on, very similar to what rpm does."""
    # In case we can't open and read /proc/self/auxv, just return
    try:
        with open("/proc/self/auxv", "rb") as f:
            data = f.read()
    except Exception:
        return

    # Define values from /usr/include/elf.h
    AT_PLATFORM = 15
    AT_HWCAP = 16
    fmtlen = struct.calcsize("LL")
    offset = 0
    platform = ctypes.c_char_p()

    # Parse the data and fill in _aux_vector dict
    while offset <= len(data) - fmtlen:
        at_type, at_val = struct.unpack_from("LL", data, offset)
        if at_type == AT_PLATFORM:
            platform.value = at_val
            _aux_vector["platform"] = platform.value
        if at_type == AT_HWCAP:
            _aux_vector["hwcap"] = at_val
        offset = offset + fmtlen


def getCanonX86Arch(arch):  # pragma: no cover
    if arch == "i586":
        for line in _try_read_cpuinfo():
            if line.startswith("model name"):
                if line.find("Geode(TM)") != -1:
                    return "geode"
                break
        return arch
    # only athlon vs i686 isn't handled with uname currently
    if arch != "i686":
        return arch

    # if we're i686 and AuthenticAMD, then we should be an athlon
    for line in _try_read_cpuinfo():
        if line.startswith("vendor") and line.find("AuthenticAMD") != -1:
            return "athlon"
        elif line.startswith("vendor") and line.find("HygonGenuine") != -1:
            return "athlon"
        # i686 doesn't guarantee cmov, but we depend on it
        elif line.startswith("flags"):
            if line.find("cmov") == -1:
                return "i586"
            break

    return arch


def getCanonARMArch(arch):  # pragma: no cover
    # the %{_target_arch} macro in rpm will let us know the abi we are using
    target = rpm.expandMacro("%{_target_cpu}")
    if target.startswith("armv6h"):
        return target
    if target.startswith("armv7h"):
        return target
    return arch


def getCanonPPCArch(arch):  # pragma: no cover
    # FIXME: should I do better handling for mac, etc?
    if arch != "ppc64":
        return arch

    machine = None
    for line in _try_read_cpuinfo():
        if line.find("machine") != -1:
            machine = line.split(":")[1]
            break

    platform = _aux_vector["platform"]
    if machine is None and not platform:
        return arch

    try:
        if platform.startswith("power") and int(platform[5:].rstrip("+")) >= 7:
            return "ppc64p7"
    except Exception:
        pass

    if machine is None:
        return arch

    if machine.find("CHRP IBM") != -1:
        return "ppc64pseries"
    if machine.find("iSeries") != -1:
        return "ppc64iseries"
    return arch


def getCanonSPARCArch(arch):  # pragma: no cover
    # Deal with sun4v, sun4u, sun4m cases
    SPARCtype = None
    for line in _try_read_cpuinfo():
        if line.startswith("type"):
            SPARCtype = line.split(":")[1]
            break
    if SPARCtype is None:
        return arch

    if SPARCtype.find("sun4v") != -1:
        if arch.startswith("sparc64"):
            return "sparc64v"
        else:
            return "sparcv9v"
    if SPARCtype.find("sun4u") != -1:
        if arch.startswith("sparc64"):
            return "sparc64"
        else:
            return "sparcv9"
    if SPARCtype.find("sun4m") != -1:
        return "sparcv8"
    return arch


def getCanonX86_64Arch(arch):  # pragma: no cover
    if arch != "x86_64":
        return arch

    vendor = None
    for line in _try_read_cpuinfo():
        if line.startswith("vendor_id"):
            vendor = line.split(":")[1]
            break
    if vendor is None:
        return arch

    if vendor.find("Authentic AMD") != -1 or vendor.find("AuthenticAMD") != -1:
        return "amd64"
    if vendor.find("HygonGenuine") != -1:
        return "amd64"
    if vendor.find("GenuineIntel") != -1:
        return "ia32e"
    return arch


def getCanonArch(skipRpmPlatform=0):  # pragma: no cover
    if not skipRpmPlatform and os.access("/etc/rpm/platform", os.R_OK):
        try:
            f = open("/etc/rpm/platform", "r")
            line = f.readline()
            f.close()
            (arch, vendor, opersys) = line.split("-", 2)
            return arch
        except Exception:
            pass

    arch = os.uname()[4]

    _parse_auxv()

    if len(arch) == 4 and arch[0] == "i" and arch[2:4] == "86":
        return getCanonX86Arch(arch)

    if arch.startswith("arm"):
        return getCanonARMArch(arch)
    if arch.startswith("ppc"):
        return getCanonPPCArch(arch)
    if arch.startswith("sparc"):
        return getCanonSPARCArch(arch)
    if arch == "x86_64":
        return getCanonX86_64Arch(arch)

    return arch


canonArch = getCanonArch()


# this gets you the "compat" arch of a biarch pair
def getMultiArchInfo(arch=canonArch):  # pragma: no cover
    if arch in multilibArches:
        return multilibArches[arch]
    if arch in arches and arches[arch] != "noarch":
        return getMultiArchInfo(arch=arches[arch])
    return None


def getBaseArch(myarch=None):  # pragma: no cover
    """returns 'base' arch for myarch, if specified, or canonArch if not.
    base arch is the arch before noarch in the arches dict if myarch is not
    a key in the multilibArches."""

    if not myarch:
        myarch = canonArch

    if myarch not in arches:  # this is dumb, but <shrug>
        return myarch

    if myarch.startswith("sparc64"):
        return "sparc"
    elif myarch == "ppc64le":
        return "ppc64le"
    elif myarch.startswith("ppc64") and not _ppc64_native_is_best:
        return "ppc"
    elif myarch.startswith("arm64"):
        return "arm64"
    elif myarch.startswith("armv6h"):
        return "armhfp"
    elif myarch.startswith("armv7h"):
        return "armhfp"
    elif myarch.startswith("arm"):
        return "arm"

    if isMultiLibArch(arch=myarch):
        if myarch in multilibArches:
            return myarch
        else:
            return arches[myarch]

    if myarch in arches:
        basearch = myarch
        value = arches[basearch]
        while value != "noarch":
            basearch = value
            value = arches[basearch]

        return basearch