/usr/src/sys/arch/amd64/amd64/machdep.c

Bug Summary

File:	arch/amd64/amd64/machdep.c
Warning:	line 1668, column 8 Access to field 'avail_end' results in a dereference of a null pointer (loaded from variable 'vps')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name machdep.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/arch/amd64/amd64/machdep.c
1/*	$OpenBSD: machdep.c,v 1.288 2023/09/08 20:47:22 kn Exp $	*/
2/*	$NetBSD: machdep.c,v 1.3 2003/05/07 22:58:18 fvdl Exp $	*/

4/*-
* Copyright (c) 1996, 1997, 1998, 2000 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
* Simulation Facility, NASA Ames Research Center.
*
* 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/

34/*-
* Copyright (c) 1982, 1987, 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* William Jolitz.
*
* 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.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
*	@(#)machdep.c	7.4 (Berkeley) 6/3/91
*/

68#include <sys/param.h>
69#include <sys/systm.h>
70#include <sys/signal.h>
71#include <sys/signalvar.h>
72#include <sys/proc.h>
73#include <sys/user.h>
74#include <sys/exec.h>
75#include <sys/buf.h>
76#include <sys/reboot.h>
77#include <sys/conf.h>
78#include <sys/msgbuf.h>
79#include <sys/mount.h>
80#include <sys/extent.h>
81#include <sys/core.h>
82#include <sys/kcore.h>
83#include <sys/syscallargs.h>

85#include <dev/cons.h>
86#include <stand/boot/bootarg.h>

88#include <net/if.h>
89#include <uvm/uvm_extern.h>

91#include <sys/sysctl.h>

93#include <machine/cpu_full.h>
94#include <machine/cpufunc.h>
95#include <machine/pio.h>
96#include <machine/psl.h>
97#include <machine/reg.h>
98#include <machine/fpu.h>
99#include <machine/biosvar.h>
100#include <machine/mpbiosvar.h>
101#include <machine/kcore.h>
102#include <machine/tss.h>

104#include <dev/isa/isareg.h>
105#include <dev/ic/i8042reg.h>

107#ifdef DDB1
108#include <machine/db_machdep.h>
109#include <ddb/db_extern.h>
110extern int db_console;
111#endif

113#include "isa.h"
114#include "isadma.h"
115#include "ksyms.h"

117#include "acpi.h"
118#if NACPI1 > 0
119#include <dev/acpi/acpivar.h>
120#endif

122#include "com.h"
123#if NCOM1 > 0
124#include <sys/tty.h>
125#include <dev/ic/comvar.h>
126#include <dev/ic/comreg.h>
127#endif

129#include "efi.h"
130#if NEFI1 > 0
131#include <dev/efi/efi.h>
132#endif

134#include "softraid.h"
135#if NSOFTRAID1 > 0
136#include <dev/softraidvar.h>
137#endif

139#ifdef HIBERNATE1
140#include <machine/hibernate_var.h>
141#endif /* HIBERNATE */

143#include "ukbd.h"
144#include "pckbc.h"
145#if NPCKBC1 > 0 && NUKBD1 > 0
146#include <dev/ic/pckbcvar.h>
147#endif

149/* #define MACHDEP_DEBUG */

151#ifdef MACHDEP_DEBUG
152#define DPRINTF(x...)	do { printf(x); } while(0)
153#else
154#define DPRINTF(x...)
155#endif /* MACHDEP_DEBUG */

157/* the following is used externally (sysctl_hw) */
158char machine[] = MACHINE"amd64";

160/*
* switchto vectors
*/
163void cpu_idle_cycle_hlt(void);
164void (*cpu_idle_cycle_fcn)(void) = &cpu_idle_cycle_hlt;

166/* the following is used externally for concurrent handlers */
167int setperf_prio = 0;

169#ifdef CPURESET_DELAY
170int	cpureset_delay = CPURESET_DELAY;
171#else
172int     cpureset_delay = 0;
173#endif

175char *ssym = 0, *esym = 0;	/* start and end of symbol table */
176dev_t bootdev = 0;		/* device we booted from */
177int biosbasemem = 0;		/* base memory reported by BIOS */
178u_int bootapiver = 0;		/* /boot API version */

180int	physmem;
181u_int64_t	dumpmem_low;
182u_int64_t	dumpmem_high;
183extern int	boothowto;
184int	cpu_class;

186paddr_t	dumpmem_paddr;
187vaddr_t	dumpmem_vaddr;
188psize_t	dumpmem_sz;

190vaddr_t kern_end;

192vaddr_t	msgbuf_vaddr;
193paddr_t msgbuf_paddr;

195vaddr_t	idt_vaddr;
196paddr_t	idt_paddr;

198vaddr_t lo32_vaddr;
199paddr_t lo32_paddr;
200paddr_t tramp_pdirpa;

202int kbd_reset;
203int lid_action = 1;
204int pwr_action = 1;
205int forceukbd;

207/*
* safepri is a safe priority for sleep to set for a spin-wait
* during autoconfiguration or after a panic.
*/
211int	safepri = 0;

213struct vm_map *exec_map = NULL((void *)0);
214struct vm_map *phys_map = NULL((void *)0);

216/* UVM constraint ranges. */
217struct uvm_constraint_range  isa_constraint = { 0x0, 0x00ffffffUL };
218struct uvm_constraint_range  dma_constraint = { 0x0, 0xffffffffUL };
219struct uvm_constraint_range *uvm_md_constraints[] = {
  &isa_constraint,
  &dma_constraint,
  NULL((void *)0),
223};

225paddr_t avail_start;
226paddr_t avail_end;

228void (*delay_func)(int) = i8254_delay;
229void (*initclock_func)(void) = i8254_initclocks;
230void (*startclock_func)(void) = i8254_start_both_clocks;

232/*
* Format of boot information passed to us by 32-bit /boot
*/
235typedef struct _boot_args32 {
int	ba_type;
int	ba_size;
int	ba_nextX;	/* a ptr in 32-bit world, but not here */
char	ba_arg[1];
240} bootarg32_t;

242#define BOOTARGC_MAX(1 << 12)	NBPG(1 << 12)	/* one page */

244bios_bootmac_t *bios_bootmac;

246/* locore copies the arguments from /boot to here for us */
247char bootinfo[BOOTARGC_MAX(1 << 12)];
248int bootinfo_size = BOOTARGC_MAX(1 << 12);

250void getbootinfo(char *, int);

252/* Data passed to us by /boot, filled in by getbootinfo() */
253bios_diskinfo_t	*bios_diskinfo;
254bios_memmap_t	*bios_memmap;
255u_int32_t	bios_cksumlen;
256bios_efiinfo_t	*bios_efiinfo;
257bios_ucode_t	*bios_ucode;

259#if NEFI1 > 0
260EFI_MEMORY_DESCRIPTOR *mmap;
261#endif

263/*
* Size of memory segments, before any memory is stolen.
*/
266phys_ram_seg_t mem_clusters[VM_PHYSSEG_MAX16];
267int	mem_cluster_cnt;

269int	cpu_dump(void);
270int	cpu_dumpsize(void);
271u_long	cpu_dump_mempagecnt(void);
272void	dumpsys(void);
273void	cpu_init_extents(void);
274void	map_tramps(void);
275void	init_x86_64(paddr_t);
276void	(*cpuresetfn)(void);
277void	enter_shared_special_pages(void);

279#ifdef APERTURE1
280int allowaperture = 0;
281#endif

283/*
* Machine-dependent startup code
*/
286void
287cpu_startup(void)
288{
vaddr_t minaddr, maxaddr;

msgbuf_vaddr = PMAP_DIRECT_MAP(msgbuf_paddr)((vaddr_t)(((((511 - 4) * (1ULL << 39))) | 0xffff000000000000
)) + (msgbuf_paddr));
initmsgbuf((caddr_t)msgbuf_vaddr, round_page(MSGBUFSIZE)((((32 * (1 << 12))) + ((1 << 12) - 1)) & ~((
<< 12) - 1)));

printf("%s", version);
startclocks();
rtcinit();

printf("real mem = %lu (%luMB)\n", ptoa((psize_t)physmem)((paddr_t)((psize_t)physmem) << 12),
   ptoa((psize_t)physmem)((paddr_t)((psize_t)physmem) << 12)/1024/1024);

/*
* Allocate a submap for exec arguments.  This map effectively
* limits the number of processes exec'ing at any time.
*/
minaddr = vm_map_min(kernel_map)((kernel_map)->min_offset);
exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
		   16*NCARGS(512 * 1024), VM_MAP_PAGEABLE0x01, FALSE0, NULL((void *)0));

/*
* Allocate a submap for physio
*/
minaddr = vm_map_min(kernel_map)((kernel_map)->min_offset);
phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
		   VM_PHYS_SIZE(300*(1 << 12)), 0, FALSE0, NULL((void *)0));

printf("avail mem = %lu (%luMB)\n", ptoa((psize_t)uvmexp.free)((paddr_t)((psize_t)uvmexp.free) << 12),
   ptoa((psize_t)uvmexp.free)((paddr_t)((psize_t)uvmexp.free) << 12)/1024/1024);

bufinit();

if (boothowto & RB_CONFIG0x00400) {
322#ifdef BOOT_CONFIG1
user_config();
324#else
printf("kernel does not support -c; continuing..\n");
326#endif
}

/* Safe for i/o port / memory space allocation to use malloc now. */
x86_bus_space_mallocok();

332#ifndef SMALL_KERNEL
cpu_ucode_setup();
cpu_ucode_apply(&cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))));
335#endif
cpu_tsx_disable(&cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))));

/* enter the IDT and trampoline code in the u-k maps */
enter_shared_special_pages();

/* initialize CPU0's TSS and GDT and put them in the u-k maps */
cpu_enter_pages(&cpu_info_full_primary);
343}

