From 7ffb3c628dea313496c829bcb40447545470847e Mon Sep 17 00:00:00 2001

From: Karel Zak <kzak@redhat.com>

Date: Tue, 21 Mar 2017 14:57:37 +0100

Subject: [PATCH 115/116] lscpu: backport from v2.29

Addresses: https://bugzilla.redhat.com/show_bug.cgi?id=1360764

Addresses: https://bugzilla.redhat.com/show_bug.cgi?id=1397709

Signed-off-by: Karel Zak <kzak@redhat.com>

---

 configure.ac            |   3 +-

 include/c.h             |  30 ++

 include/pathnames.h     |   2 +

 include/xalloc.h        |  10 +

 sys-utils/Makemodule.am |   8 +-

 sys-utils/lscpu-dmi.c   | 285 ++++++++++++++

 sys-utils/lscpu.1       |  53 ++-

 sys-utils/lscpu.c       | 964 ++++++++++++++++++++++++++++++++++++++++--------

 sys-utils/lscpu.h       |  26 ++

 9 files changed, 1220 insertions(+), 161 deletions(-)

 create mode 100644 sys-utils/lscpu-dmi.c

 create mode 100644 sys-utils/lscpu.h

diff --git a/configure.ac b/configure.ac

index db7095a..78258d6 100644

--- a/configure.ac

+++ b/configure.ac

@@ -1059,8 +1059,9 @@ AM_CONDITIONAL(BUILD_LSBLK, test "x$build_lsblk" = xyes)

 UL_BUILD_INIT([lscpu], [check])

 UL_REQUIRES_LINUX([lscpu])

+UL_REQUIRES_BUILD([lscpu], [libsmartcols])

 UL_REQUIRES_HAVE([lscpu], [cpu_set_t], [cpu_set_t type])

-AM_CONDITIONAL(BUILD_LSCPU, test "x$build_lscpu" = xyes)

+AM_CONDITIONAL([BUILD_LSCPU], [test "x$build_lscpu" = xyes])

 UL_BUILD_INIT([lslogins], [check])

diff --git a/include/c.h b/include/c.h

index 3754e75..8ff61b4 100644

--- a/include/c.h

+++ b/include/c.h

@@ -200,6 +200,19 @@ errmsg(char doexit, int excode, char adderr, const char *fmt, ...)

 #endif

 #endif /* !HAVE_ERR_H */

+/* Don't use inline function to avoid '#include "nls.h"' in c.h

+ */

+#define errtryhelp(eval) __extension__ ({ \

+	fprintf(stderr, _("Try '%s --help' for more information.\n"), \

+			program_invocation_short_name); \

+	exit(eval); \

+})

+

+#define errtryh(eval) __extension__ ({ \

+	fprintf(stderr, _("Try '%s -h' for more information.\n"), \

+			program_invocation_short_name); \

+	exit(eval); \

