DragonFlyBSD

smbios.c time.c vidconsole.c x86_64_tramp.S

.if !defined(BOOT_HIDE_SERIAL_NUMBERS)

# Export serial numbers, UUID, and asset tag from loader.

CFLAGS+= -DSMBIOS_SERIAL_NUMBERS

.if defined(BOOT_LITTLE_ENDIAN_UUID)

# Use little-endian UUID format as defined in SMBIOS 2.6.

CFLAGS+= -DSMBIOS_LITTLE_ENDIAN_UUID

.endif

.endif

void smbios_detect(void);

/*-

* Copyright (c) 2005-2009 Jung-uk Kim <jkim@FreeBSD.org>

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

* __FBSDID("$FreeBSD: stable/9/sys/boot/i386/libi386/smbios.c 190814 2009-04-07 17:58:15Z jkim $");

*/

#include <sys/cdefs.h>

#include <stand.h>

#include <bootstrap.h>

#include <sys/param.h>

#include <sys/endian.h>

#include "btxv86.h"

#include "libi386.h"

/*

* Detect SMBIOS and export information about the SMBIOS into the

* environment.

*

* System Management BIOS Reference Specification, v2.6 Final

* http://www.dmtf.org/standards/published_documents/DSP0134_2.6.0.pdf

*/

/*

* 2.1.1 SMBIOS Structure Table Entry Point

*

* "On non-EFI systems, the SMBIOS Entry Point structure, described below, can

* be located by application software by searching for the anchor-string on

* paragraph (16-byte) boundaries within the physical memory address range

* 000F0000h to 000FFFFFh. This entry point encapsulates an intermediate anchor

* string that is used by some existing DMI browsers."

*/

#define SMBIOS_START 0xf0000

#define SMBIOS_LENGTH 0x10000

#define SMBIOS_STEP 0x10

#define SMBIOS_SIG "_SM_"

#define SMBIOS_DMI_SIG "_DMI_"

#define SMBIOS_GET8(base, off) (*(uint8_t *)((base) + (off)))

#define SMBIOS_GET16(base, off) (*(uint16_t *)((base) + (off)))

#define SMBIOS_GET32(base, off) (*(uint32_t *)((base) + (off)))

#define SMBIOS_GETLEN(base) SMBIOS_GET8(base, 0x01)

#define SMBIOS_GETSTR(base) ((base) + SMBIOS_GETLEN(base))

static uint32_t smbios_enabled_memory = 0;

static uint32_t smbios_old_enabled_memory = 0;

static uint8_t smbios_enabled_sockets = 0;

static uint8_t smbios_populated_sockets = 0;

static uint8_t

smbios_checksum(const caddr_t addr, const uint8_t len)

{

uint8_t sum;

int i;

for (sum = 0, i = 0; i < len; i++)

sum += SMBIOS_GET8(addr, i);

return (sum);

}

static caddr_t

smbios_sigsearch(const caddr_t addr, const uint32_t len)

{

caddr_t cp;

/* Search on 16-byte boundaries. */

for (cp = addr; cp < addr + len; cp += SMBIOS_STEP)

if (strncmp(cp, SMBIOS_SIG, 4) == 0 &&

smbios_checksum(cp, SMBIOS_GET8(cp, 0x05)) == 0 &&

strncmp(cp + 0x10, SMBIOS_DMI_SIG, 5) == 0 &&

smbios_checksum(cp + 0x10, 0x0f) == 0)

return (cp);

return (NULL);

}

static void

smbios_setenv(const char *name, caddr_t addr, const int offset)

{

caddr_t cp;

int i, idx;

idx = SMBIOS_GET8(addr, offset);

if (idx != 0) {

cp = SMBIOS_GETSTR(addr);

for (i = 1; i < idx; i++)

cp += strlen(cp) + 1;

setenv(name, cp, 1);

}

}

