Return to acpidump.c CVS log

Up to [local] / src / usr.sbin / acpidump

When looking up a symble using kvm_nlist(3), we need to prepend an
underscore.  This fixes acpidump on arm64.  How this ever worked before
is unclear, but part of the puzzle is that we didn't properly check the
return value of the kvm_nlist(3) calls.  So fix that too.

ok deraadt@, mglocker@

/*	$OpenBSD: acpidump.c,v 1.25 2022/09/11 10:40:35 kettenis Exp $	*/
/*
 * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@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.
 *
 */

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/queue.h>
#include <sys/stat.h>

#include <assert.h>
#include <err.h>
#include <fcntl.h>
#include <kvm.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <paths.h>


#define vm_page_size sysconf(_SC_PAGESIZE)
#define PRINTFLAG(xx)							\
	do {								\
		if (facp->flags & ACPI_FACP_FLAG_## xx) {		\
			fprintf(fhdr, "%c%s", sep, #xx); sep = ',';	\
		}							\
	} while (0)


typedef unsigned long	vm_offset_t;

struct ACPIrsdp {
	u_char		signature[8];
	u_char		sum;
	u_char		oem[6];
	u_char		rev;
	u_int32_t	addr;
#define SIZEOF_RSDP_REV_0	20
	u_int32_t	len;
	u_int64_t	xaddr;
	u_char		xsum;
	u_char		xres[3];
} __packed;

struct ACPIsdt {
	u_char		signature[4];
	u_int32_t	len;
	u_char		rev;
	u_char		check;
	u_char		oemid[6];
	u_char		oemtblid[8];
	u_int32_t	oemrev;
	u_char		creator[4];
	u_int32_t	crerev;
#define SIZEOF_SDT_HDR	36	/* struct size except body */
	u_int32_t	body[1];/* This member should be casted */
} __packed;

struct ACPIgas {
	u_int8_t	address_space_id;
#define ACPI_GAS_MEMORY		0
#define ACPI_GAS_IO		1
#define ACPI_GAS_PCI		2
#define ACPI_GAS_EMBEDDED	3
#define ACPI_GAS_SMBUS		4
#define ACPI_GAS_FIXED		0x7f
	u_int8_t	register_bit_width;
	u_int8_t	register_bit_offset;
	u_int8_t	res;
	u_int64_t	address;
} __packed;

struct FACPbody {
	u_int32_t	facs_ptr;
	u_int32_t	dsdt_ptr;
	u_int8_t	int_model;
#define ACPI_FACP_INTMODEL_PIC	0	/* Standard PC-AT PIC */
#define ACPI_FACP_INTMODEL_APIC	1	/* Multiple APIC */
	u_char		reserved1;
	u_int16_t	sci_int;
	u_int32_t	smi_cmd;
	u_int8_t	acpi_enable;
	u_int8_t	acpi_disable;
	u_int8_t	s4biosreq;
	u_int8_t	reserved2;
	u_int32_t	pm1a_evt_blk;
	u_int32_t	pm1b_evt_blk;
	u_int32_t	pm1a_cnt_blk;
	u_int32_t	pm1b_cnt_blk;
	u_int32_t	pm2_cnt_blk;
	u_int32_t	pm_tmr_blk;
	u_int32_t	gpe0_blk;
	u_int32_t	gpe1_blk;
	u_int8_t	pm1_evt_len;
	u_int8_t	pm1_cnt_len;
	u_int8_t	pm2_cnt_len;
	u_int8_t	pm_tmr_len;
	u_int8_t	gpe0_len;
	u_int8_t	gpe1_len;
	u_int8_t	gpe1_base;
	u_int8_t	reserved3;
	u_int16_t	p_lvl2_lat;
	u_int16_t	p_lvl3_lat;
	u_int16_t	flush_size;
	u_int16_t	flush_stride;
	u_int8_t	duty_off;
	u_int8_t	duty_width;
	u_int8_t	day_alrm;
	u_int8_t	mon_alrm;
	u_int8_t	century;
	u_int16_t	iapc_boot_arch;
	u_char		reserved4[1];
	u_int32_t	flags;
#define ACPI_FACP_FLAG_WBINVD	1	/* WBINVD is correctly supported */
#define ACPI_FACP_FLAG_WBINVD_FLUSH 2	/* WBINVD flushes caches */
#define ACPI_FACP_FLAG_PROC_C1	4	/* C1 power state supported */
#define ACPI_FACP_FLAG_P_LVL2_UP 8	/* C2 power state works on SMP */
#define ACPI_FACP_FLAG_PWR_BUTTON 16	/* Power button uses control method */
#define ACPI_FACP_FLAG_SLP_BUTTON 32	/* Sleep button uses control method */
#define ACPI_FACP_FLAG_FIX_RTC	64	/* RTC wakeup not supported */
#define ACPI_FACP_FLAG_RTC_S4	128	/* RTC can wakeup from S4 state */
#define ACPI_FACP_FLAG_TMR_VAL_EXT 256	/* TMR_VAL is 32bit */
#define ACPI_FACP_FLAG_DCK_CAP	512	/* Can support docking */
	struct ACPIgas	reset_reg;
	u_int8_t	reset_value;
	u_int8_t	reserved5[3];
	u_int64_t	x_firmware_ctrl;
	u_int64_t	x_dsdt;
	struct ACPIgas	x_pm1a_evt_blk;
	struct ACPIgas	x_pm1b_evt_blk;
	struct ACPIgas	x_pm1a_cnt_blk;
	struct ACPIgas	x_pm1b_cnt_blk;
	struct ACPIgas	x_pm2_cnt_blk;
	struct ACPIgas	x_pm_tmr_blk;
	struct ACPIgas	x_gpe0_blk;
	struct ACPIgas	x_gpe1_blk;
} __packed;

struct acpi_user_mapping {
	LIST_ENTRY(acpi_user_mapping)	link;
	vm_offset_t			pa;
	caddr_t				va;
	size_t				size;
};

LIST_HEAD(acpi_user_mapping_list, acpi_user_mapping) maplist;

int		acpi_mem_fd = -1;
char		*aml_dumpfile;
int		aml_dumpdir;
FILE		*fhdr;
int		quiet;

int	acpi_checksum(void *_p, size_t _length);
struct acpi_user_mapping *acpi_user_find_mapping(vm_offset_t _pa, size_t _size);
void	*acpi_map_physical(vm_offset_t _pa, size_t _size);
void	acpi_user_init(void);
struct ACPIrsdp *acpi_check_rsd_ptr(vm_offset_t _pa);
struct ACPIrsdp *acpi_find_rsd_ptr(void);
void	acpi_print_string(char *_s, size_t _length);
void	acpi_print_rsd_ptr(struct ACPIrsdp *_rp);
struct ACPIsdt *acpi_map_sdt(vm_offset_t _pa);
void	aml_dump(struct ACPIsdt *_hdr);
void	acpi_print_sdt(struct ACPIsdt *_sdp);
void	acpi_print_rsdt(struct ACPIsdt *_rsdp);
void	acpi_print_xsdt(struct ACPIsdt *_rsdp);
void	acpi_print_facp(struct FACPbody *_facp);
void	acpi_print_dsdt(struct ACPIsdt *_dsdp);
void	acpi_handle_dsdt(struct ACPIsdt *_dsdp);
void	acpi_handle_facp(struct FACPbody *_facp);
void	acpi_handle_rsdt(struct ACPIsdt *_rsdp);
void	acpi_handle_xsdt(struct ACPIsdt *_rsdp);
void	asl_dump_from_devmem(void);
void	usage(void);
u_long	efi_acpi_addr(void);


struct ACPIsdt	dsdt_header = {
	"DSDT", 0, 1, 0, "OEMID", "OEMTBLID", 0x12345678, "CRTR", 0x12345678
};

int
acpi_checksum(void *p, size_t length)
{
	u_int8_t	*bp;
	u_int8_t	sum;

	bp = p;
	sum = 0;
	while (length--)
		sum += *bp++;

	return (sum);
}

struct acpi_user_mapping *
acpi_user_find_mapping(vm_offset_t pa, size_t size)
{
	struct acpi_user_mapping	*map;
	int	page_mask = getpagesize() - 1;

	/* First search for an existing mapping */
	for (map = LIST_FIRST(&maplist); map; map = LIST_NEXT(map, link)) {
		if (map->pa <= pa && map->size >= pa + size - map->pa)
			return (map);
	}

	/* Then create a new one */
#undef round_page
#undef trunc_page
#define	round_page(x)	(((x) + page_mask) & ~page_mask)
#define	trunc_page(x)	((x) & ~page_mask)
	size = round_page(pa + size) - trunc_page(pa);
	pa = trunc_page(pa);
#undef round_page
#undef trunc_page
	map = malloc(sizeof(struct acpi_user_mapping));
	if (!map)
		errx(1, "out of memory");
	map->pa = pa;
	map->va = mmap(0, size, PROT_READ, MAP_SHARED, acpi_mem_fd, pa);
	map->size = size;
	if (map->va == MAP_FAILED)
		err(1, "can't map address");
	LIST_INSERT_HEAD(&maplist, map, link);

	return (map);
}

void *
acpi_map_physical(vm_offset_t pa, size_t size)
{
	struct acpi_user_mapping	*map;

	map = acpi_user_find_mapping(pa, size);
	return (map->va + (pa - map->pa));
}

void
acpi_user_init(void)
{
	if (acpi_mem_fd == -1) {
		acpi_mem_fd = open("/dev/mem", O_RDONLY);
		if (acpi_mem_fd == -1)
			err(1, "opening /dev/mem");
		LIST_INIT(&maplist);
	}
}

struct ACPIrsdp *
acpi_check_rsd_ptr(vm_offset_t pa)
{
	struct ACPIrsdp rp;
		
	lseek(acpi_mem_fd, pa, SEEK_SET);
	read(acpi_mem_fd, &rp, SIZEOF_RSDP_REV_0);
	if (memcmp(rp.signature, "RSD PTR ", 8) != 0)
		return NULL;

	if (rp.rev >= 2) {
		read(acpi_mem_fd, &(rp.len),
		    sizeof(struct ACPIrsdp) - SIZEOF_RSDP_REV_0);
		if (acpi_checksum(&rp, sizeof(struct ACPIrsdp)) == 0)
			return acpi_map_physical(pa, sizeof(struct ACPIrsdp));
	}

	if (acpi_checksum(&rp, SIZEOF_RSDP_REV_0) == 0)
		return (acpi_map_physical(pa, SIZEOF_RSDP_REV_0));

	return NULL;
}

struct ACPIrsdp *
acpi_find_rsd_ptr(void)
{
	struct ACPIrsdp *rp;
	u_long		addr;

	if ((addr = efi_acpi_addr()) != 0) {
		if ((rp = acpi_check_rsd_ptr(addr)))
			return rp;
	}

#if defined(__amd64__) || defined (__i386__)
	for (addr = 0; addr < 1024 * 1024; addr += 16) {
		if ((rp = acpi_check_rsd_ptr(addr)))
			return rp;
	}
#endif

	return NULL;
}

void
acpi_print_string(char *s, size_t length)
{
	int		c;

	/* Trim trailing spaces and NULLs */
	while (length > 0 && (s[length - 1] == ' ' || s[length - 1] == '\0'))
		length--;

	while (length--) {
		c = *s++;
		fputc(c, fhdr);
	}
}

void
acpi_print_rsd_ptr(struct ACPIrsdp *rp)
{
	fprintf(fhdr, "\n");
	fprintf(fhdr, "RSD PTR: Checksum=%d, OEMID=", rp->sum);
	acpi_print_string(rp->oem, 6);
	fprintf(fhdr, ", Revision=%d", rp->rev);
	fprintf(fhdr, ", RsdtAddress=0x%08x\n", rp->addr);
	if (rp->rev >= 2) {
		fprintf(fhdr, "\tLength=%d", rp->len);
		fprintf(fhdr, ", XsdtAddress=0x%016llx", rp->xaddr);
		fprintf(fhdr, ", Extended Checksum=%d\n", rp->xsum);
	}
	fprintf(fhdr, "\n");
}

struct ACPIsdt *
acpi_map_sdt(vm_offset_t pa)
{
	struct ACPIsdt	*sp;

	sp = acpi_map_physical(pa, sizeof(struct ACPIsdt));
	sp = acpi_map_physical(pa, sp->len);
	return (sp);
}

void
aml_dump(struct ACPIsdt *hdr)
{
	static int	hdr_index;
	char		name[PATH_MAX];
	int		fd;
	mode_t		mode;

	snprintf(name, sizeof(name), "%s%c%c%c%c%c.%d",
	    aml_dumpfile, aml_dumpdir ? '/' : '.',
	    hdr->signature[0], hdr->signature[1],
	    hdr->signature[2], hdr->signature[3],
	    hdr_index++);

	mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
	fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, mode);
	if (fd == -1)
		err(1, "aml_dump");

	write(fd, hdr, SIZEOF_SDT_HDR);
	write(fd, hdr->body, hdr->len - SIZEOF_SDT_HDR);
	close(fd);
}