+})

 static inline __attribute__((const)) int is_power_of_2(unsigned long num)

 {

@@ -317,6 +330,23 @@ static inline int usleep(useconds_t usec)

 #define stringify(s) #s

 /*

+ * UL_ASAN_BLACKLIST is a macro to tell AddressSanitizer (a compile-time

+ * instrumentation shipped with Clang and GCC) to not instrument the

+ * annotated function.  Furthermore, it will prevent the compiler from

+ * inlining the function because inlining currently breaks the blacklisting

+ * mechanism of AddressSanitizer.

+ */

+#if defined(__has_feature)

+# if __has_feature(address_sanitizer)

+#  define UL_ASAN_BLACKLIST __attribute__((noinline)) __attribute__((no_sanitize_memory)) __attribute__((no_sanitize_address))

+# else

+#  define UL_ASAN_BLACKLIST	/* nothing */

+# endif

+#else

+# define UL_ASAN_BLACKLIST	/* nothing */

+#endif

+

+/*

  * Note that sysconf(_SC_GETPW_R_SIZE_MAX) returns *initial* suggested size for

  * pwd buffer and in some cases it is not large enough. See POSIX and

  * getpwnam_r man page for more details.

diff --git a/include/pathnames.h b/include/pathnames.h

index b648afc..fa4bddb 100644

--- a/include/pathnames.h

+++ b/include/pathnames.h

@@ -131,6 +131,8 @@

 # define _PATH_DEV		"/dev/"

 #endif

+#define _PATH_DEV_MEM           "/dev/mem"

+

 #define _PATH_DEV_LOOP		"/dev/loop"

 #define _PATH_DEV_LOOPCTL	"/dev/loop-control"

 #define _PATH_DEV_TTY		"/dev/tty"

diff --git a/include/xalloc.h b/include/xalloc.h

index 1a1799a..883e472 100644

--- a/include/xalloc.h

+++ b/include/xalloc.h

@@ -99,6 +99,16 @@ static inline int __attribute__ ((__format__(printf, 2, 3)))

 }

+static inline int  __attribute__ ((__format__(printf, 2, 0)))

+xvasprintf(char **strp, const char *fmt, va_list ap)

+{

+	int ret = vasprintf(&(*strp), fmt, ap);

+	if (ret < 0)

+		err(XALLOC_EXIT_CODE, "cannot allocate string");

+	return ret;

+}

+

+

 static inline char *xgethostname(void)

 {

 	char *name;

diff --git a/sys-utils/Makemodule.am b/sys-utils/Makemodule.am

index 408e884..0496b84 100644

--- a/sys-utils/Makemodule.am

+++ b/sys-utils/Makemodule.am

@@ -274,8 +274,12 @@ endif

 if BUILD_LSCPU

 usrbin_exec_PROGRAMS += lscpu

-lscpu_SOURCES = sys-utils/lscpu.c

-lscpu_LDADD = $(LDADD) libcommon.la

+lscpu_SOURCES = \

+	sys-utils/lscpu.c \

+	sys-utils/lscpu.h \

+	sys-utils/lscpu-dmi.c

+lscpu_LDADD = $(LDADD) libcommon.la libsmartcols.la $(RTAS_LIBS)

+lscpu_CFLAGS = $(AM_CFLAGS) -I$(ul_libsmartcols_incdir)

 dist_man_MANS += sys-utils/lscpu.1

 endif

diff --git a/sys-utils/lscpu-dmi.c b/sys-utils/lscpu-dmi.c

new file mode 100644

index 0000000..0e497d1

--- /dev/null

+++ b/sys-utils/lscpu-dmi.c

@@ -0,0 +1,285 @@

+/*

+ * lscpu-dmi - Module to parse SMBIOS information

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it would be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License along

+ * with this program; if not, write to the Free Software Foundation, Inc.,

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+ *

+ * Code originally taken from the dmidecode utility and slightly rewritten

+ * to suite the needs of lscpu

+ */

+#include <errno.h>

+#include <stdlib.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <fcntl.h>

+#include <unistd.h>

+#include <string.h>

+#include <stdio.h>

+

+#include "c.h"

+#include "pathnames.h"

+#include "all-io.h"

+#include "lscpu.h"

+

+#define WORD(x) (uint16_t)(*(const uint16_t *)(x))

+#define DWORD(x) (uint32_t)(*(const uint32_t *)(x))

+

+struct dmi_header

+{

+	uint8_t type;

+	uint8_t length;

+	uint16_t handle;

+	uint8_t *data;

+};

+

+static int checksum(const uint8_t *buf, size_t len)

+{

+	uint8_t sum = 0;

+	size_t a;

+

+	for (a = 0; a < len; a++)

+		sum += buf[a];

+	return (sum == 0);

+}

+

+static void *get_mem_chunk(size_t base, size_t len, const char *devmem)

+{

+	void *p = NULL;

+	int fd;

+

+	if ((fd = open(devmem, O_RDONLY)) < 0)

+		return NULL;

+

+	if (!(p = malloc(len)))

+		goto nothing;

+	if (lseek(fd, base, SEEK_SET) == -1)

+		goto nothing;

+	if (read_all(fd, p, len) == -1)

+		goto nothing;

+

+	close(fd);

+	return p;

+

+nothing:

+	free(p);

+	close(fd);

+	return NULL;

+}

+

+static void to_dmi_header(struct dmi_header *h, uint8_t *data)

+{

+	h->type = data[0];

+	h->length = data[1];

+	h->handle = WORD(data + 2);

+	h->data = data;

+}

+

+static char *dmi_string(const struct dmi_header *dm, uint8_t s)

+{

+	char *bp = (char *)dm->data;

+

+	if (s == 0)

+		return NULL;

+

+	bp += dm->length;

+	while (s > 1 && *bp)

+	{

+		bp += strlen(bp);

+		bp++;

+		s--;

+	}

+

+	if (!*bp)

+		return NULL;

+

+	return bp;

+}

+

+static int hypervisor_from_dmi_table(uint32_t base, uint16_t len,

+				uint16_t num, const char *devmem)

+{

+	uint8_t *buf;

+	uint8_t *data;

+	int i = 0;

+	char *vendor = NULL;

+	char *product = NULL;

+	char *manufacturer = NULL;

+	int rc = HYPER_NONE;

+

+	data = buf = get_mem_chunk(base, len, devmem);

+	if (!buf)

+		goto done;

+

+	 /* 4 is the length of an SMBIOS structure header */

+	while (i < num && data + 4 <= buf + len) {

+		uint8_t *next;

+		struct dmi_header h;

+

+		to_dmi_header(&h, data);

+

+		/*

+		 * If a short entry is found (less than 4 bytes), not only it

+		 * is invalid, but we cannot reliably locate the next entry.

+		 * Better stop at this point.

+		 */

+		if (h.length < 4)

+			goto done;

+

+		/* look for the next handle */

+		next = data + h.length;

+		while (next - buf + 1 < len && (next[0] != 0 || next[1] != 0))

+			next++;

+		next += 2;

+		switch (h.type) {

+			case 0:

+				vendor = dmi_string(&h, data[0x04]);

+				break;

+			case 1:

+				manufacturer = dmi_string(&h, data[0x04]);

+				product = dmi_string(&h, data[0x05]);

+				break;

+			default:

+				break;

+		}

+

+		data = next;

+		i++;

+	}

+	if (manufacturer && !strcmp(manufacturer, "innotek GmbH"))

+		rc = HYPER_INNOTEK;

+	else if (manufacturer && strstr(manufacturer, "HITACHI") &&

+					product && strstr(product, "LPAR"))

+		rc = HYPER_HITACHI;

+	else if (vendor && !strcmp(vendor, "Parallels"))

+		rc = HYPER_PARALLELS;

+done:

+	free(buf);

+	return rc;

+}

+

+#if defined(__x86_64__) || defined(__i386__)

+static int hypervisor_decode_legacy(uint8_t *buf, const char *devmem)

+{

+	if (!checksum(buf, 0x0F))

+		return HYPER_NONE;

+

+	return hypervisor_from_dmi_table(DWORD(buf + 0x08), WORD(buf + 0x06),

+			 WORD(buf + 0x0C),

+		devmem);

+}

+#endif

+

+static int hypervisor_decode_smbios(uint8_t *buf, const char *devmem)

+{

+	if (!checksum(buf, buf[0x05])

+	    || memcmp(buf + 0x10, "_DMI_", 5) != 0

+	    || !checksum(buf + 0x10, 0x0F))

+		return -1;

+

+	return hypervisor_from_dmi_table(DWORD(buf + 0x18), WORD(buf + 0x16),

+			 WORD(buf + 0x1C),

+		devmem);

+}

+

+/*

+ * Probe for EFI interface

+ */

+#define EFI_NOT_FOUND   (-1)

+#define EFI_NO_SMBIOS   (-2)

+static int address_from_efi(size_t *address)

+{

+	FILE *tab;

+	char linebuf[64];

+	int ret;

+

+	*address = 0; /* Prevent compiler warning */

+

+	/*

+	 * Linux up to 2.6.6: /proc/efi/systab

+	 * Linux 2.6.7 and up: /sys/firmware/efi/systab

+	 */

+	if (!(tab = fopen("/sys/firmware/efi/systab", "r")) &&

+	    !(tab = fopen("/proc/efi/systab", "r")))

+		return EFI_NOT_FOUND;		/* No EFI interface */

+

+	ret = EFI_NO_SMBIOS;

+	while ((fgets(linebuf, sizeof(linebuf) - 1, tab)) != NULL) {

+		char *addrp = strchr(linebuf, '=');

+		if (!addrp)

+			continue;

+		*(addrp++) = '\0';

+		if (strcmp(linebuf, "SMBIOS") == 0) {

+			*address = strtoul(addrp, NULL, 0);

+			ret = 0;

+			break;

+		}

+	}

+

+	fclose(tab);

+	return ret;

+}

+

+int read_hypervisor_dmi(void)

+{

+	int rc = HYPER_NONE;

+	uint8_t *buf = NULL;

+	size_t fp = 0;

+

+	if (sizeof(uint8_t) != 1

+	    || sizeof(uint16_t) != 2

+	    || sizeof(uint32_t) != 4

+	    || '\0' != 0)

+		return rc;

+

+	/* First try EFI (ia64, Intel-based Mac) */

+	switch (address_from_efi(&fp)) {

+		case EFI_NOT_FOUND:

+			goto memory_scan;

+		case EFI_NO_SMBIOS:

+			goto done;

+	}

+

+	buf = get_mem_chunk(fp, 0x20, _PATH_DEV_MEM);

+	if (!buf)

+		goto done;

+

+	rc = hypervisor_decode_smbios(buf, _PATH_DEV_MEM);

+	if (rc)

+		goto done;

+	free(buf);

+	buf = NULL;

+memory_scan:

+#if defined(__x86_64__) || defined(__i386__)

+	/* Fallback to memory scan (x86, x86_64) */

+	buf = get_mem_chunk(0xF0000, 0x10000, _PATH_DEV_MEM);

+	if (!buf)

+		goto done;

+

+	for (fp = 0; fp <= 0xFFF0; fp += 16) {

+		if (memcmp(buf + fp, "_SM_", 4) == 0 && fp <= 0xFFE0) {

+			rc = hypervisor_decode_smbios(buf + fp, _PATH_DEV_MEM);

+			if (rc == -1)

+				fp += 16;

+

+		} else if (memcmp(buf + fp, "_DMI_", 5) == 0)

+			rc = hypervisor_decode_legacy(buf + fp, _PATH_DEV_MEM);

+

+		if (rc >= 0)

+			break;

+	}

+#endif

+done:

+	free(buf);

+	return rc;

+}

diff --git a/sys-utils/lscpu.1 b/sys-utils/lscpu.1

index f747a35..8636e52 100644

--- a/sys-utils/lscpu.1

+++ b/sys-utils/lscpu.1

@@ -1,34 +1,42 @@

-.\" Process this file with

-.\" groff -man -Tascii lscpu.1

-.\"

-.TH LSCPU 1 "January 2013" "util-linux" "User Commands"

+.TH LSCPU 1 "November 2015" "util-linux" "User Commands"

 .SH NAME

 lscpu \- display information about the CPU architecture

 .SH SYNOPSIS

 .B lscpu

-.RB [ \-a | \-b | \-c "] [" \-x "] [" \-s " \fIdirectory\fP] [" \-e [=\fIlist\fP]| \-p [=\fIlist\fP]]

+.RB [ \-a | \-b | \-c | \-J "] [" \-x "] [" \-y "] [" \-s " \fIdirectory\fP] [" \-e [=\fIlist\fP]| \-p [=\fIlist\fP]]

 .br

 .B lscpu

 .BR \-h | \-V

 .SH DESCRIPTION

 .B lscpu

-gathers CPU architecture information from sysfs and /proc/cpuinfo.  The

+gathers CPU architecture information from sysfs, /proc/cpuinfo and any

+applicable architecture-specific libraries (e.g.\& librtas on Powerpc).  The

 command output can be optimized for parsing or for easy readability by humans.

 The information includes, for example, the number of CPUs, threads, cores,

 sockets, and Non-Uniform Memory Access (NUMA) nodes.  There is also information

 about the CPU caches and cache sharing, family, model, bogoMIPS, byte order,

 and stepping.

-

+.sp

+In virtualized environments, the CPU architecture information displayed

+reflects the configuration of the guest operating system which is

+typically different from the physical (host) system.  On architectures that

+support retrieving physical topology information,

+.B lscpu

+also displays the number of physical sockets, chips, cores in the host system.

+.sp

 Options that result in an output table have a \fIlist\fP argument.  Use this

 argument to customize the command output.  Specify a comma-separated list of

 column labels to limit the output table to only the specified columns, arranged

 in the specified order.  See \fBCOLUMNS\fP for a list of valid column labels.  The

 column labels are not case sensitive.

-

+.sp

 Not all columns are supported on all architectures.  If an unsupported column is

 specified, \fBlscpu\fP prints the column but does not provide any data for it.

 .SS COLUMNS

+Note that topology elements (core, socket, etc.) use a sequential unique ID

+starting from zero, but CPU logical numbers follow the kernel where there is

+no guarantee of sequential numbering.

 .TP

 .B CPU

 The logical CPU number of a CPU as used by the Linux kernel.

@@ -42,8 +50,11 @@ The logical socket number.  A socket can contain several cores.

 .B BOOK

 The logical book number.  A book can contain several sockets.

 .TP

+.B DRAWER

+The logical drawer number.  A drawer can contain several books.

+.TP

 .B NODE

-The logical NUMA node number.  A node may contain several books.

+The logical NUMA node number.  A node can contain several drawers.

 .TP

 .B CACHE

 Information about how caches are shared between CPUs.

@@ -77,6 +88,14 @@ For vertical polarization, the column also shows the degree of concentration,

 high, medium, or low.  This column contains data only if your hardware system

 and hypervisor support CPU polarization.

 .RE

+.TP

+.B MAXMHZ

+Maximum megahertz value for the CPU. Useful when \fBlscpu\fP is used as hardware

+inventory information gathering tool.  Notice that the megahertz value is

+dynamic, and driven by CPU governor depending on current resource need.

+.TP

+.B MINMHZ

+Minimum megahertz value for the CPU.

 .SH OPTIONS

 .TP

 .BR \-a , " \-\-all"

@@ -92,7 +111,7 @@ Limit the output to offline CPUs.

 This option may only be specified together with option \fB-e\fR or \fB-p\fR.

 .TP

 .BR \-e , " \-\-extended" [=\fIlist\fP]

-Display the CPU information in human readable format.

+Display the CPU information in human-readable format.

 If the \fIlist\fP argument is omitted, all columns for which data is available

 are included in the command output.

@@ -102,7 +121,7 @@ When specifying the \fIlist\fP argument, the string of option, equal sign (=), a

 Examples: '\fB-e=cpu,node\fP' or '\fB--extended=cpu,node\fP'.

 .TP

 .BR \-h , " \-\-help"

-Display help information and exit.

+Display help text and exit.

 .TP

 .BR \-p , " \-\-parse" [=\fIlist\fP]

 Optimize the command output for easy parsing.

@@ -126,6 +145,16 @@ of the Linux instance to be inspected.

 Use hexadecimal masks for CPU sets (for example 0x3).  The default is to print

 the sets in list format (for example 0,1).

 .TP

+.BR \-y , " \-\-physical"

+Display physical IDs for all columns with topology elements (core, socket, etc.).

+Other than logical IDs, which are assigned by \fBlscpu\fP, physical IDs are

+platform-specific values that are provided by the kernel. Physical IDs are not

+necessarily unique and they might not be arranged sequentially.

+If the kernel could not retrieve a physical ID for an element \fBlscpu\fP prints

+the dash (-) character.

+

+The CPU logical numbers are not affected by this option.

+.TP

 .BR \-V , " \-\-version"

 Display version information and exit.

 .SH BUGS

@@ -145,4 +174,4 @@ Heiko Carstens <heiko.carstens@de.ibm.com>

 .BR chcpu (8)

 .SH AVAILABILITY

 The lscpu command is part of the util-linux package and is available from

-ftp://ftp.kernel.org/pub/linux/utils/util-linux/.

+https://www.kernel.org/pub/linux/utils/util-linux/.

diff --git a/sys-utils/lscpu.c b/sys-utils/lscpu.c

index 7a00636..683fd66 100644

--- a/sys-utils/lscpu.c

+++ b/sys-utils/lscpu.c

@@ -19,6 +19,7 @@

  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  */

+#include <assert.h>

 #include <ctype.h>

 #include <dirent.h>

 #include <errno.h>

@@ -33,21 +34,46 @@

 #include <sys/types.h>

 #include <sys/stat.h>

+#if (defined(__x86_64__) || defined(__i386__))

+# if !defined( __SANITIZE_ADDRESS__)

+#  define INCLUDE_VMWARE_BDOOR

+# else

+#  warning VMWARE detection disabled by __SANITIZE_ADDRESS__

+# endif

+#endif

+

+#ifdef INCLUDE_VMWARE_BDOOR

+# include <stdint.h>

+# include <signal.h>

+# include <strings.h>

+# include <setjmp.h>

+# ifdef HAVE_SYS_IO_H

+#  include <sys/io.h>

+# endif

+#endif

+

+#if defined(HAVE_LIBRTAS)

+#include <librtas.h>

+#endif

+

+#include <libsmartcols.h>

+

 #include "cpuset.h"

 #include "nls.h"

 #include "xalloc.h"

 #include "c.h"

 #include "strutils.h"

 #include "bitops.h"

-#include "tt.h"

 #include "path.h"

 #include "closestream.h"

 #include "optutils.h"

+#include "lscpu.h"

 #define CACHE_MAX 100

 /* /sys paths */

 #define _PATH_SYS_SYSTEM	"/sys/devices/system"

+#define _PATH_SYS_HYP_FEATURES "/sys/hypervisor/properties/features"

 #define _PATH_SYS_CPU		_PATH_SYS_SYSTEM "/cpu"

 #define _PATH_SYS_NODE		_PATH_SYS_SYSTEM "/node"

 #define _PATH_PROC_XEN		"/proc/xen"

@@ -55,35 +81,71 @@

 #define _PATH_PROC_CPUINFO	"/proc/cpuinfo"

 #define _PATH_PROC_PCIDEVS	"/proc/bus/pci/devices"

 #define _PATH_PROC_SYSINFO	"/proc/sysinfo"

+#define _PATH_PROC_STATUS	"/proc/self/status"

+#define _PATH_PROC_VZ	"/proc/vz"

+#define _PATH_PROC_BC	"/proc/bc"

+#define _PATH_PROC_DEVICETREE	"/proc/device-tree"

+#define _PATH_DEV_MEM 		"/dev/mem"

+#define _PATH_PROC_OSRELEASE	"/proc/sys/kernel/osrelease"

+

+/* Xen Domain feature flag used for /sys/hypervisor/properties/features */

+#define XENFEAT_supervisor_mode_kernel		3

+#define XENFEAT_mmu_pt_update_preserve_ad	5

+#define XENFEAT_hvm_callback_vector			8

+

+#define XEN_FEATURES_PV_MASK	(1U << XENFEAT_mmu_pt_update_preserve_ad)

+#define XEN_FEATURES_PVH_MASK	( (1U << XENFEAT_supervisor_mode_kernel) \

+								| (1U << XENFEAT_hvm_callback_vector) )

 /* virtualization types */

 enum {

 	VIRT_NONE	= 0,

 	VIRT_PARA,

-	VIRT_FULL

+	VIRT_FULL,

+	VIRT_CONT

 };