#ifdef SMBIOS_SERIAL_NUMBERS

#define UUID_SIZE 16

#define UUID_TYPE uint32_t

#define UUID_STEP sizeof(UUID_TYPE)

#define UUID_ALL_BITS (UUID_SIZE / UUID_STEP)

#define UUID_GET(base, off) (*(UUID_TYPE *)((base) + (off)))

static void

smbios_setuuid(const char *name, const caddr_t addr, const int ver)

{

char uuid[37];

int i, ones, zeros;

UUID_TYPE n;

uint32_t f1;

uint16_t f2, f3;

for (i = 0, ones = 0, zeros = 0; i < UUID_SIZE; i += UUID_STEP) {

n = UUID_GET(addr, i) + 1;

if (zeros == 0 && n == 0)

ones++;

else if (ones == 0 && n == 1)

zeros++;

else

break;

}

if (ones != UUID_ALL_BITS && zeros != UUID_ALL_BITS) {

/*

* 3.3.2.1 System UUID

*

* "Although RFC 4122 recommends network byte order for all

* fields, the PC industry (including the ACPI, UEFI, and

* Microsoft specifications) has consistently used

* little-endian byte encoding for the first three fields:

* time_low, time_mid, time_hi_and_version. The same encoding,

* also known as wire format, should also be used for the

* SMBIOS representation of the UUID."

*

* Note: We use network byte order for backward compatibility

* unless SMBIOS version is 2.6+ or little-endian is forced.

*/

#ifndef SMBIOS_LITTLE_ENDIAN_UUID

if (ver < 0x0206) {

f1 = ntohl(SMBIOS_GET32(addr, 0));

f2 = ntohs(SMBIOS_GET16(addr, 4));

f3 = ntohs(SMBIOS_GET16(addr, 6));

} else

#endif

{

f1 = le32toh(SMBIOS_GET32(addr, 0));

f2 = le16toh(SMBIOS_GET16(addr, 4));

f3 = le16toh(SMBIOS_GET16(addr, 6));

}

sprintf(uuid,

"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",

f1, f2, f3, SMBIOS_GET8(addr, 8), SMBIOS_GET8(addr, 9),

SMBIOS_GET8(addr, 10), SMBIOS_GET8(addr, 11),

SMBIOS_GET8(addr, 12), SMBIOS_GET8(addr, 13),

SMBIOS_GET8(addr, 14), SMBIOS_GET8(addr, 15));

setenv(name, uuid, 1);

}

}

#undef UUID_SIZE

#undef UUID_TYPE

#undef UUID_STEP

#undef UUID_ALL_BITS

#undef UUID_GET

#endif

static caddr_t

smbios_parse_table(const caddr_t addr, const int ver)