345/*
* enter_shared_special_pages
*
* Requests mapping of various special pages required in the Intel Meltdown
* case (to be entered into the U-K page table):
*
*  1 IDT page
*  Various number of pages covering the U-K ".kutext" section. This section
*   contains code needed during trampoline operation
*  Various number of pages covering the U-K ".kudata" section. This section
*   contains data accessed by the trampoline, before switching to U+K
*   (for example, various shared global variables used by IPIs, etc)
*
* The linker script places the required symbols in the sections above.
*
* On CPUs not affected by Meltdown, the calls to pmap_enter_special below
* become no-ops.
*/
363void
364enter_shared_special_pages(void)
365{
extern char __kutext_start[], __kutext_end[], __kernel_kutext_phys[];
extern char __text_page_start[], __text_page_end[];
extern char __kernel_kutext_page_phys[];
extern char __kudata_start[], __kudata_end[], __kernel_kudata_phys[];
vaddr_t va;
paddr_t pa;

/* idt */
pmap_enter_special(idt_vaddr, idt_paddr, PROT_READ0x01);
DPRINTF("%s: entered idt page va 0x%llx pa 0x%llx\n", __func__,
   (uint64_t)idt_vaddr, (uint64_t)idt_paddr);

/* .kutext section */
va = (vaddr_t)__kutext_start;
pa = (paddr_t)__kernel_kutext_phys;
while (va < (vaddr_t)__kutext_end) {
pmap_enter_special(va, pa, PROT_READ0x01 | PROT_EXEC0x04);
DPRINTF("%s: entered kutext page va 0x%llx pa 0x%llx\n",
    __func__, (uint64_t)va, (uint64_t)pa);
va += PAGE_SIZE(1 << 12);
pa += PAGE_SIZE(1 << 12);
}

/* .kutext.page section */
va = (vaddr_t)__text_page_start;
pa = (paddr_t)__kernel_kutext_page_phys;
while (va < (vaddr_t)__text_page_end) {
pmap_enter_special(va, pa, PROT_READ0x01 | PROT_EXEC0x04);
DPRINTF("%s: entered kutext.page va 0x%llx pa 0x%llx\n",
    __func__, (uint64_t)va, (uint64_t)pa);
va += PAGE_SIZE(1 << 12);
pa += PAGE_SIZE(1 << 12);
}

/* .kudata section */
va = (vaddr_t)__kudata_start;
pa = (paddr_t)__kernel_kudata_phys;
while (va < (vaddr_t)__kudata_end) {
pmap_enter_special(va, pa, PROT_READ0x01 | PROT_WRITE0x02);
DPRINTF("%s: entered kudata page va 0x%llx pa 0x%llx\n",
    __func__, (uint64_t)va, (uint64_t)pa);
va += PAGE_SIZE(1 << 12);
pa += PAGE_SIZE(1 << 12);
}
410}

412/*
* Set up proc0's PCB and the cpu's TSS.
*/
415void
416x86_64_proc0_tss_ldt_init(void)
417{
struct pcb *pcb;

cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))).ci_curpcb = pcb = &proc0.p_addr->u_pcb;
pcb->pcb_fsbase = 0;
pcb->pcb_kstack = (u_int64_t)proc0.p_addr + USPACE(6 * (1 << 12)) - 16;
proc0.p_md.md_regs = (struct trapframe *)pcb->pcb_kstack - 1;

ltr(GSYSSEL(GPROC0_SEL, SEL_KPL)((((0) << 4) + (6 << 3)) | 0));
lldt(0);
427}

429bios_diskinfo_t *
430bios_getdiskinfo(dev_t dev)
431{
bios_diskinfo_t *pdi;

if (bios_diskinfo == NULL((void *)0))
return NULL((void *)0);

for (pdi = bios_diskinfo; pdi->bios_number != -1; pdi++) {
if ((dev & B_MAGICMASK0xf0000000) == B_DEVMAGIC0xa0000000) { /* search by bootdev */
	if (pdi->bsd_dev == dev)
		break;
} else {
	if (pdi->bios_number == dev)
		break;
}
}

if (pdi->bios_number == -1)
return NULL((void *)0);
else
return pdi;
451}

453int
454bios_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
  size_t newlen, struct proc *p)
456{
bios_diskinfo_t *pdi;
int biosdev;

/* all sysctl names at this level except diskinfo are terminal */
if (namelen != 1 && name[0] != BIOS_DISKINFO2)
return (ENOTDIR20);	       /* overloaded */

if (!(bootapiver & BAPIV_VECTOR0x00000002))
return EOPNOTSUPP45;

switch (name[0]) {
case BIOS_DEV1:
if ((pdi = bios_getdiskinfo(bootdev)) == NULL((void *)0))
	return ENXIO6;
biosdev = pdi->bios_number;
return sysctl_rdint(oldp, oldlenp, newp, biosdev);
case BIOS_DISKINFO2:
if (namelen != 2)
	return ENOTDIR20;
if ((pdi = bios_getdiskinfo(name[1])) == NULL((void *)0))
	return ENXIO6;
return sysctl_rdstruct(oldp, oldlenp, newp, pdi, sizeof(*pdi));
case BIOS_CKSUMLEN3:
return sysctl_rdint(oldp, oldlenp, newp, bios_cksumlen);
default:
return EOPNOTSUPP45;
}
/* NOTREACHED */
485}

487extern int tsc_is_invariant;
488extern int amd64_has_xcrypt;

490const struct sysctl_bounded_args cpuctl_vars[] = {
{ CPU_LIDACTION14, &lid_action, 0, 2 },
{ CPU_PWRACTION18, &pwr_action, 0, 2 },
{ CPU_CPUID7, &cpu_id, SYSCTL_INT_READONLY1,0 },
{ CPU_CPUFEATURE8, &cpu_feature, SYSCTL_INT_READONLY1,0 },
{ CPU_XCRYPT12, &amd64_has_xcrypt, SYSCTL_INT_READONLY1,0 },
{ CPU_INVARIANTTSC17, &tsc_is_invariant, SYSCTL_INT_READONLY1,0 },
497};

499/*
* machine dependent system variables.
*/
502int
503cpu_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
  size_t newlen, struct proc *p)
505{
extern uint64_t tsc_frequency;
dev_t consdev;
dev_t dev;

switch (name[0]) {
case CPU_CONSDEV1:
if (namelen != 1)
	return (ENOTDIR20);		/* overloaded */
if (cn_tab != NULL((void *)0))
	consdev = cn_tab->cn_dev;
else
	consdev = NODEV(dev_t)(-1);
return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
    sizeof consdev));
case CPU_CHR2BLK4:
if (namelen != 2)
	return (ENOTDIR20);		/* overloaded */
dev = chrtoblk((dev_t)name[1]);
return sysctl_rdstruct(oldp, oldlenp, newp, &dev, sizeof(dev));
case CPU_BIOS2:
return bios_sysctl(name + 1, namelen - 1, oldp, oldlenp,
    newp, newlen, p);
case CPU_CPUVENDOR6:
return (sysctl_rdstring(oldp, oldlenp, newp, cpu_vendor));
case CPU_KBDRESET10:
return (sysctl_securelevel_int(oldp, oldlenp, newp, newlen,
    &kbd_reset));
case CPU_ALLOWAPERTURE5:
if (namelen != 1)
	return (ENOTDIR20);		/* overloaded */
536#ifdef APERTURE1
if (securelevel > 0)
	return (sysctl_int_lower(oldp, oldlenp, newp, newlen,
	    &allowaperture));
else
	return (sysctl_int(oldp, oldlenp, newp, newlen,
	    &allowaperture));
543#else
return (sysctl_rdint(oldp, oldlenp, newp, 0));
545#endif
546#if NPCKBC1 > 0 && NUKBD1 > 0
case CPU_FORCEUKBD15:
{
int error;

if (forceukbd)
	return (sysctl_rdint(oldp, oldlenp, newp, forceukbd));

error = sysctl_int(oldp, oldlenp, newp, newlen, &forceukbd);
if (forceukbd)
	pckbc_release_console();
return (error);
}
559#endif
case CPU_TSCFREQ16:
return (sysctl_rdquad(oldp, oldlenp, newp, tsc_frequency));
default:
return (sysctl_bounded_arr(cpuctl_vars, nitems(cpuctl_vars)(sizeof((cpuctl_vars)) / sizeof((cpuctl_vars)[0])),
    name, namelen, oldp, oldlenp, newp, newlen));
}
/* NOTREACHED */
567}

569static inline void
570maybe_enable_user_cet(struct proc *p)
571{
572#ifndef SMALL_KERNEL
/* Enable indirect-branch tracking if present and not disabled */
if ((xsave_mask & XFEATURE_CET_U0x00000800) &&
   (p->p_p->ps_flags & PS_NOBTCFI0x02000000) == 0) {
uint64_t msr = rdmsr(MSR_U_CET0x6a0);
wrmsr(MSR_U_CET0x6a0, msr | MSR_CET_ENDBR_EN(1 << 2) | MSR_CET_NO_TRACK_EN(1 << 4));
}
579#endif
580}

582static inline void
583initialize_thread_xstate(struct proc *p)
584{
if (cpu_use_xsaves) {
xrstors(fpu_cleandata(&proc0.p_addr->u_pcb.pcb_savefpu), xsave_mask);
maybe_enable_user_cet(p);
} else {
/* Reset FPU state in PCB */
memcpy(&p->p_addr->u_pcb.pcb_savefpu, fpu_cleandata,__builtin_memcpy((&p->p_addr->u_pcb.pcb_savefpu), (
(&proc0.p_addr->u_pcb.pcb_savefpu)), (fpu_save_len))
    fpu_save_len)__builtin_memcpy((&p->p_addr->u_pcb.pcb_savefpu), (
(&proc0.p_addr->u_pcb.pcb_savefpu)), (fpu_save_len));

if (curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_pflags & CPUPF_USERXSTATE0x02) {
	/* state in CPU is obsolete; reset it */
	fpureset()xrstor_kern((&proc0.p_addr->u_pcb.pcb_savefpu), xsave_mask
);
}
}

/* The reset state _is_ the userspace state for this thread now */
curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_pflags |= CPUPF_USERXSTATE0x02;
601}

603/*
* Copy out the FPU state, massaging it to be usable from userspace
* and acceptable to xrstor_user()
*/
607static inline int
608copyoutfpu(struct savefpu *sfp, char *sp, size_t len)
609{
uint64_t bvs[2];

if (copyout(sfp, sp, len))
return 1;
if (len > offsetof(struct savefpu, fp_xstate.xstate_bv)__builtin_offsetof(struct savefpu, fp_xstate.xstate_bv)) {
sp  += offsetof(struct savefpu, fp_xstate.xstate_bv)__builtin_offsetof(struct savefpu, fp_xstate.xstate_bv);
len -= offsetof(struct savefpu, fp_xstate.xstate_bv)__builtin_offsetof(struct savefpu, fp_xstate.xstate_bv);
bvs[0] = sfp->fp_xstate.xstate_bv & XFEATURE_XCR0_MASK(0x00000001 | 0x00000002 | 0x00000004 | (0x00000008 | 0x00000010
) | (0x00000020 | 0x00000040 | 0x00000080) | 0x00000200 | (0x00040000
 | 0x00040000));
bvs[1] = sfp->fp_xstate.xstate_xcomp_bv &
    (XFEATURE_XCR0_MASK(0x00000001 | 0x00000002 | 0x00000004 | (0x00000008 | 0x00000010
) | (0x00000020 | 0x00000040 | 0x00000080) | 0x00000200 | (0x00040000
 | 0x00040000)) | XFEATURE_COMPRESSED(1ULL << 63));
if (copyout(bvs, sp, min(len, sizeof bvs)))
	return 1;
}
return 0;
624}