-const char *virt_types[] = {

+static const char *virt_types[] = {

 	[VIRT_NONE]	= N_("none"),

 	[VIRT_PARA]	= N_("para"),

-	[VIRT_FULL]	= N_("full")

+	[VIRT_FULL]	= N_("full"),

+	[VIRT_CONT]	= N_("container"),

 };

-/* hypervisor vendors */

-enum {

-	HYPER_NONE	= 0,

-	HYPER_XEN,

-	HYPER_KVM,

-	HYPER_MSHV,

-	HYPER_VMWARE,

-	HYPER_IBM

-};

-const char *hv_vendors[] = {

+static const char *hv_vendors[] = {

 	[HYPER_NONE]	= NULL,

 	[HYPER_XEN]	= "Xen",

 	[HYPER_KVM]	= "KVM",

 	[HYPER_MSHV]	= "Microsoft",

 	[HYPER_VMWARE]  = "VMware",

-	[HYPER_IBM]	= "IBM"

+	[HYPER_IBM]	= "IBM",

+	[HYPER_VSERVER]	= "Linux-VServer",

+	[HYPER_UML]	= "User-mode Linux",

+	[HYPER_INNOTEK]	= "Innotek GmbH",

+	[HYPER_HITACHI]	= "Hitachi",

+	[HYPER_PARALLELS] = "Parallels",

+	[HYPER_VBOX]	= "Oracle",

+	[HYPER_OS400]	= "OS/400",

+	[HYPER_PHYP]	= "pHyp",

+	[HYPER_SPAR]	= "Unisys s-Par",

+	[HYPER_WSL]	= "Windows Subsystem for Linux"

+};

+

+static const int hv_vendor_pci[] = {

+	[HYPER_NONE]	= 0x0000,

+	[HYPER_XEN]	= 0x5853,

+	[HYPER_KVM]	= 0x0000,

+	[HYPER_MSHV]	= 0x1414,

+	[HYPER_VMWARE]	= 0x15ad,

+	[HYPER_VBOX]	= 0x80ee,

+};

+

+static const int hv_graphics_pci[] = {

+	[HYPER_NONE]	= 0x0000,

+	[HYPER_XEN]	= 0x0001,

+	[HYPER_KVM]	= 0x0000,

+	[HYPER_MSHV]	= 0x5353,

+	[HYPER_VMWARE]	= 0x0710,

+	[HYPER_VBOX]	= 0xbeef,

 };

 /* CPU modes */

@@ -107,7 +169,7 @@ enum {

 	DISP_VERTICAL	= 1

 };

-const char *disp_modes[] = {

+static const char *disp_modes[] = {

 	[DISP_HORIZONTAL]	= N_("horizontal"),

 	[DISP_VERTICAL]		= N_("vertical")

 };

@@ -126,7 +188,7 @@ struct polarization_modes {

 	char *readable;

 };

-struct polarization_modes polar_modes[] = {

+static struct polarization_modes polar_modes[] = {

 	[POLAR_UNKNOWN]	   = {"U",  "-"},

 	[POLAR_VLOW]	   = {"VL", "vert-low"},

 	[POLAR_VMEDIUM]	   = {"VM", "vert-medium"},

@@ -138,6 +200,7 @@ struct polarization_modes polar_modes[] = {

 struct lscpu_desc {