{

caddr_t cp;

int proc, size, osize, type;

type = SMBIOS_GET8(addr, 0); /* 3.1.2 Structure Header Format */

switch(type) {

case 0: /* 3.3.1 BIOS Information (Type 0) */

smbios_setenv("smbios.bios.vendor", addr, 0x04);

smbios_setenv("smbios.bios.version", addr, 0x05);

smbios_setenv("smbios.bios.reldate", addr, 0x08);

break;

case 1: /* 3.3.2 System Information (Type 1) */

smbios_setenv("smbios.system.maker", addr, 0x04);

smbios_setenv("smbios.system.product", addr, 0x05);

smbios_setenv("smbios.system.version", addr, 0x06);

#ifdef SMBIOS_SERIAL_NUMBERS

smbios_setenv("smbios.system.serial", addr, 0x07);

smbios_setuuid("smbios.system.uuid", addr + 0x08, ver);

#endif

break;

case 2: /* 3.3.3 Base Board (or Module) Information (Type 2) */

smbios_setenv("smbios.planar.maker", addr, 0x04);

smbios_setenv("smbios.planar.product", addr, 0x05);

smbios_setenv("smbios.planar.version", addr, 0x06);

#ifdef SMBIOS_SERIAL_NUMBERS

smbios_setenv("smbios.planar.serial", addr, 0x07);

#endif

break;

case 3: /* 3.3.4 System Enclosure or Chassis (Type 3) */

smbios_setenv("smbios.chassis.maker", addr, 0x04);

smbios_setenv("smbios.chassis.version", addr, 0x06);

#ifdef SMBIOS_SERIAL_NUMBERS

smbios_setenv("smbios.chassis.serial", addr, 0x07);

smbios_setenv("smbios.chassis.tag", addr, 0x08);

#endif

break;

case 4: /* 3.3.5 Processor Information (Type 4) */

/*

* Offset 18h: Processor Status

*

* Bit 7 Reserved, must be 0

* Bit 6 CPU Socket Populated

* 1 - CPU Socket Populated

* 0 - CPU Socket Unpopulated

* Bit 5:3 Reserved, must be zero

* Bit 2:0 CPU Status

* 0h - Unknown

* 1h - CPU Enabled

* 2h - CPU Disabled by User via BIOS Setup

* 3h - CPU Disabled by BIOS (POST Error)

* 4h - CPU is Idle, waiting to be enabled

* 5-6h - Reserved

* 7h - Other

*/

proc = SMBIOS_GET8(addr, 0x18);

if ((proc & 0x07) == 1)

smbios_enabled_sockets++;

if ((proc & 0x40) != 0)

smbios_populated_sockets++;

break;

case 6: /* 3.3.7 Memory Module Information (Type 6, Obsolete) */

/*

* Offset 0Ah: Enabled Size

*

* Bit 7 Bank connection

* 1 - Double-bank connection

* 0 - Single-bank connection

* Bit 6:0 Size (n), where 2**n is the size in MB

* 7Dh - Not determinable (Installed Size only)

* 7Eh - Module is installed, but no memory

* has been enabled

* 7Fh - Not installed

*/

osize = SMBIOS_GET8(addr, 0x0a) & 0x7f;

if (osize > 0 && osize < 22)

smbios_old_enabled_memory += 1 << (osize + 10);

break;

case 17: /* 3.3.18 Memory Device (Type 17) */

/*

* Offset 0Ch: Size

*

* Bit 15 Granularity

* 1 - Value is in kilobytes units

* 0 - Value is in megabytes units

* Bit 14:0 Size

*/

size = SMBIOS_GET16(addr, 0x0c);

if (size != 0 && size != 0xffff)

smbios_enabled_memory += (size & 0x8000) != 0 ?

(size & 0x7fff) : (size << 10);

break;

default: /* skip other types */

break;

}

/* Find structure terminator. */

cp = SMBIOS_GETSTR(addr);

while (SMBIOS_GET16(cp, 0) != 0)

cp++;

return (cp + 2);

}

void

smbios_detect(void)

{

char buf[16];

caddr_t addr, dmi, smbios;

size_t count, length;

uint32_t paddr;

int i, major, minor, ver;

/* Search signatures and validate checksums. */

smbios = smbios_sigsearch(PTOV(SMBIOS_START), SMBIOS_LENGTH);

if (smbios == NULL)

return;

length = SMBIOS_GET16(smbios, 0x16); /* Structure Table Length */

paddr = SMBIOS_GET32(smbios, 0x18); /* Structure Table Address */

count = SMBIOS_GET16(smbios, 0x1c); /* No of SMBIOS Structures */

ver = SMBIOS_GET8(smbios, 0x1e); /* SMBIOS BCD Revision */

if (ver != 0) {

major = ver >> 4;

minor = ver & 0x0f;

if (major > 9 || minor > 9)

ver = 0;

}

if (ver == 0) {

major = SMBIOS_GET8(smbios, 0x06); /* SMBIOS Major Version */

minor = SMBIOS_GET8(smbios, 0x07); /* SMBIOS Minor Version */

}

ver = (major << 8) | minor;

addr = PTOV(paddr);

for (dmi = addr, i = 0; dmi < addr + length && i < count; i++)

dmi = smbios_parse_table(dmi, ver);

sprintf(buf, "%d.%d", major, minor);

setenv("smbios.version", buf, 1);

if (smbios_enabled_memory > 0 || smbios_old_enabled_memory > 0) {

sprintf(buf, "%u", smbios_enabled_memory > 0 ?

smbios_enabled_memory : smbios_old_enabled_memory);

setenv("smbios.memory.enabled", buf, 1);

}

if (smbios_enabled_sockets > 0) {

sprintf(buf, "%u", smbios_enabled_sockets);

setenv("smbios.socket.enabled", buf, 1);

}

if (smbios_populated_sockets > 0) {

sprintf(buf, "%u", smbios_populated_sockets);

setenv("smbios.socket.populated", buf, 1);

}

}