626/*
* Send an interrupt to process.
*
* Stack is set up to allow sigcode to call routine, followed by
* syscall to sigreturn routine below.  After sigreturn resets the
* signal mask, the stack, and the frame pointer, it returns to the
* user specified pc.
*/
634int
635sendsig(sig_t catcher, int sig, sigset_t mask, const siginfo_t *ksip,
  int info, int onstack)
637{
struct proc *p = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc;
struct trapframe *tf = p->p_md.md_regs;
struct sigcontext ksc;
struct savefpu *sfp = &p->p_addr->u_pcb.pcb_savefpu;
register_t sp, scp, sip;
u_long sss;

memset(&ksc, 0, sizeof ksc)__builtin_memset((&ksc), (0), (sizeof ksc));
ksc.sc_rdi = tf->tf_rdi;
ksc.sc_rsi = tf->tf_rsi;
ksc.sc_rdx = tf->tf_rdx;
ksc.sc_rcx = tf->tf_rcx;
ksc.sc_r8  = tf->tf_r8;
ksc.sc_r9  = tf->tf_r9;
ksc.sc_r10 = tf->tf_r10;
ksc.sc_r11 = tf->tf_r11;
ksc.sc_r12 = tf->tf_r12;
ksc.sc_r13 = tf->tf_r13;
ksc.sc_r14 = tf->tf_r14;
ksc.sc_r15 = tf->tf_r15;
ksc.sc_rbx = tf->tf_rbx;
ksc.sc_rax = tf->tf_rax;
ksc.sc_rbp = tf->tf_rbp;
ksc.sc_rip = tf->tf_rip;
ksc.sc_cs  = tf->tf_cs;
ksc.sc_rflags = tf->tf_rflags;
ksc.sc_rsp = tf->tf_rsp;
ksc.sc_ss  = tf->tf_ss;
ksc.sc_mask = mask;

/* Allocate space for the signal handler context. */
if ((p->p_sigstk.ss_flags & SS_DISABLE0x0004) == 0 &&
   !sigonstack(tf->tf_rsp) && onstack)
sp = trunc_page((vaddr_t)p->p_sigstk.ss_sp + p->p_sigstk.ss_size)(((vaddr_t)p->p_sigstk.ss_sp + p->p_sigstk.ss_size) &
 ~((1 << 12) - 1));
else
sp = tf->tf_rsp - 128;

sp -= fpu_save_len;
if (cpu_use_xsaves)
sp &= ~63ULL;	/* just in case */
else
sp &= ~15ULL;	/* just in case */

/* Save FPU state to PCB if necessary, then copy it out */
if (curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_pflags & CPUPF_USERXSTATE0x02)
fpusave(&p->p_addr->u_pcb.pcb_savefpu);
if (copyoutfpu(sfp, (void *)sp, fpu_save_len))
return 1;

initialize_thread_xstate(p);

ksc.sc_fpstate = (struct fxsave64 *)sp;
sss = (sizeof(ksc) + 15) & ~15;
sip = 0;
if (info) {
sip = sp - ((sizeof(*ksip) + 15) & ~15);
sss += (sizeof(*ksip) + 15) & ~15;

if (copyout(ksip, (void *)sip, sizeof(*ksip)))
	return 1;
}
scp = sp - sss;

ksc.sc_cookie = (long)scp ^ p->p_p->ps_sigcookie;
if (copyout(&ksc, (void *)scp, sizeof(ksc)))
return 1;

/*
* Build context to run handler in.
*/
tf->tf_rax = (u_int64_t)catcher;
tf->tf_rdi = sig;
tf->tf_rsi = sip;
tf->tf_rdx = scp;

tf->tf_rip = (u_int64_t)p->p_p->ps_sigcode;
tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL)(((5) << 3) | 3);
tf->tf_rflags &= ~(PSL_T0x00000100|PSL_D0x00000400|PSL_VM0x00020000|PSL_AC0x00040000);
tf->tf_rsp = scp;
tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL)(((4) << 3) | 3);

return 0;
720}

722/*
* System call to cleanup state after a signal
* has been taken.  Reset signal mask and
* stack state from context left by sendsig (above).
* Return to previous pc and psl as specified by
* context left by sendsig. Check carefully to
* make sure that the user has not modified the
* psl to gain improper privileges or to cause
* a machine fault.
*/
732int
733sys_sigreturn(struct proc *p, void *v, register_t *retval)
734{
struct sys_sigreturn_args /* {
syscallarg(struct sigcontext *) sigcntxp;
} */ *uap = v;
struct sigcontext ksc, *scp = SCARG(uap, sigcntxp)((uap)->sigcntxp.le.datum);
struct trapframe *tf = p->p_md.md_regs;
struct savefpu *sfp = &p->p_addr->u_pcb.pcb_savefpu;
int error;

if (PROC_PC(p)((p)->p_md.md_regs->tf_rip) != p->p_p->ps_sigcoderet) {
sigexit(p, SIGILL4);
return (EPERM1);
}

if ((error = copyin((caddr_t)scp, &ksc, sizeof ksc)))
return (error);

if (ksc.sc_cookie != ((long)scp ^ p->p_p->ps_sigcookie)) {
sigexit(p, SIGILL4);
return (EFAULT14);
}

/* Prevent reuse of the sigcontext cookie */
ksc.sc_cookie = 0;
(void)copyout(&ksc.sc_cookie, (caddr_t)scp +
   offsetof(struct sigcontext, sc_cookie)__builtin_offsetof(struct sigcontext, sc_cookie), sizeof (ksc.sc_cookie));

if (((ksc.sc_rflags ^ tf->tf_rflags) & PSL_USERSTATIC(0x00000002 | 0xffc08028 | 0x00000200 | 0x00003000 | 0x00004000
 | 0x00020000 | 0x00080000 | 0x00100000)) != 0 ||
   !USERMODE(ksc.sc_cs, ksc.sc_eflags)(((ksc.sc_cs) & 3) == 3))
return (EINVAL22);

/* Current FPU state is obsolete; toss it and force a reload */
if (curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_pflags & CPUPF_USERXSTATE0x02) {
curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_pflags &= ~CPUPF_USERXSTATE0x02;
fpureset()xrstor_kern((&proc0.p_addr->u_pcb.pcb_savefpu), xsave_mask
);
}

/* Copy in the FPU state to restore */
if (__predict_true(ksc.sc_fpstate != NULL)__builtin_expect(((ksc.sc_fpstate != ((void *)0)) != 0), 1)) {
if ((error = copyin(ksc.sc_fpstate, sfp, fpu_save_len)))
	return error;
if (xrstor_user(sfp, xsave_mask)) {
	memcpy(sfp, fpu_cleandata, fpu_save_len)__builtin_memcpy((sfp), ((&proc0.p_addr->u_pcb.pcb_savefpu
)), (fpu_save_len));
	return EINVAL22;
}
maybe_enable_user_cet(p);
curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_pflags |= CPUPF_USERXSTATE0x02;
} else {
/* shouldn't happen, but handle it */
initialize_thread_xstate(p);
}

tf->tf_rdi = ksc.sc_rdi;
tf->tf_rsi = ksc.sc_rsi;
tf->tf_rdx = ksc.sc_rdx;
tf->tf_rcx = ksc.sc_rcx;
tf->tf_r8  = ksc.sc_r8;
tf->tf_r9  = ksc.sc_r9;
tf->tf_r10 = ksc.sc_r10;
tf->tf_r11 = ksc.sc_r11;
tf->tf_r12 = ksc.sc_r12;
tf->tf_r13 = ksc.sc_r13;
tf->tf_r14 = ksc.sc_r14;
tf->tf_r15 = ksc.sc_r15;
tf->tf_rbx = ksc.sc_rbx;
tf->tf_rax = ksc.sc_rax;
tf->tf_rbp = ksc.sc_rbp;
tf->tf_rip = ksc.sc_rip;
tf->tf_cs  = ksc.sc_cs;
tf->tf_rflags = ksc.sc_rflags;
tf->tf_rsp = ksc.sc_rsp;
tf->tf_ss  = ksc.sc_ss;

/* Restore signal mask. */
p->p_sigmask = ksc.sc_mask & ~sigcantmask((1U << ((9)-1)) | (1U << ((17)-1)));

/*
* sigreturn() needs to return to userspace via the 'iretq'
* method, so that if the process was interrupted (by tick,
* an IPI, whatever) as opposed to already being in the kernel
* when a signal was being delivered, the process will be
* completely restored, including the userland %rcx and %r11
* registers which the 'sysretq' instruction cannot restore.
* Also need to make sure we can handle faulting on xrstor.
*/
p->p_md.md_flags |= MDP_IRET0x0002;

return (EJUSTRETURN-2);
822}

824#ifdef MULTIPROCESSOR1
825/* force a CPU into the kernel, whether or not it's idle */
826void
827cpu_kick(struct cpu_info *ci)
828{
/* only need to kick other CPUs */
if (ci != curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})) {
if (cpu_mwait_size > 0) {
	/*
	 * If not idling, then send an IPI, else
	 * just clear the "keep idling" bit.
	 */
	if ((ci->ci_mwait & MWAIT_IN_IDLE0x1) == 0)
		x86_send_ipi(ci, X86_IPI_NOP0x00000002);
	else
		atomic_clearbits_intx86_atomic_clearbits_u32(&ci->ci_mwait,
		    MWAIT_KEEP_IDLING0x2);
} else {
	/* no mwait, so need an IPI */
	x86_send_ipi(ci, X86_IPI_NOP0x00000002);
}
}
846}
847#endif

849/*
* Notify the current process (p) that it has a signal pending,
* process as soon as possible.
*/
853void
854signotify(struct proc *p)
855{
aston(p)((p)->p_md.md_astpending = 1);
cpu_kick(p->p_cpu);
858}

860#ifdef MULTIPROCESSOR1
861void
862cpu_unidle(struct cpu_info *ci)
863{
if (cpu_mwait_size > 0 && (ci->ci_mwait & MWAIT_ONLY0x4)) {
/*
 * Just clear the "keep idling" bit; if it wasn't
 * idling then we didn't need to do anything anyway.
 */
atomic_clearbits_intx86_atomic_clearbits_u32(&ci->ci_mwait, MWAIT_KEEP_IDLING0x2);
return;
}

if (ci != curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;}))
x86_send_ipi(ci, X86_IPI_NOP0x00000002);
875}
876#endif

878int	waittime = -1;
879struct pcb dumppcb;