void
acpi_print_sdt(struct ACPIsdt *sdp)
{
	fprintf(fhdr, "\n");
	acpi_print_string(sdp->signature, 4);
	fprintf(fhdr, ": Length=%d, Revision=%d, Checksum=%d,\n",
	       sdp->len, sdp->rev, sdp->check);
	fprintf(fhdr, "\tOEMID=");
	acpi_print_string(sdp->oemid, 6);
	fprintf(fhdr, ", OEM Table ID=");
	acpi_print_string(sdp->oemtblid, 8);
	fprintf(fhdr, ", OEM Revision=0x%x,\n", sdp->oemrev);
	fprintf(fhdr, "\tCreator ID=");
	acpi_print_string(sdp->creator, 4);
	fprintf(fhdr, ", Creator Revision=0x%x\n", sdp->crerev);
	fprintf(fhdr, "\n");
	if (!memcmp(sdp->signature, "DSDT", 4))
		memcpy(&dsdt_header, sdp, sizeof(dsdt_header));
}

void
acpi_print_rsdt(struct ACPIsdt *rsdp)
{
	int		i, entries;

	acpi_print_sdt(rsdp);
	entries = (rsdp->len - SIZEOF_SDT_HDR) / sizeof(u_int32_t);
	fprintf(fhdr, "\n");
	fprintf(fhdr, "\tEntries={ ");
	for (i = 0; i < entries; i++) {
		if (i > 0)
			fprintf(fhdr, ", ");
		fprintf(fhdr, "0x%08x", rsdp->body[i]);
	}
	fprintf(fhdr, " }\n");
	fprintf(fhdr, "\n");
}