/* detect SMBIOS for future reference */

smbios_detect();

static __inline void

clflush(u_long addr)

{

__asm __volatile("clflush %0" : : "m" (*(char *)addr));

}

clflush(u_long addr)

{

__asm __volatile("clflush %0" : : "m" (*(char *)addr));

}

static __inline void

#include <sys/sysctl.h>

# ifndef HZ_VM

# define HZ_VM 100

# endif

#else

# ifndef HZ_VM

# define HZ_VM HZ

# endif

static int sysctl_kern_vm_guest(SYSCTL_HANDLER_ARGS);

int vm_guest; /* Running as virtual machine guest? */

SYSCTL_PROC(_kern, OID_AUTO, vm_guest, CTLFLAG_RD | CTLTYPE_STRING,

NULL, 0, sysctl_kern_vm_guest, "A",

"Virtual machine guest detected? (none|generic|xen)");

* The elements of this array are ordered based upon the values of the

* corresponding enum VM_GUEST members.

*/

static const char *const vm_guest_sysctl_names[] = {

"none",

"generic",

"xen",

NULL

};

#ifndef XEN

static const char *const vm_bnames[] = {

"QEMU", /* QEMU */

"Plex86", /* Plex86 */

"Bochs", /* Bochs */

"Xen", /* Xen */

NULL

};

static const char *const vm_pnames[] = {

"VMware Virtual Platform", /* VMWare VM */

"Virtual Machine", /* Microsoft VirtualPC */

"VirtualBox", /* Sun xVM VirtualBox */

"Parallels Virtual Platform", /* Parallels VM */

NULL

};

/*

* Detect known Virtual Machine hosts by inspecting the emulated BIOS.

*/

static enum VM_GUEST

detect_virtual(void)

{

char *sysenv;

int i;

sysenv = kgetenv("smbios.bios.vendor");

if (sysenv != NULL) {

for (i = 0; vm_bnames[i] != NULL; i++)

if (strcmp(sysenv, vm_bnames[i]) == 0) {

kfreeenv(sysenv);

return (VM_GUEST_VM);

}

kfreeenv(sysenv);

}

sysenv = kgetenv("smbios.system.product");

if (sysenv != NULL) {

for (i = 0; vm_pnames[i] != NULL; i++)

if (strcmp(sysenv, vm_pnames[i]) == 0) {

kfreeenv(sysenv);

return (VM_GUEST_VM);

}

kfreeenv(sysenv);

}

return (VM_GUEST_NO);

}

#endif

/*

#ifndef XEN

vm_guest = detect_virtual();

#else

vm_guest = VM_GUEST_XEN;

#endif

hz = -1;

if (hz == -1)

hz = vm_guest > VM_GUEST_NO ? HZ_VM : HZ;

/*

* Sysctl stringiying handler for kern.vm_guest.

*/

static int

sysctl_kern_vm_guest(SYSCTL_HANDLER_ARGS)

