libvirt/src/util/virarch.c

237 lines
6.5 KiB
C
Raw Normal View History

/*
* virarch.c: architecture handling
*
* Copyright (C) 2012 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
#include <config.h>
#ifdef WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
#else
# include <sys/utsname.h>
#endif
2012-12-12 17:59:27 +00:00
#include "virlog.h"
#include "virarch.h"
VIR_LOG_INIT("util.arch");
/* The canonical names are used in XML documents. ie ABI sensitive */
static const struct virArchData {
const char *name;
unsigned int wordsize;
virArchEndian endian;
} virArchData[] = {
{ "none", 0, VIR_ARCH_LITTLE_ENDIAN },
{ "alpha", 64, VIR_ARCH_BIG_ENDIAN },
{ "armv6l", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "armv7l", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "armv7b", 32, VIR_ARCH_BIG_ENDIAN },
{ "aarch64", 64, VIR_ARCH_LITTLE_ENDIAN },
{ "cris", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "i686", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "ia64", 64, VIR_ARCH_LITTLE_ENDIAN },
{ "lm32", 32, VIR_ARCH_BIG_ENDIAN },
{ "m68k", 32, VIR_ARCH_BIG_ENDIAN },
{ "microblaze", 32, VIR_ARCH_BIG_ENDIAN },
{ "microblazeel", 32, VIR_ARCH_LITTLE_ENDIAN},
{ "mips", 32, VIR_ARCH_BIG_ENDIAN },
{ "mipsel", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "mips64", 64, VIR_ARCH_BIG_ENDIAN },
{ "mips64el", 64, VIR_ARCH_LITTLE_ENDIAN },
{ "openrisc", 32, VIR_ARCH_BIG_ENDIAN },
{ "parisc", 32, VIR_ARCH_BIG_ENDIAN },
{ "parisc64", 64, VIR_ARCH_BIG_ENDIAN },
{ "ppc", 32, VIR_ARCH_BIG_ENDIAN },
{ "ppcle", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "ppc64", 64, VIR_ARCH_BIG_ENDIAN },
{ "ppc64le", 64, VIR_ARCH_LITTLE_ENDIAN },
{ "ppcemb", 32, VIR_ARCH_BIG_ENDIAN },
{ "riscv32", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "riscv64", 64, VIR_ARCH_LITTLE_ENDIAN },
{ "s390", 32, VIR_ARCH_BIG_ENDIAN },
{ "s390x", 64, VIR_ARCH_BIG_ENDIAN },
{ "sh4", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "sh4eb", 64, VIR_ARCH_BIG_ENDIAN },
{ "sparc", 32, VIR_ARCH_BIG_ENDIAN },
{ "sparc64", 64, VIR_ARCH_BIG_ENDIAN },
{ "unicore32", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "x86_64", 64, VIR_ARCH_LITTLE_ENDIAN },
{ "xtensa", 32, VIR_ARCH_LITTLE_ENDIAN },
{ "xtensaeb", 32, VIR_ARCH_BIG_ENDIAN },
};
G_STATIC_ASSERT(G_N_ELEMENTS(virArchData) == VIR_ARCH_LAST);
/**
* virArchGetWordSize:
* @arch: the CPU architecture
*
* Return the wordsize of the CPU architecture (32 or 64)
*/
unsigned int virArchGetWordSize(virArch arch)
{
if (arch >= VIR_ARCH_LAST)
arch = VIR_ARCH_NONE;
return virArchData[arch].wordsize;
}
/**
* virArchGetEndian:
* @arch: the CPU architecture
*
* Return the endian-ness of the CPU architecture
* (VIR_ARCH_LITTLE_ENDIAN or VIR_ARCH_BIG_ENDIAN)
*/
virArchEndian virArchGetEndian(virArch arch)
{
if (arch >= VIR_ARCH_LAST)
arch = VIR_ARCH_NONE;
return virArchData[arch].endian;
}
/**
* virArchToString:
* @arch: the CPU architecture
*
* Return the string name of the architecture
*/
const char *virArchToString(virArch arch)
{
if (arch >= VIR_ARCH_LAST)
arch = VIR_ARCH_NONE;
return virArchData[arch].name;
}
/**
* virArchFromString:
* @archstr: the CPU architecture string
*
* Return the architecture matching @archstr,
* defaulting to VIR_ARCH_NONE if unidentified
*/
virArch virArchFromString(const char *archstr)
{
size_t i;
for (i = 1; i < VIR_ARCH_LAST; i++) {
if (STREQ(virArchData[i].name, archstr))
return i;
}
VIR_DEBUG("Unknown arch %s", archstr);
return VIR_ARCH_NONE;
}
/**
* virArchFromHost:
*
* Return the host architecture. Prefer this to the
* uname 'machine' field, since this will canonicalize
* architecture names like 'amd64' into 'x86_64'.
*/
#ifdef WIN32
/*
* Missing in ming64 headers 6.0.0, but defined as '12' in:
*
* https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info
*/
# ifndef PROCESSOR_ARCHITECTURE_ARM64
# define PROCESSOR_ARCHITECTURE_ARM64 12
# endif
virArch virArchFromHost(void)
{
SYSTEM_INFO info;
GetSystemInfo(&info);
switch (info.wProcessorArchitecture) {
case PROCESSOR_ARCHITECTURE_AMD64:
return VIR_ARCH_X86_64;
case PROCESSOR_ARCHITECTURE_IA64:
return VIR_ARCH_ITANIUM;
case PROCESSOR_ARCHITECTURE_INTEL:
case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
return VIR_ARCH_I686;
case PROCESSOR_ARCHITECTURE_MIPS:
return VIR_ARCH_MIPS;
case PROCESSOR_ARCHITECTURE_ALPHA:
return VIR_ARCH_ALPHA;
case PROCESSOR_ARCHITECTURE_PPC:
return VIR_ARCH_PPC;
case PROCESSOR_ARCHITECTURE_SHX:
return VIR_ARCH_SH4;
case PROCESSOR_ARCHITECTURE_ARM:
return VIR_ARCH_ARMV7L;
case PROCESSOR_ARCHITECTURE_ARM64:
return VIR_ARCH_AARCH64;
default:
VIR_WARN("Unknown host arch '%d', report to libvir-list@redhat.com",
info.wProcessorArchitecture);
return VIR_ARCH_NONE;
}
}
#else /* !WIN32 */
virArch virArchFromHost(void)
{
struct utsname ut;
virArch arch;
uname(&ut);
/* Some special cases we need to handle first
* for non-canonical names */
if (strlen(ut.machine) == 4 &&
ut.machine[0] == 'i' &&
ut.machine[2] == '8' &&
ut.machine[3] == '6' &&
ut.machine[4] == '\0') {
arch = VIR_ARCH_I686;
} else if (STREQ(ut.machine, "amd64")) {
arch = VIR_ARCH_X86_64;
} else {
/* Otherwise assume the canonical name */
if ((arch = virArchFromString(ut.machine)) == VIR_ARCH_NONE) {
VIR_WARN("Unknown host arch %s, report to libvir-list@redhat.com",
ut.machine);
}
}
VIR_DEBUG("Mapped %s to %d (%s)",
ut.machine, arch, virArchToString(arch));
return arch;
}
#endif /* !WIN32 */