void
acpi_print_xsdt(struct ACPIsdt *rsdp)
{
	int		i, entries;
	u_int64_t	*body = (u_int64_t *) rsdp->body;

	acpi_print_sdt(rsdp);
	entries = (rsdp->len - SIZEOF_SDT_HDR) / sizeof(u_int64_t);
	fprintf(fhdr, "\n");
	fprintf(fhdr, "\tEntries={ ");
	for (i = 0; i < entries; i++) {
		if (i > 0)
			fprintf(fhdr, ", ");
		fprintf(fhdr, "0x%016llx", body[i]);
	}
	fprintf(fhdr, " }\n");
	fprintf(fhdr, "\n");
}

void
acpi_print_facp(struct FACPbody *facp)
{
	char		sep;

	fprintf(fhdr, "\n");
	fprintf(fhdr, "\tDSDT=0x%x\n", facp->dsdt_ptr);
	fprintf(fhdr, "\tINT_MODEL=%s\n", facp->int_model ? "APIC" : "PIC");
	fprintf(fhdr, "\tSCI_INT=%d\n", facp->sci_int);
	fprintf(fhdr, "\tSMI_CMD=0x%x, ", facp->smi_cmd);
	fprintf(fhdr, "ACPI_ENABLE=0x%x, ", facp->acpi_enable);
	fprintf(fhdr, "ACPI_DISABLE=0x%x, ", facp->acpi_disable);
	fprintf(fhdr, "S4BIOS_REQ=0x%x\n", facp->s4biosreq);
	if (facp->pm1a_evt_blk)
		fprintf(fhdr, "\tPM1a_EVT_BLK=0x%x-0x%x\n",
		    facp->pm1a_evt_blk,
		    facp->pm1a_evt_blk + facp->pm1_evt_len - 1);
	if (facp->pm1b_evt_blk)
		fprintf(fhdr, "\tPM1b_EVT_BLK=0x%x-0x%x\n",
		    facp->pm1b_evt_blk,
		    facp->pm1b_evt_blk + facp->pm1_evt_len - 1);
	if (facp->pm1a_cnt_blk)
		fprintf(fhdr, "\tPM1a_CNT_BLK=0x%x-0x%x\n",
		    facp->pm1a_cnt_blk,
		    facp->pm1a_cnt_blk + facp->pm1_cnt_len - 1);
	if (facp->pm1b_cnt_blk)
		fprintf(fhdr, "\tPM1b_CNT_BLK=0x%x-0x%x\n",
		    facp->pm1b_cnt_blk,
		    facp->pm1b_cnt_blk + facp->pm1_cnt_len - 1);
	if (facp->pm2_cnt_blk)
		fprintf(fhdr, "\tPM2_CNT_BLK=0x%x-0x%x\n",
		    facp->pm2_cnt_blk,
		    facp->pm2_cnt_blk + facp->pm2_cnt_len - 1);
	if (facp->pm_tmr_blk)
		fprintf(fhdr, "\tPM2_TMR_BLK=0x%x-0x%x\n",
		    facp->pm_tmr_blk,
		    facp->pm_tmr_blk + facp->pm_tmr_len - 1);
	if (facp->gpe0_blk)
		fprintf(fhdr, "\tPM2_GPE0_BLK=0x%x-0x%x\n",
		    facp->gpe0_blk,
		    facp->gpe0_blk + facp->gpe0_len - 1);
	if (facp->gpe1_blk)
		fprintf(fhdr, "\tPM2_GPE1_BLK=0x%x-0x%x, GPE1_BASE=%d\n",
		    facp->gpe1_blk,
		    facp->gpe1_blk + facp->gpe1_len - 1,
		    facp->gpe1_base);
	fprintf(fhdr, "\tP_LVL2_LAT=%dms, P_LVL3_LAT=%dms\n",
	    facp->p_lvl2_lat, facp->p_lvl3_lat);
	fprintf(fhdr, "\tFLUSH_SIZE=%d, FLUSH_STRIDE=%d\n",
	    facp->flush_size, facp->flush_stride);
	fprintf(fhdr, "\tDUTY_OFFSET=%d, DUTY_WIDTH=%d\n",
	    facp->duty_off, facp->duty_width);
	fprintf(fhdr, "\tDAY_ALRM=%d, MON_ALRM=%d, CENTURY=%d\n",
	    facp->day_alrm, facp->mon_alrm, facp->century);
	fprintf(fhdr, "\tFlags=");
	sep = '{';

	PRINTFLAG(WBINVD);
	PRINTFLAG(WBINVD_FLUSH);
	PRINTFLAG(PROC_C1);
	PRINTFLAG(P_LVL2_UP);
	PRINTFLAG(PWR_BUTTON);
	PRINTFLAG(SLP_BUTTON);
	PRINTFLAG(FIX_RTC);
	PRINTFLAG(RTC_S4);
	PRINTFLAG(TMR_VAL_EXT);
	PRINTFLAG(DCK_CAP);

	fprintf(fhdr, "}\n");
	fprintf(fhdr, "\n");
}