{

return (SYSCTL_OUT(req, vm_guest_sysctl_names[vm_guest],

strlen(vm_guest_sysctl_names[vm_guest])));

}

#include <vm/vm.h>

#include <vm/pmap.h>

#if !defined(CPU_DISABLE_SSE) && defined(I686_CPU)

#define CPU_ENABLE_SSE

#endif

/*

* -1: automatic (default)

* 0: keep enable CLFLUSH

* 1: force disable CLFLUSH

*/

static int hw_clflush_disable = -1;

u_int cpu_clflush_line_size = 32;

#if 0

#endif

#ifdef CPU_ENABLE_SSE

u_int cpu_fxsr; /* SSE enabled */

#if 0

u_int cpu_mxcsr_mask; /* valid bits in mxcsr */

#endif

#endif

#if 0

#endif

#if defined(CPU_ENABLE_SSE)

if ((cpu_feature & CPUID_XMM) && (cpu_feature & CPUID_FXSR)) {

load_cr4(rcr4() | CR4_FXSR | CR4_XMM);

cpu_fxsr = hw_instruction_sse = 1;

}

#endif

/*

* CPUID with %eax = 1, %ebx returns

* Bits 15-8: CLFLUSH line size

* (Value * 8 = cache line size in bytes)

*/

if ((cpu_feature & CPUID_CLFSH) != 0)

cpu_clflush_line_size = ((cpu_procinfo >> 8) & 0xff) * 8;

/*

* XXXKIB: (temporary) hack to work around traps generated

* when CLFLUSHing APIC register window under virtualization

* environments. These environments tend to disable the

* CPUID_SS feature even though the native CPU supports it.

*/

TUNABLE_INT_FETCH("hw.clflush_disable", &hw_clflush_disable);

if (vm_guest != VM_GUEST_NO && hw_clflush_disable == -1)

cpu_feature &= ~CPUID_CLFSH;

/*

* Allow to disable CLFLUSH feature manually by

* hw.clflush_disable tunable.

*/

if (hw_clflush_disable == 1)

cpu_feature &= ~CPUID_CLFSH;

extern u_int cpu_clflush_line_size;

extern u_int cpu_clflush_line_size;

#if 0

void initializecpu(void);

#endif

void initializecpucache(void);

/*

* -1: automatic (default)

* 0: keep enable CLFLUSH

* 1: force disable CLFLUSH

*/

static int hw_clflush_disable = -1;

u_int cpu_clflush_line_size = 32;

void

initializecpucache(void)

{

/*

* CPUID with %eax = 1, %ebx returns

* Bits 15-8: CLFLUSH line size

* (Value * 8 = cache line size in bytes)

*/

if ((cpu_feature & CPUID_CLFSH) != 0)

cpu_clflush_line_size = ((cpu_procinfo >> 8) & 0xff) * 8;

/*

* XXXKIB: (temporary) hack to work around traps generated

* when CLFLUSHing APIC register window under virtualization

* environments. These environments tend to disable the

* CPUID_SS feature even though the native CPU supports it.

*/

TUNABLE_INT_FETCH("hw.clflush_disable", &hw_clflush_disable);

if (vm_guest != VM_GUEST_NO && hw_clflush_disable == -1)

cpu_feature &= ~CPUID_CLFSH;

/*

* Allow to disable CLFLUSH feature manually by

* hw.clflush_disable tunable.

*/

if (hw_clflush_disable == 1)

cpu_feature &= ~CPUID_CLFSH;

}

initializecpucache();

extern int vm_guest; /* Running as virtual machine guest? */

/*

* Detected virtual machine guest types. The intention is to expand

* and/or add to the VM_GUEST_VM type if specific VM functionality is

* ever implemented (e.g. vendor-specific paravirtualization features).

*/

enum VM_GUEST { VM_GUEST_NO = 0, VM_GUEST_VM, VM_GUEST_XEN };