881__dead__attribute__((__noreturn__)) void
882boot(int howto)
883{
if ((howto & RB_POWERDOWN0x01000) != 0)
lid_action = 0;

if ((howto & RB_RESET0x08000) != 0)
goto doreset;

if (cold) {
if ((howto & RB_USERREQ0x04000) == 0)
	howto |= RB_HALT0x00008;
goto haltsys;
}

boothowto = howto;
if ((howto & RB_NOSYNC0x00004) == 0 && waittime < 0) {
waittime = 0;
vfs_shutdown(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc);

if ((howto & RB_TIMEBAD0x00800) == 0) {
	resettodr();
} else {
	printf("WARNING: not updating battery clock\n");
}
}
if_downall();

uvm_shutdown();
splhigh()splraise(0xd);
cold = 1;

if ((howto & RB_DUMP0x00100) != 0)
dumpsys();

916haltsys:
config_suspend_all(DVACT_POWERDOWN6);

919#ifdef MULTIPROCESSOR1
x86_broadcast_ipi(X86_IPI_HALT0x00000001);
921#endif

if ((howto & RB_HALT0x00008) != 0) {
924#if NACPI1 > 0 && !defined(SMALL_KERNEL)
extern int acpi_enabled;

if (acpi_enabled) {
	delay(500000)(*delay_func)(500000);
	if ((howto & RB_POWERDOWN0x01000) != 0)
		acpi_powerdown();
}
932#endif
printf("\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1);	/* for proper keyboard command handling */
cngetc();
cnpollc(0);
}

941doreset:
printf("rebooting...\n");
if (cpureset_delay > 0)
delay(cpureset_delay * 1000)(*delay_func)(cpureset_delay * 1000);
cpu_reset();
for (;;)
continue;
/* NOTREACHED */
949}

951/*
* These variables are needed by /sbin/savecore
*/
954u_long	dumpmag = 0x8fca0101;	/* magic number */
955int 	dumpsize = 0;		/* pages */
956long	dumplo = 0; 		/* blocks */

958/*
* cpu_dump: dump the machine-dependent kernel core dump headers.
*/
961int
962cpu_dump(void)
963{
int (*dump)(dev_t, daddr_t, caddr_t, size_t);
char buf[dbtob(1)((1) << 9)];
kcore_seg_t *segp;
cpu_kcore_hdr_t *cpuhdrp;
phys_ram_seg_t *memsegp;
caddr_t va;
int i;

dump = bdevsw[major(dumpdev)(((unsigned)(dumpdev) >> 8) & 0xff)].d_dump;

memset(buf, 0, sizeof buf)__builtin_memset((buf), (0), (sizeof buf));
segp = (kcore_seg_t *)buf;
cpuhdrp = (cpu_kcore_hdr_t *)&buf[ALIGN(sizeof(*segp))(((unsigned long)(sizeof(*segp)) + (sizeof(long) - 1)) &~
(sizeof(long) - 1))];
memsegp = (phys_ram_seg_t *)&buf[ALIGN(sizeof(*segp))(((unsigned long)(sizeof(*segp)) + (sizeof(long) - 1)) &~
(sizeof(long) - 1)) +
   ALIGN(sizeof(*cpuhdrp))(((unsigned long)(sizeof(*cpuhdrp)) + (sizeof(long) - 1)) &
~(sizeof(long) - 1))];

/*
* Generate a segment header.
*/
CORE_SETMAGIC(*segp, KCORE_MAGIC, MID_MACHINE, CORE_CPU)( (*segp).c_midmag = (__uint32_t)(__builtin_constant_p(( ((1)
 & 0x3f) << 26) | ( ((157) & 0x03ff) << 16
) | ( ((0x8fca) & 0xffff) )) ? (__uint32_t)(((__uint32_t)
(( ((1) & 0x3f) << 26) | ( ((157) & 0x03ff) <<
 16) | ( ((0x8fca) & 0xffff) )) & 0xff) << 24 |
 ((__uint32_t)(( ((1) & 0x3f) << 26) | ( ((157) &
 0x03ff) << 16) | ( ((0x8fca) & 0xffff) )) & 0xff00
) << 8 | ((__uint32_t)(( ((1) & 0x3f) << 26) |
 ( ((157) & 0x03ff) << 16) | ( ((0x8fca) & 0xffff
) )) & 0xff0000) >> 8 | ((__uint32_t)(( ((1) & 0x3f
) << 26) | ( ((157) & 0x03ff) << 16) | ( ((0x8fca
) & 0xffff) )) & 0xff000000) >> 24) : __swap32md
(( ((1) & 0x3f) << 26) | ( ((157) & 0x03ff) <<
 16) | ( ((0x8fca) & 0xffff) ))) );
segp->c_size = dbtob(1)((1) << 9) - ALIGN(sizeof(*segp))(((unsigned long)(sizeof(*segp)) + (sizeof(long) - 1)) &~
(sizeof(long) - 1));

/*
* Add the machine-dependent header info.
*/
cpuhdrp->ptdpaddr = proc0.p_addr->u_pcb.pcb_cr3;
cpuhdrp->nmemsegs = mem_cluster_cnt;

/*
* Fill in the memory segment descriptors.
*/
for (i = 0; i < mem_cluster_cnt; i++) {
memsegp[i].start = mem_clusters[i].start;
memsegp[i].size = mem_clusters[i].size & ~PAGE_MASK((1 << 12) - 1);
}

/*
* If we have dump memory then assume the kernel stack is in high
* memory and bounce
*/
if (dumpmem_vaddr != 0) {
memcpy((char *)dumpmem_vaddr, buf, sizeof(buf))__builtin_memcpy(((char *)dumpmem_vaddr), (buf), (sizeof(buf)
));
va = (caddr_t)dumpmem_vaddr;
} else {
va = (caddr_t)buf;
}
return (dump(dumpdev, dumplo, va, dbtob(1)((1) << 9)));
1011}

1013/*
* This is called by main to set dumplo and dumpsize.
* Dumps always skip the first PAGE_SIZE of disk space
* in case there might be a disk label stored there.
* If there is extra space, put dump at the end to
* reduce the chance that swapping trashes it.
*/
1020void
1021dumpconf(void)
1022{
int nblks, dumpblks;	/* size of dump area */

if (dumpdev == NODEV(dev_t)(-1) ||
   (nblks = (bdevsw[major(dumpdev)(((unsigned)(dumpdev) >> 8) & 0xff)].d_psize)(dumpdev)) == 0)
return;
if (nblks <= ctod(1)((1) << (12 - 9)))
return;

dumpblks = cpu_dumpsize();
if (dumpblks < 0)
return;
dumpblks += ctod(cpu_dump_mempagecnt())((cpu_dump_mempagecnt()) << (12 - 9));

/* If dump won't fit (incl. room for possible label), punt. */
if (dumpblks > (nblks - ctod(1)((1) << (12 - 9))))
return;

/* Put dump at end of partition */
dumplo = nblks - dumpblks;

/* dumpsize is in page units, and doesn't include headers. */
dumpsize = cpu_dump_mempagecnt();
1045}

1047/*
* Doadump comes here after turning off memory management and
* getting on the dump stack, either when called above, or by
* the auto-restart code.
*/
1052#define BYTES_PER_DUMP(64 * 1024)  MAXPHYS(64 * 1024) /* must be a multiple of pagesize */

1054void
1055dumpsys(void)
1056{
u_long totalbytesleft, bytes, i, n, memseg;
u_long maddr;
daddr_t blkno;
void *va;
int (*dump)(dev_t, daddr_t, caddr_t, size_t);
int error;

/* Save registers. */
savectx(&dumppcb);

if (dumpdev == NODEV(dev_t)(-1))
return;

/*
* For dumps during autoconfiguration,
* if dump device has already configured...
*/
if (dumpsize == 0)
dumpconf();
if (dumplo <= 0 || dumpsize == 0) {
printf("\ndump to dev %u,%u not possible\n", major(dumpdev)(((unsigned)(dumpdev) >> 8) & 0xff),
    minor(dumpdev)((unsigned)((dumpdev) & 0xff) | (((dumpdev) & 0xffff0000
) >> 8)));
return;
}
printf("\ndumping to dev %u,%u offset %ld\n", major(dumpdev)(((unsigned)(dumpdev) >> 8) & 0xff),
   minor(dumpdev)((unsigned)((dumpdev) & 0xff) | (((dumpdev) & 0xffff0000
) >> 8)), dumplo);

error = (*bdevsw[major(dumpdev)(((unsigned)(dumpdev) >> 8) & 0xff)].d_psize)(dumpdev);
printf("dump ");
if (error == -1) {
printf("area unavailable\n");
return;
}

if ((error = cpu_dump()) != 0)
goto err;

totalbytesleft = ptoa(cpu_dump_mempagecnt())((paddr_t)(cpu_dump_mempagecnt()) << 12);
blkno = dumplo + cpu_dumpsize();
dump = bdevsw[major(dumpdev)(((unsigned)(dumpdev) >> 8) & 0xff)].d_dump;
error = 0;

for (memseg = 0; memseg < mem_cluster_cnt; memseg++) {
maddr = mem_clusters[memseg].start;
bytes = mem_clusters[memseg].size;

for (i = 0; i < bytes; i += n, totalbytesleft -= n) {
	/* Print out how many MBs we have left to go. */
	if ((totalbytesleft % (1024*1024)) < BYTES_PER_DUMP(64 * 1024))
		printf("%ld ", totalbytesleft / (1024 * 1024));

	/* Limit size for next transfer. */
	n = bytes - i;
	if (n > BYTES_PER_DUMP(64 * 1024))
		n = BYTES_PER_DUMP(64 * 1024);
	if (maddr > 0xffffffff) {
		va = (void *)dumpmem_vaddr;
		if (n > dumpmem_sz)
			n = dumpmem_sz;
		memcpy(va, (void *)PMAP_DIRECT_MAP(maddr), n)__builtin_memcpy((va), ((void *)((vaddr_t)(((((511 - 4) * (1ULL
 << 39))) | 0xffff000000000000)) + (maddr))), (n));
	} else {
		va = (void *)PMAP_DIRECT_MAP(maddr)((vaddr_t)(((((511 - 4) * (1ULL << 39))) | 0xffff000000000000
)) + (maddr));
	}

	error = (*dump)(dumpdev, blkno, va, n);
	if (error)
		goto err;
	maddr += n;
	blkno += btodb(n)((n) >> 9);		/* XXX? */

1127#if 0	/* XXX this doesn't work.  grr. */
	/* operator aborting dump? */
	if (sget() != NULL((void *)0)) {
		error = EINTR4;
		break;
	}
1133#endif
}
}

err:
switch (error) {

case ENXIO6:
printf("device bad\n");
break;

case EFAULT14:
printf("device not ready\n");
break;

case EINVAL22:
printf("area improper\n");
break;

case EIO5:
printf("i/o error\n");
break;

case EINTR4:
printf("aborted from console\n");
break;

case 0:
printf("succeeded\n");
break;

default:
printf("error %d\n", error);
break;
}
printf("\n\n");
delay(5000000)(*delay_func)(5000000);		/* 5 seconds */
1170}

1172/*
* Force the userspace FS.base to be reloaded from the PCB on return from
* the kernel, and reset the segment registers (%ds, %es, %fs, and %gs)
* to their expected userspace value.
*/
1177void
1178reset_segs(void)
1179{
/*
* This operates like the cpu_switchto() sequence: if we
* haven't reset %[defg]s already, do so now.
*/
if (curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_pflags & CPUPF_USERSEGS0x01) {
curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_pflags &= ~CPUPF_USERSEGS0x01;
__asm volatile(
    "movw %%ax,%%ds\n\t"
    "movw %%ax,%%es\n\t"
    "movw %%ax,%%fs\n\t"
    "cli\n\t"		/* block intr when on user GS.base */
    "swapgs\n\t"	/* swap from kernel to user GS.base */
    "movw %%ax,%%gs\n\t"/* set %gs to UDATA and GS.base to 0 */
    "swapgs\n\t"	/* back to kernel GS.base */
    "sti" : : "a"(GSEL(GUDATA_SEL, SEL_UPL)(((4) << 3) | 3)));
}
1196}

1198/*
* Clear registers on exec
*/
1201void
1202setregs(struct proc *p, struct exec_package *pack, u_long stack,
  struct ps_strings *arginfo)
1204{
struct trapframe *tf;

initialize_thread_xstate(p);

/* To reset all registers we have to return via iretq */
p->p_md.md_flags |= MDP_IRET0x0002;

reset_segs();
p->p_addr->u_pcb.pcb_fsbase = 0;

tf = p->p_md.md_regs;
memset(tf, 0, sizeof *tf)__builtin_memset((tf), (0), (sizeof *tf));
tf->tf_rip = pack->ep_entry;
tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL)(((5) << 3) | 3);
tf->tf_rflags = PSL_USERSET(0x00000002 | 0x00000200);
tf->tf_rsp = stack;
tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL)(((4) << 3) | 3);
1222}