void
acpi_print_dsdt(struct ACPIsdt *dsdp)
{
	acpi_print_sdt(dsdp);
}

void
acpi_handle_dsdt(struct ACPIsdt *dsdp)
{
	u_int8_t	*dp;
	u_int8_t	*end;

	acpi_print_dsdt(dsdp);

	dp = (u_int8_t *)dsdp->body;
	end = (u_int8_t *)dsdp + dsdp->len;
}

void
acpi_handle_facp(struct FACPbody *facp)
{
	struct ACPIsdt	*dsdp;

	acpi_print_facp(facp);
	if (facp->dsdt_ptr == 0)
		dsdp = (struct ACPIsdt *) acpi_map_sdt(facp->x_dsdt);
	else
		dsdp = (struct ACPIsdt *) acpi_map_sdt(facp->dsdt_ptr);
	if (acpi_checksum(dsdp, dsdp->len))
		errx(1, "DSDT is corrupt");
	acpi_handle_dsdt(dsdp);
	aml_dump(dsdp);
}

void
acpi_handle_rsdt(struct ACPIsdt *rsdp)
{
	int		i;
	int		entries;
	struct ACPIsdt	*sdp;

	aml_dump(rsdp);
	entries = (rsdp->len - SIZEOF_SDT_HDR) / sizeof(u_int32_t);
	acpi_print_rsdt(rsdp);
	for (i = 0; i < entries; i++) {
		sdp = (struct ACPIsdt *) acpi_map_sdt(rsdp->body[i]);
		if (acpi_checksum(sdp, sdp->len))
			errx(1, "RSDT entry %d is corrupt", i);
		aml_dump(sdp);
		if (!memcmp(sdp->signature, "FACP", 4)) {
			acpi_handle_facp((struct FACPbody *) sdp->body);
		} else {
			acpi_print_sdt(sdp);
		}
	}
}

void
acpi_handle_xsdt(struct ACPIsdt *rsdp)
{
	int		i;
	int		entries;
	struct ACPIsdt	*sdp;
	u_int64_t	*body = (u_int64_t *) rsdp->body;

	aml_dump(rsdp);
	entries = (rsdp->len - SIZEOF_SDT_HDR) / sizeof(u_int64_t);
	acpi_print_xsdt(rsdp);
	for (i = 0; i < entries; i++) {
		sdp = (struct ACPIsdt *) acpi_map_sdt(body[i]);
		if (acpi_checksum(sdp, sdp->len))
			errx(1, "XSDT entry %d is corrupt", i);
		aml_dump(sdp);
		if (!memcmp(sdp->signature, "FACP", 4)) {
			acpi_handle_facp((struct FACPbody *) sdp->body);
		} else {
			acpi_print_sdt(sdp);
		}
	}
}

void
asl_dump_from_devmem(void)
{
	struct ACPIrsdp	*rp;
	struct ACPIsdt	*rsdp;
	char		name[PATH_MAX];

	snprintf(name, sizeof(name), "%s%cheaders", aml_dumpfile,
	    aml_dumpdir ? '/' : '.');

	acpi_user_init();

	/* Can only unveil if being dumped to a dir */
	if (aml_dumpdir) {
		if (unveil(aml_dumpfile, "wc") == -1)
			err(1, "unveil %s", aml_dumpfile);
	} else if (aml_dumpfile[0] == '/') {	/* admittedly pretty shitty */
		if (unveil("/", "wc") == -1)
			err(1, "unveil /");
	} else {
		if (unveil(".", "wc") == -1)
			err(1, "unveil .");
	}

	if (unveil(_PATH_MEM, "r") == -1)
		err(1, "unveil %s", _PATH_MEM);
	if (unveil(_PATH_KMEM, "r") == -1)
		err(1, "unveil %s", _PATH_KMEM);
	if (unveil(_PATH_KVMDB, "r") == -1)
		err(1, "unveil %s", _PATH_KVMDB);
	if (unveil(_PATH_KSYMS, "r") == -1)
		err(1, "unveil %s", _PATH_KSYMS);
	if (unveil(_PATH_UNIX, "r") == -1)
		err(1, "unveil %s", _PATH_UNIX);
	if (pledge("stdio rpath wpath cpath", NULL) == -1)
		err(1, "pledge");

	rp = acpi_find_rsd_ptr();
	if (!rp) {
		if (!quiet)
			warnx("Can't find ACPI information");
		exit(1);
	}

	fhdr = fopen(name, "w");
	if (fhdr == NULL)
		err(1, "asl_dump_from_devmem");

	acpi_print_rsd_ptr(rp);

	if (rp->rev == 2 && rp->xaddr) {
		rsdp = (struct ACPIsdt *) acpi_map_sdt(rp->xaddr);
		if (memcmp(rsdp->signature, "XSDT", 4) ||
		    acpi_checksum(rsdp, rsdp->len))
			errx(1, "XSDT is corrupted");

		acpi_handle_xsdt(rsdp);
	} else if (rp->addr) {
		rsdp = (struct ACPIsdt *) acpi_map_sdt(rp->addr);
		if (memcmp(rsdp->signature, "RSDT", 4) ||
		    acpi_checksum(rsdp, rsdp->len))
			errx(1, "RSDT is corrupted");

		acpi_handle_rsdt(rsdp);
	} else
		errx(1, "XSDT or RSDT not found");

	fclose(fhdr);
}