1224/*
* Initialize segments and descriptor tables
*/

1228struct gate_descriptor *idt;
1229char idt_allocmap[NIDT256];
1230struct user *proc0paddr = NULL((void *)0);

1232void
1233setgate(struct gate_descriptor *gd, void *func, int ist, int type, int dpl,
  int sel)
1235{
gd->gd_looffset = (u_int64_t)func & 0xffff;
gd->gd_selector = sel;
gd->gd_ist = ist;
gd->gd_type = type;
gd->gd_dpl = dpl;
gd->gd_p = 1;
gd->gd_hioffset = (u_int64_t)func >> 16;
gd->gd_zero = 0;
gd->gd_xx1 = 0;
gd->gd_xx2 = 0;
gd->gd_xx3 = 0;
1247}

1249void
1250unsetgate(struct gate_descriptor *gd)
1251{
memset(gd, 0, sizeof (*gd))__builtin_memset((gd), (0), (sizeof (*gd)));
1253}

1255void
1256setregion(struct region_descriptor *rd, void *base, u_int16_t limit)
1257{
rd->rd_limit = limit;
rd->rd_base = (u_int64_t)base;
1260}

1262/*
* Note that the base and limit fields are ignored in long mode.
*/
1265void
1266set_mem_segment(struct mem_segment_descriptor *sd, void *base, size_t limit,
  int type, int dpl, int gran, int def32, int is64)
1268{
sd->sd_lolimit = (unsigned)limit;
sd->sd_lobase = (unsigned long)base;
sd->sd_type = type;
sd->sd_dpl = dpl;
sd->sd_p = 1;
sd->sd_hilimit = (unsigned)limit >> 16;
sd->sd_avl = 0;
sd->sd_long = is64;
sd->sd_def32 = def32;
sd->sd_gran = gran;
sd->sd_hibase = (unsigned long)base >> 24;
1280}

1282void
1283set_sys_segment(struct sys_segment_descriptor *sd, void *base, size_t limit,
  int type, int dpl, int gran)
1285{
memset(sd, 0, sizeof *sd)__builtin_memset((sd), (0), (sizeof *sd));
sd->sd_lolimit = (unsigned)limit;
sd->sd_lobase = (u_int64_t)base;
sd->sd_type = type;
sd->sd_dpl = dpl;
sd->sd_p = 1;
sd->sd_hilimit = (unsigned)limit >> 16;
sd->sd_gran = gran;
sd->sd_hibase = (u_int64_t)base >> 24;
1295}

1297void cpu_init_idt(void)
1298{
struct region_descriptor region;

setregion(&region, idt, NIDT256 * sizeof(idt[0]) - 1);
lidt(&region);
1303}

1305void
1306cpu_init_extents(void)
1307{
extern struct extent *iomem_ex;
static int already_done;
int i;

/* We get called for each CPU, only first should do this */
if (already_done)
return;

/*
* Allocate the physical addresses used by RAM from the iomem
* extent map.
*/
for (i = 0; i < mem_cluster_cnt; i++) {
if (extent_alloc_region(iomem_ex, mem_clusters[i].start,
    mem_clusters[i].size, EX_NOWAIT0x0000)) {
	/* XXX What should we do? */
	printf("WARNING: CAN'T ALLOCATE RAM (%llx-%llx)"
	    " FROM IOMEM EXTENT MAP!\n", mem_clusters[i].start,
	    mem_clusters[i].start + mem_clusters[i].size - 1);
}
}

already_done = 1;
1331}

1333void
1334map_tramps(void)
1335{
1336#if defined(MULTIPROCESSOR1) || \
  (NACPI1 > 0 && !defined(SMALL_KERNEL))
struct pmap *kmp = pmap_kernel()(&kernel_pmap_store);
extern paddr_t tramp_pdirpa;
1340#ifdef MULTIPROCESSOR1
extern u_char cpu_spinup_trampoline[];
extern u_char cpu_spinup_trampoline_end[];
extern u_char mp_tramp_data_start[];
extern u_char mp_tramp_data_end[];
extern u_int32_t mp_pdirpa;
1346#endif

/*
* The initial PML4 pointer must be below 4G, so if the
* current one isn't, use a "bounce buffer" and save it
* for tramps to use.
*/
if (kmp->pm_pdirpa > 0xffffffff) {
pmap_kenter_pa(lo32_vaddr, lo32_paddr, PROT_READ0x01 | PROT_WRITE0x02);
memcpy((void *)lo32_vaddr, kmp->pm_pdir, PAGE_SIZE)__builtin_memcpy(((void *)lo32_vaddr), (kmp->pm_pdir), ((1
 << 12)));
tramp_pdirpa = lo32_paddr;
pmap_kremove(lo32_vaddr, PAGE_SIZE(1 << 12));
} else
tramp_pdirpa = kmp->pm_pdirpa;


1362#ifdef MULTIPROCESSOR1
/* Map MP tramp code and data pages RW for copy */
pmap_kenter_pa(MP_TRAMPOLINE(16 * (1 << 12)), MP_TRAMPOLINE(16 * (1 << 12)),
   PROT_READ0x01 | PROT_WRITE0x02);

pmap_kenter_pa(MP_TRAMP_DATA(17 * (1 << 12)), MP_TRAMP_DATA(17 * (1 << 12)),
   PROT_READ0x01 | PROT_WRITE0x02);

memset((caddr_t)MP_TRAMPOLINE, 0xcc, PAGE_SIZE)__builtin_memset(((caddr_t)(16 * (1 << 12))), (0xcc), (
(1 << 12)));
memset((caddr_t)MP_TRAMP_DATA, 0xcc, PAGE_SIZE)__builtin_memset(((caddr_t)(17 * (1 << 12))), (0xcc), (
(1 << 12)));

memcpy((caddr_t)MP_TRAMPOLINE,__builtin_memcpy(((caddr_t)(16 * (1 << 12))), (cpu_spinup_trampoline
), (cpu_spinup_trampoline_end-cpu_spinup_trampoline))
   cpu_spinup_trampoline,__builtin_memcpy(((caddr_t)(16 * (1 << 12))), (cpu_spinup_trampoline
), (cpu_spinup_trampoline_end-cpu_spinup_trampoline))
   cpu_spinup_trampoline_end-cpu_spinup_trampoline)__builtin_memcpy(((caddr_t)(16 * (1 << 12))), (cpu_spinup_trampoline
), (cpu_spinup_trampoline_end-cpu_spinup_trampoline));

memcpy((caddr_t)MP_TRAMP_DATA,__builtin_memcpy(((caddr_t)(17 * (1 << 12))), (mp_tramp_data_start
), (mp_tramp_data_end - mp_tramp_data_start))
mp_tramp_data_start,__builtin_memcpy(((caddr_t)(17 * (1 << 12))), (mp_tramp_data_start
), (mp_tramp_data_end - mp_tramp_data_start))
mp_tramp_data_end - mp_tramp_data_start)__builtin_memcpy(((caddr_t)(17 * (1 << 12))), (mp_tramp_data_start
), (mp_tramp_data_end - mp_tramp_data_start));

/*
* We need to patch this after we copy the tramp data,
* the symbol points into the copied tramp data page.
*/
mp_pdirpa = tramp_pdirpa;

/* Unmap, will be remapped in cpu_start_secondary */
pmap_kremove(MP_TRAMPOLINE(16 * (1 << 12)), PAGE_SIZE(1 << 12));
pmap_kremove(MP_TRAMP_DATA(17 * (1 << 12)), PAGE_SIZE(1 << 12));
1390#endif /* MULTIPROCESSOR */
1391#endif
1392}

1394#define	IDTVEC(name)Xname	__CONCAT(X, name)Xname
1395typedef void (vector)(void);
1396extern vector *IDTVEC(exceptions)Xexceptions[];

1398paddr_t early_pte_pages;

1400void
1401init_x86_64(paddr_t first_avail)
1402{
struct region_descriptor region;
bios_memmap_t *bmp;
int x, ist;
uint64_t max_dm_size = ((uint64_t)512 * NUM_L4_SLOT_DIRECT4) << 30;

/*
* locore0 mapped 3 pages for use before the pmap is initialized
* starting at first_avail. These pages are currently used by
* efifb to create early-use VAs for the framebuffer before efifb
* is attached.
*/
early_pte_pages = first_avail;
first_avail += 3 * NBPG(1 << 12);

cpu_init_msrs(&cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))));

proc0.p_addr = proc0paddr;
cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))).ci_curpcb = &proc0.p_addr->u_pcb;

x86_bus_space_init();

i8254_startclock();

/*
* Initialize PAGE_SIZE-dependent variables.
*/
uvm_setpagesize();

/*
* Boot arguments are in a single page specified by /boot.
*
* We require the "new" vector form, as well as memory ranges
* to be given in bytes rather than KB.
*
* locore copies the data into bootinfo[] for us.
*/
if ((bootapiver & (BAPIV_VECTOR0x00000002 | BAPIV_BMEMMAP0x00000008)) ==
1
Assuming the condition is true→
2
←
Taking true branch→
   (BAPIV_VECTOR0x00000002 | BAPIV_BMEMMAP0x00000008)) {
if (bootinfo_size >= sizeof(bootinfo))
3
←
Assuming the condition is false→
4
←
Taking false branch→
	panic("boot args too big");

getbootinfo(bootinfo, bootinfo_size);
} else
panic("invalid /boot");

cninit();

1450/*
* Memory on the AMD64 port is described by three different things.
*
* 1. biosbasemem - This is outdated, and should really only be used to
*    sanitize the other values. This is what we get back from the BIOS
*    using the legacy routines, describing memory below 640KB.
*
* 2. bios_memmap[] - This is the memory map as the bios has returned
*    it to us.  It includes memory the kernel occupies, etc.
*
* 3. mem_cluster[] - This is the massaged free memory segments after
*    taking into account the contents of bios_memmap, biosbasemem,
*    and locore/machdep/pmap kernel allocations of physical
*    pages.
*
* The other thing is that the physical page *RANGE* is described by
* three more variables:
*
* avail_start - This is a physical address of the start of available
*               pages, until IOM_BEGIN.  This is basically the start
*               of the UVM managed range of memory, with some holes...
*
* avail_end - This is the end of physical pages.  All physical pages
*             that UVM manages are between avail_start and avail_end.
*             There are holes...
*
* first_avail - This is the first available physical page after the
*               kernel, page tables, etc.
*
* We skip the first few pages for trampolines, hibernate, and to avoid
* buggy SMI implementations that could corrupt the first 64KB.
*/
avail_start = 16*PAGE_SIZE(1 << 12);

1484#ifdef MULTIPROCESSOR1
if (avail_start < MP_TRAMPOLINE(16 * (1 << 12)) + PAGE_SIZE(1 << 12))
5
←
Taking true branch→
avail_start = MP_TRAMPOLINE(16 * (1 << 12)) + PAGE_SIZE(1 << 12);
if (avail_start < MP_TRAMP_DATA(17 * (1 << 12)) + PAGE_SIZE(1 << 12))
6
←
Taking true branch→
avail_start = MP_TRAMP_DATA(17 * (1 << 12)) + PAGE_SIZE(1 << 12);
1489#endif

1491#if (NACPI1 > 0 && !defined(SMALL_KERNEL))
if (avail_start < ACPI_TRAMPOLINE(19 * (1 << 12)) + PAGE_SIZE(1 << 12))
7
←
Taking true branch→
avail_start = ACPI_TRAMPOLINE(19 * (1 << 12)) + PAGE_SIZE(1 << 12);
if (avail_start < ACPI_TRAMP_DATA(20 * (1 << 12)) + PAGE_SIZE(1 << 12))
8
←
Taking true branch→
avail_start = ACPI_TRAMP_DATA(20 * (1 << 12)) + PAGE_SIZE(1 << 12);
1496#endif

1498#ifdef HIBERNATE1
if (avail_start < HIBERNATE_HIBALLOC_PAGE((1 << 12) * 34) + PAGE_SIZE(1 << 12))
9
←
Taking true branch→
avail_start = HIBERNATE_HIBALLOC_PAGE((1 << 12) * 34) + PAGE_SIZE(1 << 12);
1501#endif /* HIBERNATE */

/*
* We need to go through the BIOS memory map given, and
* fill out mem_clusters and mem_cluster_cnt stuff, taking
* into account all the points listed above.
*/
avail_end = mem_cluster_cnt = 0;
for (bmp = bios_memmap; bmp->type != BIOS_MAP_END0x00; bmp++) {
10
←
Assuming field 'type' is equal to BIOS_MAP_END→
11
←
Loop condition is false. Execution continues on line 1584→
paddr_t s1, s2, e1, e2;

/* Ignore non-free memory */
if (bmp->type != BIOS_MAP_FREE0x01)
	continue;
if (bmp->size < PAGE_SIZE(1 << 12))
	continue;

/* Init our segment(s), round/trunc to pages */
s1 = round_page(bmp->addr)(((bmp->addr) + ((1 << 12) - 1)) & ~((1 <<
 12) - 1));
e1 = trunc_page(bmp->addr + bmp->size)((bmp->addr + bmp->size) & ~((1 << 12) - 1));
s2 = e2 = 0;

/*
 * XXX Some buggy ACPI BIOSes use memory that they
 * declare as free.  Current worst offender is
 * Supermicro 5019D-FTN4.  Typically the affected memory
 * areas are small blocks between areas reserved for
 * ACPI and other BIOS goo.  So skip areas smaller
 * than 32 MB above the 16 MB boundary (to avoid
 * affecting legacy stuff).
 */
if (s1 > 16*1024*1024 && (e1 - s1) < 32*1024*1024)
	continue;

/* Check and adjust our segment(s) */
/* Nuke low pages */
if (s1 < avail_start) {
	s1 = avail_start;
	if (s1 > e1)
		continue;
}

/*
 * The direct map is limited to 512GB * NUM_L4_SLOT_DIRECT of
 * memory, so discard anything above that.
 */
if (e1 >= max_dm_size) {
	e1 = max_dm_size;
	if (s1 > e1)
		continue;
}

/* Crop stuff into "640K hole" */
if (s1 < IOM_BEGIN0x0a0000 && e1 > IOM_BEGIN0x0a0000)
	e1 = IOM_BEGIN0x0a0000;
if (s1 < biosbasemem && e1 > biosbasemem)
	e1 = biosbasemem;

/* Split any segments straddling the 16MB boundary */
if (s1 < 16*1024*1024 && e1 > 16*1024*1024) {
	e2 = e1;
	s2 = e1 = 16*1024*1024;
}

/* Store segment(s) */
if (e1 - s1 >= PAGE_SIZE(1 << 12)) {
	mem_clusters[mem_cluster_cnt].start = s1;
	mem_clusters[mem_cluster_cnt].size = e1 - s1;
	mem_cluster_cnt++;
}
if (e2 - s2 >= PAGE_SIZE(1 << 12)) {
	mem_clusters[mem_cluster_cnt].start = s2;
	mem_clusters[mem_cluster_cnt].size = e2 - s2;
	mem_cluster_cnt++;
}
if (avail_end < e1) avail_end = e1;
if (avail_end < e2) avail_end = e2;
}

/*
* Call pmap initialization to make new kernel address space.
* We must do this before loading pages into the VM system.
*/
first_avail = pmap_bootstrap(first_avail, trunc_page(avail_end)((avail_end) & ~((1 << 12) - 1)));

1586#if NEFI1 > 0
/* Relocate the EFI memory map. */
if (bios_efiinfo && bios_efiinfo->mmap_start) {
12
←
Assuming 'bios_efiinfo' is null→
mmap = (EFI_MEMORY_DESCRIPTOR *)PMAP_DIRECT_MAP(first_avail)((vaddr_t)(((((511 - 4) * (1ULL << 39))) | 0xffff000000000000
)) + (first_avail));
memcpy(mmap, (void *)PMAP_DIRECT_MAP(bios_efiinfo->mmap_start),__builtin_memcpy((mmap), ((void *)((vaddr_t)(((((511 - 4) * (
1ULL << 39))) | 0xffff000000000000)) + (bios_efiinfo->
mmap_start))), (bios_efiinfo->mmap_size))
    bios_efiinfo->mmap_size)__builtin_memcpy((mmap), ((void *)((vaddr_t)(((((511 - 4) * (
1ULL << 39))) | 0xffff000000000000)) + (bios_efiinfo->
mmap_start))), (bios_efiinfo->mmap_size));
first_avail += round_page(bios_efiinfo->mmap_size)(((bios_efiinfo->mmap_size) + ((1 << 12) - 1)) &
 ~((1 << 12) - 1));
}
1594#endif

/* Allocate these out of the 640KB base memory */
if (avail_start != PAGE_SIZE(1 << 12))
13
←
Assuming the condition is false→
14
←
Taking false branch→
avail_start = pmap_prealloc_lowmem_ptps(avail_start);

cpu_init_extents();

/* Make sure the end of the space used by the kernel is rounded. */
first_avail = round_page(first_avail)(((first_avail) + ((1 << 12) - 1)) & ~((1 << 12
) - 1));
kern_end = KERNBASE0xffffffff80000000 + first_avail;

/*
* Now, load the memory clusters (which have already been
* flensed) into the VM system.
*/
for (x = 0; x < mem_cluster_cnt; x++) {
15
←
Assuming 'x' is >= 'mem_cluster_cnt'→
16
←
Loop condition is false. Execution continues on line 1633→
paddr_t seg_start = mem_clusters[x].start;
paddr_t seg_end = seg_start + mem_clusters[x].size;

if (seg_start < first_avail) seg_start = first_avail;
if (seg_start > seg_end) continue;
if (seg_end - seg_start < PAGE_SIZE(1 << 12)) continue;

physmem += atop(mem_clusters[x].size)((mem_clusters[x].size) >> 12);

1620#if DEBUG_MEMLOAD
printf("loading 0x%lx-0x%lx (0x%lx-0x%lx)\n",
    seg_start, seg_end, atop(seg_start)((seg_start) >> 12), atop(seg_end)((seg_end) >> 12));
1623#endif
uvm_page_physload(atop(seg_start)((seg_start) >> 12), atop(seg_end)((seg_end) >> 12),
    atop(seg_start)((seg_start) >> 12), atop(seg_end)((seg_end) >> 12), 0);
}

/*
       * Now, load the memory between the end of I/O memory "hole"
       * and the kernel.
*/
{
paddr_t seg_start = round_page(IOM_END)(((0x100000) + ((1 << 12) - 1)) & ~((1 << 12)
 - 1));
paddr_t seg_end = trunc_page(KERNTEXTOFF - KERNBASE)(((0xffffffff80000000 +0x1000000) - 0xffffffff80000000) &
 ~((1 << 12) - 1));

if (seg_start16.1
'seg_start' is < 'seg_end'
 < seg_end) {
17
←
Taking true branch→
1637#if DEBUG_MEMLOAD
	printf("loading 0x%lx-0x%lx\n", seg_start, seg_end);
1639#endif
	uvm_page_physload(atop(seg_start)((seg_start) >> 12), atop(seg_end)((seg_end) >> 12),
	    atop(seg_start)((seg_start) >> 12), atop(seg_end)((seg_end) >> 12), 0);
}
}