void
usage(void)
{
	extern char	*__progname;

	fprintf(stderr, "usage: %s -o prefix\n", __progname);
	exit(1);
}

int
main(int argc, char *argv[])
{
	struct stat	st;
	int		c;

	while ((c = getopt(argc, argv, "o:q")) != -1) {
		switch (c) {
		case 'o':
			aml_dumpfile = optarg;
			break;
		case 'q':
			quiet = 1;
			break;
		default:
			usage();
			break;
		}
	}

	if (aml_dumpfile == NULL)
		usage();

	if (stat(aml_dumpfile, &st) == 0 && S_ISDIR(st.st_mode))
		aml_dumpdir = 1;

	asl_dump_from_devmem();

	return (0);
}

#ifdef __aarch64__

u_long
efi_acpi_addr(void)
{
	kvm_t		*kd;
	struct nlist	 nl[2];
	uint64_t	 table;

	memset(&nl, 0, sizeof(nl));
	kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
	if (kd == NULL)
		goto on_error;
	nl[0].n_name = "_efi_acpi_table";
	if (kvm_nlist(kd, nl) != 0)
		goto on_error;
	if (kvm_read(kd, nl[0].n_value, &table, sizeof(table)) == -1)
		goto on_error;

	kvm_close(kd);
	return table;

on_error:
	if (kd != NULL)
		kvm_close(kd);
	return (0);
}

#else

#include <machine/biosvar.h>

u_long
efi_acpi_addr(void)
{
	kvm_t		*kd;
	struct nlist	 nl[2];
	bios_efiinfo_t	 efiinfo;
	u_long	 ptr;

	memset(&nl, 0, sizeof(nl));
	kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
	if (kd == NULL)
		goto on_error;
	nl[0].n_name = "_bios_efiinfo";
	if (kvm_nlist(kd, nl) != 0)
		goto on_error;
	if (kvm_read(kd, nl[0].n_value, &ptr, sizeof(ptr)) == -1)
		goto on_error;
	if (kvm_read(kd, ptr, &efiinfo, sizeof(efiinfo)) == -1)
		goto on_error;

	kvm_close(kd);
	return (efiinfo.config_acpi);

on_error:
	if (kd != NULL)
		kvm_close(kd);
	return (0);
}

#endif