1645#if DEBUG_MEMLOAD
printf("avail_start = 0x%lx\n", avail_start);
printf("avail_end = 0x%lx\n", avail_end);
printf("first_avail = 0x%lx\n", first_avail);
1649#endif

/*
* Steal memory for the message buffer (at end of core).
*/
{
struct vm_physseg *vps = NULL((void *)0);
18
←
'vps' initialized to a null pointer value→
psize_t sz = round_page(MSGBUFSIZE)((((32 * (1 << 12))) + ((1 << 12) - 1)) & ~((
<< 12) - 1));
psize_t reqsz = sz;

for (x = 0; x < vm_nphysseg; x++) {
19
←
Assuming 'x' is >= 'vm_nphysseg'→
20
←
Loop condition is false. Execution continues on line 1664→
	vps = &vm_physmem[x];
	if (ptoa(vps->avail_end)((paddr_t)(vps->avail_end) << 12) == avail_end)
		break;
}
if (x == vm_nphysseg)
21
←
Assuming 'x' is not equal to 'vm_nphysseg'→
22
←
Taking false branch→
	panic("init_x86_64: can't find end of memory");

/* Shrink so it'll fit in the last segment. */
if ((vps->avail_end - vps->avail_start) < atop(sz)((sz) >> 12))
23
←
Access to field 'avail_end' results in a dereference of a null pointer (loaded from variable 'vps')
	sz = ptoa(vps->avail_end - vps->avail_start)((paddr_t)(vps->avail_end - vps->avail_start) << 12
);

vps->avail_end -= atop(sz)((sz) >> 12);
vps->end -= atop(sz)((sz) >> 12);
msgbuf_paddr = ptoa(vps->avail_end)((paddr_t)(vps->avail_end) << 12);

/* Remove the last segment if it now has no pages. */
if (vps->start == vps->end) {
	for (vm_nphysseg--; x < vm_nphysseg; x++)
		vm_physmem[x] = vm_physmem[x + 1];
}

/* Now find where the new avail_end is. */
for (avail_end = 0, x = 0; x < vm_nphysseg; x++)
	if (vm_physmem[x].avail_end > avail_end)
		avail_end = vm_physmem[x].avail_end;
avail_end = ptoa(avail_end)((paddr_t)(avail_end) << 12);

/* Warn if the message buffer had to be shrunk. */
if (sz != reqsz)
	printf("WARNING: %ld bytes not available for msgbuf "
	    "in last cluster (%ld used)\n", reqsz, sz);
}

/*
* Steal some memory for a dump bouncebuffer if we have memory over
* the 32-bit barrier.
*/
if (avail_end > 0xffffffff) {
struct vm_physseg *vps = NULL((void *)0);
psize_t sz = round_page(MAX(BYTES_PER_DUMP, dbtob(1)))(((((((64 * 1024))>(((1) << 9)))?((64 * 1024)):(((1)
 << 9)))) + ((1 << 12) - 1)) & ~((1 << 12
) - 1));

/* XXX assumes segments are ordered */
for (x = 0; x < vm_nphysseg; x++) {
	vps = &vm_physmem[x];
	/* Find something between 16meg and 4gig */
	if (ptoa(vps->avail_end)((paddr_t)(vps->avail_end) << 12) <= 0xffffffff &&
	    ptoa(vps->avail_start)((paddr_t)(vps->avail_start) << 12) >= 0xffffff)
		break;
}
if (x == vm_nphysseg)
	panic("init_x86_64: no memory between "
	    "0xffffff-0xffffffff");

/* Shrink so it'll fit in the segment. */
if ((vps->avail_end - vps->avail_start) < atop(sz)((sz) >> 12))
	sz = ptoa(vps->avail_end - vps->avail_start)((paddr_t)(vps->avail_end - vps->avail_start) << 12
);

vps->avail_end -= atop(sz)((sz) >> 12);
vps->end -= atop(sz)((sz) >> 12);
dumpmem_paddr = ptoa(vps->avail_end)((paddr_t)(vps->avail_end) << 12);
dumpmem_vaddr = PMAP_DIRECT_MAP(dumpmem_paddr)((vaddr_t)(((((511 - 4) * (1ULL << 39))) | 0xffff000000000000
)) + (dumpmem_paddr));
dumpmem_sz = sz;

/* Remove the last segment if it now has no pages. */
if (vps->start == vps->end) {
	for (vm_nphysseg--; x < vm_nphysseg; x++)
		vm_physmem[x] = vm_physmem[x + 1];
}
}

pmap_growkernel(VM_MIN_KERNEL_ADDRESS0xffff800000000000 + 32 * 1024 * 1024);

pmap_kenter_pa(idt_vaddr, idt_paddr, PROT_READ0x01 | PROT_WRITE0x02);

idt = (struct gate_descriptor *)idt_vaddr;
cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))).ci_tss = &cpu_info_full_primary.cif_tsscif_RO.u_tssgdt.uu_tss;
cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))).ci_gdt = &cpu_info_full_primary.cif_gdtcif_RO.u_tssgdt.uu_gdt;

/* make gdt gates and memory segments */
set_mem_segment(GDT_ADDR_MEM(cpu_info_primary.ci_gdt, GCODE_SEL)((struct mem_segment_descriptor *)((char *)((*(struct cpu_info
 *)((char *)&cpu_info_full_primary + 4096*2 - __builtin_offsetof
(struct cpu_info, ci_dev))).ci_gdt) + ((1) << 3))), 0,
   0xfffff, SDT_MEMERA27, SEL_KPL0, 1, 0, 1);

set_mem_segment(GDT_ADDR_MEM(cpu_info_primary.ci_gdt, GDATA_SEL)((struct mem_segment_descriptor *)((char *)((*(struct cpu_info
 *)((char *)&cpu_info_full_primary + 4096*2 - __builtin_offsetof
(struct cpu_info, ci_dev))).ci_gdt) + ((2) << 3))), 0,
   0xfffff, SDT_MEMRWA19, SEL_KPL0, 1, 0, 1);

set_mem_segment(GDT_ADDR_MEM(cpu_info_primary.ci_gdt, GUCODE32_SEL)((struct mem_segment_descriptor *)((char *)((*(struct cpu_info
 *)((char *)&cpu_info_full_primary + 4096*2 - __builtin_offsetof
(struct cpu_info, ci_dev))).ci_gdt) + ((3) << 3))), 0,
   atop(VM_MAXUSER_ADDRESS32)((0xffffc000) >> 12) - 1, SDT_MEMERA27, SEL_UPL3, 1, 1, 0);

set_mem_segment(GDT_ADDR_MEM(cpu_info_primary.ci_gdt, GUDATA_SEL)((struct mem_segment_descriptor *)((char *)((*(struct cpu_info
 *)((char *)&cpu_info_full_primary + 4096*2 - __builtin_offsetof
(struct cpu_info, ci_dev))).ci_gdt) + ((4) << 3))), 0,
   atop(VM_MAXUSER_ADDRESS)((0x00007f7fffffc000) >> 12) - 1, SDT_MEMRWA19, SEL_UPL3, 1, 0, 1);

set_mem_segment(GDT_ADDR_MEM(cpu_info_primary.ci_gdt, GUCODE_SEL)((struct mem_segment_descriptor *)((char *)((*(struct cpu_info
 *)((char *)&cpu_info_full_primary + 4096*2 - __builtin_offsetof
(struct cpu_info, ci_dev))).ci_gdt) + ((5) << 3))), 0,
   atop(VM_MAXUSER_ADDRESS)((0x00007f7fffffc000) >> 12) - 1, SDT_MEMERA27, SEL_UPL3, 1, 0, 1);

set_sys_segment(GDT_ADDR_SYS(cpu_info_primary.ci_gdt, GPROC0_SEL)((struct sys_segment_descriptor *)((char *)((*(struct cpu_info
 *)((char *)&cpu_info_full_primary + 4096*2 - __builtin_offsetof
(struct cpu_info, ci_dev))).ci_gdt) + ((0) << 4) + (6 <<
 3))),
   cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))).ci_tss, sizeof (struct x86_64_tss)-1,
   SDT_SYS386TSS9, SEL_KPL0, 0);

/* exceptions */
for (x = 0; x < 32; x++) {
/* trap2 == NMI, trap8 == double fault */
ist = (x == 2) ? 2 : (x == 8) ? 1 : 0;
setgate(&idt[x], IDTVEC(exceptions)Xexceptions[x], ist, SDT_SYS386IGT14,
    (x == 3) ? SEL_UPL3 : SEL_KPL0,
    GSEL(GCODE_SEL, SEL_KPL)(((1) << 3) | 0));
idt_allocmap[x] = 1;
}

setregion(&region, cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))).ci_gdt, GDT_SIZE((6 << 3) + (1 << 4)) - 1);
lgdt(&region);

cpu_init_idt();

intr_default_setup();

fpuinit(&cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))));

softintr_init();
splraise(IPL_IPI0xe);
intr_enable();

1781#ifdef DDB1
db_machine_init();
ddb_init();
if (boothowto & RB_KDB0x00040)
db_enter();
1786#endif
1787}

1789void
1790cpu_reset(void)
1791{
intr_disable();

if (cpuresetfn)
(*cpuresetfn)();

/*
* The keyboard controller has 4 random output pins, one of which is
* connected to the RESET pin on the CPU in many PCs.  We tell the
* keyboard controller to pulse this line a couple of times.
*/
outb(IO_KBD + KBCMDP, KBC_PULSE0)( (__builtin_constant_p((0x060 + 4)) && (0x060 + 4) <
 0x100) ? __outbc(0x060 + 4, 0xfe) : __outb(0x060 + 4, 0xfe));
delay(100000)(*delay_func)(100000);
outb(IO_KBD + KBCMDP, KBC_PULSE0)( (__builtin_constant_p((0x060 + 4)) && (0x060 + 4) <
 0x100) ? __outbc(0x060 + 4, 0xfe) : __outb(0x060 + 4, 0xfe));
delay(100000)(*delay_func)(100000);

/*
* Try to cause a triple fault and watchdog reset by making the IDT
* invalid and causing a fault.
*/
memset((caddr_t)idt, 0, NIDT * sizeof(idt[0]))__builtin_memset(((caddr_t)idt), (0), (256 * sizeof(idt[0])));
__asm volatile("divl %0,%1" : : "q" (0), "a" (0));

for (;;)
continue;
/* NOTREACHED */
1817}

1819/*
* cpu_dumpsize: calculate size of machine-dependent kernel core dump headers.
*/
1822int
1823cpu_dumpsize(void)
1824{
int size;

size = ALIGN(sizeof(kcore_seg_t))(((unsigned long)(sizeof(kcore_seg_t)) + (sizeof(long) - 1)) &
~(sizeof(long) - 1)) +
   ALIGN(mem_cluster_cnt * sizeof(phys_ram_seg_t))(((unsigned long)(mem_cluster_cnt * sizeof(phys_ram_seg_t)) +
 (sizeof(long) - 1)) &~(sizeof(long) - 1));
if (roundup(size, dbtob(1))((((size)+((((1) << 9))-1))/(((1) << 9)))*(((1) <<
 9))) != dbtob(1)((1) << 9))
return (-1);

return (1);
1833}

1835/*
* cpu_dump_mempagecnt: calculate the size of RAM (in pages) to be dumped.
*/
1838u_long
1839cpu_dump_mempagecnt(void)
1840{
u_long i, n;

n = 0;
for (i = 0; i < mem_cluster_cnt; i++)
n += atop(mem_clusters[i].size)((mem_clusters[i].size) >> 12);
return (n);
1847}

1849/*
* Figure out which portions of memory are used by the kernel/system.
*/
1852int
1853amd64_pa_used(paddr_t addr)
1854{
struct vm_page	*pg;

/* Kernel manages these */
if ((pg = PHYS_TO_VM_PAGE(addr)) && (pg->pg_flags & PG_DEV0x00000200) == 0)
return 1;

/* Kernel is loaded here */
if (addr > IOM_END0x100000 && addr < (kern_end - KERNBASE0xffffffff80000000))
return 1;

/* Low memory used for various bootstrap things */
if (addr < avail_start)
return 1;

/*
* The only regions I can think of that are left are the things
* we steal away from UVM.  The message buffer?
* XXX - ignore these for now.
*/

return 0;
1876}

1878void
1879cpu_initclocks(void)
1880{
(*initclock_func)();
1882}

1884void
1885cpu_startclock(void)
1886{
(*startclock_func)();
1888}

1890void
1891need_resched(struct cpu_info *ci)
1892{
ci->ci_want_resched = 1;

/* There's a risk we'll be called before the idle threads start */
if (ci->ci_curproc) {
aston(ci->ci_curproc)((ci->ci_curproc)->p_md.md_astpending = 1);
cpu_kick(ci);
}
1900}

1902/*
* Allocate an IDT vector slot within the given range.
* XXX needs locking to avoid MP allocation races.
*/

1907int
1908idt_vec_alloc(int low, int high)
1909{
int vec;

for (vec = low; vec <= high; vec++) {
if (idt_allocmap[vec] == 0) {
	idt_allocmap[vec] = 1;
	return vec;
}
}
return 0;
1919}

1921void
1922idt_vec_set(int vec, void (*function)(void))
1923{
/*
* Vector should be allocated, so no locking needed.
*/
KASSERT(idt_allocmap[vec] == 1)((idt_allocmap[vec] == 1) ? (void)0 : __assert("diagnostic ",
 "/usr/src/sys/arch/amd64/amd64/machdep.c", 1927, "idt_allocmap[vec] == 1"
));
setgate(&idt[vec], function, 0, SDT_SYS386IGT14, SEL_KPL0,
   GSEL(GCODE_SEL, SEL_KPL)(((1) << 3) | 0));
1930}

1932void
1933idt_vec_free(int vec)
1934{
unsetgate(&idt[vec]);
idt_allocmap[vec] = 0;
1937}

1939#ifdef DIAGNOSTIC1
1940void
1941splassert_check(int wantipl, const char *func)
1942{
int cpl = curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_ilevel;
int floor = curcpu()({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_handled_intr_level;

if (cpl < wantipl) {
splassert_fail(wantipl, cpl, func);
}
if (floor > wantipl) {
splassert_fail(wantipl, floor, func);
}

1953}
1954#endif

1956int
1957copyin32(const uint32_t *uaddr, uint32_t *kaddr)
1958{
if ((vaddr_t)uaddr & 0x3)
return EFAULT14;

/* copyin(9) is atomic */
return copyin(uaddr, kaddr, sizeof(uint32_t));
1964}

1966void
1967getbootinfo(char *bootinfo, int bootinfo_size)
1968{
bootarg32_t *q;
bios_ddb_t *bios_ddb;
bios_bootduid_t *bios_bootduid;
bios_bootsr_t *bios_bootsr;
1973#undef BOOTINFO_DEBUG
1974#ifdef BOOTINFO_DEBUG
printf("bootargv:");
1976#endif

for (q = (bootarg32_t *)bootinfo;
   (q->ba_type != BOOTARG_END-1) &&
   ((((char *)q) - bootinfo) < bootinfo_size);
   q = (bootarg32_t *)(((char *)q) + q->ba_size)) {

switch (q->ba_type) {
case BOOTARG_MEMMAP0:
	bios_memmap = (bios_memmap_t *)q->ba_arg;
1986#ifdef BOOTINFO_DEBUG
	printf(" memmap %p", bios_memmap);
1988#endif
	break;
case BOOTARG_DISKINFO1:
	bios_diskinfo = (bios_diskinfo_t *)q->ba_arg;
1992#ifdef BOOTINFO_DEBUG
	printf(" diskinfo %p", bios_diskinfo);
1994#endif
	break;
case BOOTARG_APMINFO2:
	/* generated by i386 boot loader */
	break;
case BOOTARG_CKSUMLEN3:
	bios_cksumlen = *(u_int32_t *)q->ba_arg;
2001#ifdef BOOTINFO_DEBUG
	printf(" cksumlen %d", bios_cksumlen);
2003#endif
	break;
case BOOTARG_PCIINFO4:
	/* generated by i386 boot loader */
	break;
case BOOTARG_CONSDEV5: {
2009#if NCOM1 > 0
	bios_consdev_t *cdp = (bios_consdev_t*)q->ba_arg;
	static const int ports[] =
	    { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
	int unit = minor(cdp->consdev)((unsigned)((cdp->consdev) & 0xff) | (((cdp->consdev
) & 0xffff0000) >> 8));
	uint64_t consaddr = cdp->consaddr;
	if (consaddr == -1 && unit >= 0 && unit < nitems(ports)(sizeof((ports)) / sizeof((ports)[0])))
		consaddr = ports[unit];
	if (major(cdp->consdev)(((unsigned)(cdp->consdev) >> 8) & 0xff) == 8 && consaddr != -1) {
		comconsunit = unit;
		comconsaddr = consaddr;
		comconsrate = cdp->conspeed;
		comconsfreq = cdp->consfreq;
		comcons_reg_width = cdp->reg_width;
		comcons_reg_shift = cdp->reg_shift;
		if (cdp->flags & BCD_MMIO0x00000001)
			comconsiot = X86_BUS_SPACE_MEM(&x86_bus_space_mem_ops);
		else
			comconsiot = X86_BUS_SPACE_IO(&x86_bus_space_io_ops);
	}
2029#endif
2030#ifdef BOOTINFO_DEBUG
	printf(" console 0x%x:%d", cdp->consdev, cdp->conspeed);
2032#endif
	break;
}
case BOOTARG_BOOTMAC7:
	bios_bootmac = (bios_bootmac_t *)q->ba_arg;
	break;

case BOOTARG_DDB8:
	bios_ddb = (bios_ddb_t *)q->ba_arg;
2041#ifdef DDB1
	db_console = bios_ddb->db_console;
2043#endif
	break;

case BOOTARG_BOOTDUID9:
	bios_bootduid = (bios_bootduid_t *)q->ba_arg;
	memcpy(bootduid, bios_bootduid, sizeof(bootduid))__builtin_memcpy((bootduid), (bios_bootduid), (sizeof(bootduid
)));
	break;

case BOOTARG_BOOTSR10:
	bios_bootsr = (bios_bootsr_t *)q->ba_arg;
2053#if NSOFTRAID1 > 0
	memcpy(&sr_bootuuid, &bios_bootsr->uuid,__builtin_memcpy((&sr_bootuuid), (&bios_bootsr->uuid
), (sizeof(sr_bootuuid)))
	    sizeof(sr_bootuuid))__builtin_memcpy((&sr_bootuuid), (&bios_bootsr->uuid
), (sizeof(sr_bootuuid)));
	memcpy(&sr_bootkey, &bios_bootsr->maskkey,__builtin_memcpy((&sr_bootkey), (&bios_bootsr->maskkey
), (sizeof(sr_bootkey)))
	    sizeof(sr_bootkey))__builtin_memcpy((&sr_bootkey), (&bios_bootsr->maskkey
), (sizeof(sr_bootkey)));
2058#endif
	explicit_bzero(bios_bootsr, sizeof(bios_bootsr_t));
	break;

case BOOTARG_EFIINFO11:
	bios_efiinfo = (bios_efiinfo_t *)q->ba_arg;
	break;

case BOOTARG_UCODE12:
	bios_ucode = (bios_ucode_t *)q->ba_arg;
	break;

default:
2071#ifdef BOOTINFO_DEBUG
	printf(" unsupported arg (%d) %p", q->ba_type,
	    q->ba_arg);
2074#endif
	break;
}
}
2078#ifdef BOOTINFO_DEBUG
printf("\n");
2080#endif
2081}

2083int
2084check_context(const struct reg *regs, struct trapframe *tf)
2085{
uint16_t sel;

if (((regs->r_rflags ^ tf->tf_rflags) & PSL_USERSTATIC(0x00000002 | 0xffc08028 | 0x00000200 | 0x00003000 | 0x00004000
 | 0x00020000 | 0x00080000 | 0x00100000)) != 0)
return EINVAL22;

sel = regs->r_ss & 0xffff;
if (!VALID_USER_DSEL(sel)((sel) == (((4) << 3) | 3)))
return EINVAL22;

sel = regs->r_cs & 0xffff;
if (!VALID_USER_CSEL(sel)((sel) == (((5) << 3) | 3)))
return EINVAL22;

if (regs->r_rip >= VM_MAXUSER_ADDRESS0x00007f7fffffc000)
return EINVAL22;

return 0;
2103}

2105int amd64_delay_quality;

2107void
2108delay_init(void(*fn)(int), int fn_quality)
2109{
if (fn_quality > amd64_delay_quality) {
delay_func = fn;
amd64_delay_quality = fn_quality;
}
2114}

2116void
2117delay_fini(void (*fn)(int))
2118{
if (fn == delay_func) {
delay_func = i8254_delay;
amd64_delay_quality = 0;
}
2123}