Differential D18346 Diff 51612 sys/dev/nvdimm/nvdimm_spa.c

Changeset View

Standalone View

sys/dev/nvdimm/nvdimm_spa.c

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
#include <vm/vm_page.h>		#include <vm/vm_page.h>
#include <vm/vm_pager.h>		#include <vm/vm_pager.h>
#include <contrib/dev/acpica/include/acpi.h>		#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>		#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acuuid.h>		#include <contrib/dev/acpica/include/acuuid.h>
#include <dev/acpica/acpivar.h>		#include <dev/acpica/acpivar.h>
#include <dev/nvdimm/nvdimm_var.h>		#include <dev/nvdimm/nvdimm_var.h>

struct SPA_mapping *spa_mappings;
int spa_mappings_cnt;

static int
nvdimm_spa_count(void nfitsubtbl __unused, void arg)
{
int *cnt;

cnt = arg;
(*cnt)++;
return (0);
}

static struct nvdimm_SPA_uuid_list_elm {		static struct nvdimm_SPA_uuid_list_elm {
const char *u_name;		const char *u_name;
const char *u_id_str;		const char *u_id_str;
struct uuid u_id;		struct uuid u_id;
const bool u_usr_acc;		const bool u_usr_acc;
} nvdimm_SPA_uuid_list[] = {		} nvdimm_SPA_uuid_list[] = {
[SPA_TYPE_VOLATILE_MEMORY] = {		[SPA_TYPE_VOLATILE_MEMORY] = {
.u_name = "VOLA MEM ",		.u_name = "VOLA MEM ",
Show All 32 Lines	static struct nvdimm_SPA_uuid_list_elm {
},		},
[SPA_TYPE_PERSISTENT_VIRTUAL_CD] = {		[SPA_TYPE_PERSISTENT_VIRTUAL_CD] = {
.u_name = "PV CD ",		.u_name = "PV CD ",
.u_id_str = UUID_PERSISTENT_VIRTUAL_CD,		.u_id_str = UUID_PERSISTENT_VIRTUAL_CD,
.u_usr_acc = true,		.u_usr_acc = true,
},		},
};		};

		static int
		spa_type_from_uuid(const struct uuid *u)
		{
		int i;

		for (i = 0; i < nitems(nvdimm_SPA_uuid_list); i++) {
		if (uuidcmp(u, &nvdimm_SPA_uuid_list[i].u_id) != 0)
		continue;
		return (i);
		}
		return (SPA_TYPE_UNKNOWN);
		}

static vm_memattr_t		static vm_memattr_t
nvdimm_spa_memattr(struct SPA_mapping *spa)		nvdimm_spa_memattr(struct SPA_mapping *spa)
{		{
vm_memattr_t mode;		vm_memattr_t mode;

if ((spa->spa_efi_mem_flags & EFI_MD_ATTR_WB) != 0)		if ((spa->spa_efi_mem_flags & EFI_MD_ATTR_WB) != 0)
mode = VM_MEMATTR_WRITE_BACK;		mode = VM_MEMATTR_WRITE_BACK;
else if ((spa->spa_efi_mem_flags & EFI_MD_ATTR_WT) != 0)		else if ((spa->spa_efi_mem_flags & EFI_MD_ATTR_WT) != 0)
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines	nvdimm_spa_g_all_unmapped(struct SPA_mapping spa, struct bio bp,
else		else
pmap_copy_pages(bp->bio_ma, bp->bio_ma_offset, ma,		pmap_copy_pages(bp->bio_ma, bp->bio_ma_offset, ma,
bp->bio_offset & PAGE_MASK, bp->bio_length);		bp->bio_offset & PAGE_MASK, bp->bio_length);
}		}

static void		static void
nvdimm_spa_g_thread(void *arg)		nvdimm_spa_g_thread(void *arg)
{		{
struct SPA_mapping *spa;		struct g_spa_softc *sc;
struct bio *bp;		struct bio *bp;
struct uio auio;		struct uio auio;
struct iovec aiovec;		struct iovec aiovec;
int error;		int error;

spa = arg;		sc = arg;
for (;;) {		for (;;) {
mtx_lock(&spa->spa_g_mtx);		mtx_lock(&sc->spa_g_mtx);
for (;;) {		for (;;) {
bp = bioq_takefirst(&spa->spa_g_queue);		bp = bioq_takefirst(&sc->spa_g_queue);
if (bp != NULL)		if (bp != NULL)
break;		break;
msleep(&spa->spa_g_queue, &spa->spa_g_mtx, PRIBIO,		msleep(&sc->spa_g_queue, &sc->spa_g_mtx, PRIBIO,
"spa_g", 0);		"spa_g", 0);
if (!spa->spa_g_proc_run) {		if (!sc->spa_g_proc_run) {
spa->spa_g_proc_exiting = true;		sc->spa_g_proc_exiting = true;
wakeup(&spa->spa_g_queue);		wakeup(&sc->spa_g_queue);
mtx_unlock(&spa->spa_g_mtx);		mtx_unlock(&sc->spa_g_mtx);
kproc_exit(0);		kproc_exit(0);
}		}
continue;		continue;
}		}
mtx_unlock(&spa->spa_g_mtx);		mtx_unlock(&sc->spa_g_mtx);
if (bp->bio_cmd != BIO_READ && bp->bio_cmd != BIO_WRITE &&		if (bp->bio_cmd != BIO_READ && bp->bio_cmd != BIO_WRITE &&
bp->bio_cmd != BIO_FLUSH) {		bp->bio_cmd != BIO_FLUSH) {
error = EOPNOTSUPP;		error = EOPNOTSUPP;
goto completed;		goto completed;
}		}

error = 0;		error = 0;
if (bp->bio_cmd == BIO_FLUSH) {		if (bp->bio_cmd == BIO_FLUSH) {
if (spa->spa_kva != NULL) {		if (sc->spa->spa_kva != NULL) {
pmap_large_map_wb(spa->spa_kva, spa->spa_len);		pmap_large_map_wb(sc->spa->spa_kva,
		sc->spa->spa_len);
} else {		} else {
pmap_flush_cache_phys_range(		pmap_flush_cache_phys_range(
(vm_paddr_t)spa->spa_phys_base,		(vm_paddr_t)sc->spa->spa_phys_base,
(vm_paddr_t)spa->spa_phys_base +		(vm_paddr_t)sc->spa->spa_phys_base +
spa->spa_len, nvdimm_spa_memattr(spa));		sc->spa->spa_len,
		nvdimm_spa_memattr(sc->spa));
}		}
/*		/*
* XXX flush IMC		* XXX flush IMC
*/		*/
goto completed;		goto completed;
}		}

if ((bp->bio_flags & BIO_UNMAPPED) != 0) {		if ((bp->bio_flags & BIO_UNMAPPED) != 0) {
if (spa->spa_kva != NULL) {		if (sc->spa->spa_kva != NULL) {
aiovec.iov_base = (char *)spa->spa_kva +		aiovec.iov_base = (char *)sc->spa->spa_kva +
bp->bio_offset;		bp->bio_offset;
aiovec.iov_len = bp->bio_length;		aiovec.iov_len = bp->bio_length;
auio.uio_iov = &aiovec;		auio.uio_iov = &aiovec;
auio.uio_iovcnt = 1;		auio.uio_iovcnt = 1;
auio.uio_resid = bp->bio_length;		auio.uio_resid = bp->bio_length;
auio.uio_offset = bp->bio_offset;		auio.uio_offset = bp->bio_offset;
auio.uio_segflg = UIO_SYSSPACE;		auio.uio_segflg = UIO_SYSSPACE;
auio.uio_rw = bp->bio_cmd == BIO_READ ?		auio.uio_rw = bp->bio_cmd == BIO_READ ?
UIO_WRITE : UIO_READ;		UIO_WRITE : UIO_READ;
auio.uio_td = curthread;		auio.uio_td = curthread;
error = uiomove_fromphys(bp->bio_ma,		error = uiomove_fromphys(bp->bio_ma,
bp->bio_ma_offset, bp->bio_length, &auio);		bp->bio_ma_offset, bp->bio_length, &auio);
} else {		} else {
nvdimm_spa_g_all_unmapped(spa, bp, bp->bio_cmd);		nvdimm_spa_g_all_unmapped(sc->spa, bp,
		bp->bio_cmd);
error = 0;		error = 0;
}		}
} else {		} else {
aiovec.iov_base = bp->bio_data;		aiovec.iov_base = bp->bio_data;
aiovec.iov_len = bp->bio_length;		aiovec.iov_len = bp->bio_length;
auio.uio_iov = &aiovec;		auio.uio_iov = &aiovec;
auio.uio_iovcnt = 1;		auio.uio_iovcnt = 1;
auio.uio_resid = bp->bio_length;		auio.uio_resid = bp->bio_length;
auio.uio_offset = bp->bio_offset;		auio.uio_offset = bp->bio_offset;
auio.uio_segflg = UIO_SYSSPACE;		auio.uio_segflg = UIO_SYSSPACE;
auio.uio_rw = bp->bio_cmd == BIO_READ ? UIO_READ :		auio.uio_rw = bp->bio_cmd == BIO_READ ? UIO_READ :
UIO_WRITE;		UIO_WRITE;
auio.uio_td = curthread;		auio.uio_td = curthread;
error = nvdimm_spa_uio(spa, &auio);		error = nvdimm_spa_uio(sc->spa, &auio);
}		}
devstat_end_transaction_bio(spa->spa_g_devstat, bp);		devstat_end_transaction_bio(sc->spa_g_devstat, bp);
completed:		completed:
bp->bio_completed = bp->bio_length;		bp->bio_completed = bp->bio_length;
g_io_deliver(bp, error);		g_io_deliver(bp, error);
}		}
}		}

static void		static void
nvdimm_spa_g_start(struct bio *bp)		nvdimm_spa_g_start(struct bio *bp)
{		{
struct SPA_mapping *spa;		struct g_spa_softc *sc;

spa = bp->bio_to->geom->softc;		sc = bp->bio_to->geom->softc;
if (bp->bio_cmd == BIO_READ \|\| bp->bio_cmd == BIO_WRITE) {		if (bp->bio_cmd == BIO_READ \|\| bp->bio_cmd == BIO_WRITE) {
mtx_lock(&spa->spa_g_stat_mtx);		mtx_lock(&sc->spa_g_stat_mtx);
devstat_start_transaction_bio(spa->spa_g_devstat, bp);		devstat_start_transaction_bio(sc->spa_g_devstat, bp);
mtx_unlock(&spa->spa_g_stat_mtx);		mtx_unlock(&sc->spa_g_stat_mtx);
}		}
mtx_lock(&spa->spa_g_mtx);		mtx_lock(&sc->spa_g_mtx);
bioq_disksort(&spa->spa_g_queue, bp);		bioq_disksort(&sc->spa_g_queue, bp);
wakeup(&spa->spa_g_queue);		wakeup(&sc->spa_g_queue);
mtx_unlock(&spa->spa_g_mtx);		mtx_unlock(&sc->spa_g_mtx);
}		}

static int		static int
nvdimm_spa_g_access(struct g_provider *pp, int r, int w, int e)		nvdimm_spa_g_access(struct g_provider *pp, int r, int w, int e)
{		{

return (0);		return (0);
}		}

static g_init_t nvdimm_spa_g_init;		static g_ctl_destroy_geom_t nvdimm_spa_g_destroy_geom;
static g_fini_t nvdimm_spa_g_fini;

struct g_class nvdimm_spa_g_class = {		struct g_class nvdimm_spa_g_class = {
.name = "SPA",		.name = "SPA",
.version = G_VERSION,		.version = G_VERSION,
.start = nvdimm_spa_g_start,		.start = nvdimm_spa_g_start,
.access = nvdimm_spa_g_access,		.access = nvdimm_spa_g_access,
.init = nvdimm_spa_g_init,		.destroy_geom = nvdimm_spa_g_destroy_geom,
.fini = nvdimm_spa_g_fini,
};		};
DECLARE_GEOM_CLASS(nvdimm_spa_g_class, g_spa);		DECLARE_GEOM_CLASS(nvdimm_spa_g_class, g_spa);

static int		static int
nvdimm_spa_init_one(struct SPA_mapping spa, ACPI_NFIT_SYSTEM_ADDRESS nfitaddr,		nvdimm_spa_g_create(struct SPA_mapping *spa)
int spa_type)
{		{
		struct g_spa_softc *sc;
		int error;

		sc = malloc(sizeof(*sc), M_NVDIMM, M_WAITOK \| M_ZERO);
		sc->spa = spa;
		bioq_init(&sc->spa_g_queue);
		mtx_init(&sc->spa_g_mtx, "spag", NULL, MTX_DEF);
		mtx_init(&sc->spa_g_stat_mtx, "spagst", NULL, MTX_DEF);
		sc->spa_g_proc_run = true;
		sc->spa_g_proc_exiting = false;
		error = kproc_create(nvdimm_spa_g_thread, sc, &sc->spa_g_proc, 0, 0,
		"g_spa%d", spa->spa_nfit_idx);
		if (error != 0) {
		printf("NVDIMM SPA%d cannot create geom worker, error %d\n",
		spa->spa_nfit_idx, error);
		return (error);
		}
		g_topology_lock();
		spa->spa_g = g_new_geomf(&nvdimm_spa_g_class, "spa%d",
		spa->spa_nfit_idx);
		spa->spa_g->softc = sc;
		sc->spa_p = g_new_providerf(spa->spa_g, "spa%d", spa->spa_nfit_idx);
		sc->spa_p->mediasize = spa->spa_len;
		sc->spa_p->sectorsize = DEV_BSIZE;
		sc->spa_p->flags \|= G_PF_DIRECT_SEND \| G_PF_DIRECT_RECEIVE \|
		G_PF_ACCEPT_UNMAPPED;
		g_error_provider(sc->spa_p, 0);
		sc->spa_g_devstat = devstat_new_entry("spa", spa->spa_nfit_idx,
		DEV_BSIZE, DEVSTAT_ALL_SUPPORTED, DEVSTAT_TYPE_DIRECT,
		DEVSTAT_PRIORITY_MAX);
		g_topology_unlock();
		return (0);
		}

		static int nvdimm_spa_g_destroy_geom(struct gctl_req req, struct g_class cp,
		struct g_geom *gp)
		{
		struct g_spa_softc *sc;

		sc = gp->softc;
		mtx_lock(&sc->spa_g_mtx);
		sc->spa_g_proc_run = false;
		wakeup(&sc->spa_g_queue);
		while (!sc->spa_g_proc_exiting)
		msleep(&sc->spa_g_queue, &sc->spa_g_mtx, PRIBIO, "spa_e", 0);
		mtx_unlock(&sc->spa_g_mtx);
		g_topology_lock();
		g_wither_geom(gp, ENXIO);
		g_topology_unlock();
		sc->spa_p = NULL;
		if (sc->spa_g_devstat != NULL) {
		devstat_remove_entry(sc->spa_g_devstat);
		sc->spa_g_devstat = NULL;
		}
		sc->spa->spa_g = NULL;
		free(sc, M_NVDIMM);
		gp->softc = NULL;

		return (0);
		}

		static int
		nvdimm_spa_init_one(void nfitsubtbl, void arg)
		{
		struct SPA_mapping *spa;
		ACPI_NFIT_SYSTEM_ADDRESS *nfitaddr;
struct make_dev_args mda;		struct make_dev_args mda;
struct sglist *spa_sg;		struct sglist *spa_sg;
int error, error1;		int error, error1;

spa->spa_type = spa_type;		spa = arg;
		nfitaddr = nfitsubtbl;
		if (spa->spa_nfit_idx != nfitaddr->RangeIndex)
		return (0);

		spa->spa_type = spa_type_from_uuid((struct uuid *)&nfitaddr->RangeGuid);
spa->spa_domain = ((nfitaddr->Flags & ACPI_NFIT_PROXIMITY_VALID) != 0) ?		spa->spa_domain = ((nfitaddr->Flags & ACPI_NFIT_PROXIMITY_VALID) != 0) ?
nfitaddr->ProximityDomain : -1;		nfitaddr->ProximityDomain : -1;
spa->spa_nfit_idx = nfitaddr->RangeIndex;
spa->spa_phys_base = nfitaddr->Address;		spa->spa_phys_base = nfitaddr->Address;
spa->spa_len = nfitaddr->Length;		spa->spa_len = nfitaddr->Length;
spa->spa_efi_mem_flags = nfitaddr->MemoryMapping;		spa->spa_efi_mem_flags = nfitaddr->MemoryMapping;
if (bootverbose) {		if (bootverbose) {
printf("NVDIMM SPA%d base %#016jx len %#016jx %s fl %#jx\n",		printf("NVDIMM SPA%d base %#016jx len %#016jx %s fl %#jx\n",
spa->spa_nfit_idx,		spa->spa_nfit_idx,
(uintmax_t)spa->spa_phys_base, (uintmax_t)spa->spa_len,		(uintmax_t)spa->spa_phys_base, (uintmax_t)spa->spa_len,
nvdimm_SPA_uuid_list[spa_type].u_name,		nvdimm_SPA_uuid_list[spa->spa_type].u_name,
spa->spa_efi_mem_flags);		spa->spa_efi_mem_flags);
}		}
if (!nvdimm_SPA_uuid_list[spa_type].u_usr_acc)
return (0);

error1 = pmap_large_map(spa->spa_phys_base, spa->spa_len,		error1 = pmap_large_map(spa->spa_phys_base, spa->spa_len,
&spa->spa_kva, nvdimm_spa_memattr(spa));		&spa->spa_kva, nvdimm_spa_memattr(spa));
if (error1 != 0) {		if (error1 != 0) {
printf("NVDIMM SPA%d cannot map into KVA, error %d\n",		printf("NVDIMM SPA%d cannot map into KVA, error %d\n",
spa->spa_nfit_idx, error1);		spa->spa_nfit_idx, error1);
spa->spa_kva = NULL;		spa->spa_kva = NULL;
}		}
Show All 27 Lines	error = make_dev_s(&mda, &spa->spa_dev, "nvdimm_spa%d",
spa->spa_nfit_idx);		spa->spa_nfit_idx);
if (error != 0) {		if (error != 0) {
printf("NVDIMM SPA%d cannot create devfs node, error %d\n",		printf("NVDIMM SPA%d cannot create devfs node, error %d\n",
spa->spa_nfit_idx, error);		spa->spa_nfit_idx, error);
if (error1 == 0)		if (error1 == 0)
error1 = error;		error1 = error;
}		}

bioq_init(&spa->spa_g_queue);		error = nvdimm_spa_g_create(spa);
mtx_init(&spa->spa_g_mtx, "spag", NULL, MTX_DEF);		if (error1 != 0)
mtx_init(&spa->spa_g_stat_mtx, "spagst", NULL, MTX_DEF);
spa->spa_g_proc_run = true;
spa->spa_g_proc_exiting = false;
error = kproc_create(nvdimm_spa_g_thread, spa, &spa->spa_g_proc, 0, 0,
"g_spa%d", spa->spa_nfit_idx);
if (error != 0) {
printf("NVDIMM SPA%d cannot create geom worker, error %d\n",
spa->spa_nfit_idx, error);
if (error1 == 0)
error1 = error;		error1 = error;
} else {
g_topology_assert();
spa->spa_g = g_new_geomf(&nvdimm_spa_g_class, "spa%d",
spa->spa_nfit_idx);
spa->spa_g->softc = spa;
spa->spa_p = g_new_providerf(spa->spa_g, "spa%d",
spa->spa_nfit_idx);
spa->spa_p->mediasize = spa->spa_len;
spa->spa_p->sectorsize = DEV_BSIZE;
spa->spa_p->flags \|= G_PF_DIRECT_SEND \| G_PF_DIRECT_RECEIVE \|
G_PF_ACCEPT_UNMAPPED;
g_error_provider(spa->spa_p, 0);
spa->spa_g_devstat = devstat_new_entry("spa", spa->spa_nfit_idx,
DEV_BSIZE, DEVSTAT_ALL_SUPPORTED, DEVSTAT_TYPE_DIRECT,
DEVSTAT_PRIORITY_MAX);
}
return (error1);		return (error1);
}		}

static void		static void
nvdimm_spa_fini_one(struct SPA_mapping *spa)		nvdimm_spa_fini_one(struct SPA_mapping *spa)
{		{

mtx_lock(&spa->spa_g_mtx);		if (spa->spa_g != NULL)
spa->spa_g_proc_run = false;		nvdimm_spa_g_destroy_geom(NULL, spa->spa_g->class, spa->spa_g);
wakeup(&spa->spa_g_queue);
while (!spa->spa_g_proc_exiting)
msleep(&spa->spa_g_queue, &spa->spa_g_mtx, PRIBIO, "spa_e", 0);
mtx_unlock(&spa->spa_g_mtx);
if (spa->spa_g != NULL) {
g_topology_lock();
g_wither_geom(spa->spa_g, ENXIO);
g_topology_unlock();
spa->spa_g = NULL;
spa->spa_p = NULL;
}
if (spa->spa_g_devstat != NULL) {
devstat_remove_entry(spa->spa_g_devstat);
spa->spa_g_devstat = NULL;
}
if (spa->spa_dev != NULL) {		if (spa->spa_dev != NULL) {
destroy_dev(spa->spa_dev);		destroy_dev(spa->spa_dev);
spa->spa_dev = NULL;		spa->spa_dev = NULL;
}		}
vm_object_deallocate(spa->spa_obj);		vm_object_deallocate(spa->spa_obj);
if (spa->spa_kva != NULL) {		if (spa->spa_kva != NULL) {
pmap_large_unmap(spa->spa_kva, spa->spa_len);		pmap_large_unmap(spa->spa_kva, spa->spa_len);
spa->spa_kva = NULL;		spa->spa_kva = NULL;
}		}
mtx_destroy(&spa->spa_g_mtx);
mtx_destroy(&spa->spa_g_stat_mtx);
}		}

static int		static int
nvdimm_spa_parse(void nfitsubtbl, void arg)		nvdimm_spa_create_dev(void nfitsubtbl, void arg)
{		{
ACPI_NFIT_SYSTEM_ADDRESS *nfitaddr;		ACPI_NFIT_SYSTEM_ADDRESS *nfitaddr;
struct SPA_mapping *spa;		device_t child;
int error, *i, j;		int i;

i = arg;
spa = &spa_mappings[*i];
nfitaddr = nfitsubtbl;		nfitaddr = nfitsubtbl;
		i = spa_type_from_uuid((struct uuid *)&nfitaddr->RangeGuid);
		if (i == SPA_TYPE_UNKNOWN \|\| !nvdimm_SPA_uuid_list[i].u_usr_acc)
		return (0);
		child = device_find_child(arg, "nvdimm_spa", nfitaddr->RangeIndex);
		if (child == NULL)
		BUS_ADD_CHILD(arg, 1, "nvdimm_spa", nfitaddr->RangeIndex);
		return (0);
		}

for (j = 0; j < nitems(nvdimm_SPA_uuid_list); j++) {		static void
/* XXXKIB: is ACPI UUID representation compatible ? */		nvdimm_spa_identify(driver_t *driver, device_t parent)
if (uuidcmp((struct uuid *)&nfitaddr->RangeGuid,		{
&nvdimm_SPA_uuid_list[j].u_id) != 0)		ACPI_TABLE_NFIT *nfitbl;
continue;		ACPI_STATUS status;
error = nvdimm_spa_init_one(spa, nfitaddr, j);
		if (acpi_disabled("nvdimm"))
		return;
		status = AcpiGetTable(ACPI_SIG_NFIT, 1, (ACPI_TABLE_HEADER **)&nfitbl);
		if (ACPI_FAILURE(status))
		return;
		nvdimm_iterate_nfit(nfitbl, ACPI_NFIT_TYPE_SYSTEM_ADDRESS,
		nvdimm_spa_create_dev, parent);
		AcpiPutTable(&nfitbl->Header);
		}

		static int
		nvdimm_spa_probe(device_t dev)
		{

		return (BUS_PROBE_NOWILDCARD);
		}

		static int
		nvdimm_spa_attach(device_t dev)
		{
		struct SPA_mapping *spa;
		ACPI_TABLE_NFIT *nfitbl;
		ACPI_STATUS status;
		int error;

		spa = device_get_softc(dev);
		status = AcpiGetTable(ACPI_SIG_NFIT, 1, (ACPI_TABLE_HEADER **)&nfitbl);
		if (ACPI_FAILURE(status))
		return (ENXIO);
		spa->spa_nfit_idx = device_get_unit(dev);
		error = nvdimm_iterate_nfit(nfitbl, ACPI_NFIT_TYPE_SYSTEM_ADDRESS,
		nvdimm_spa_init_one, spa);
		AcpiPutTable(&nfitbl->Header);
if (error != 0)		if (error != 0)
nvdimm_spa_fini_one(spa);		nvdimm_spa_fini_one(spa);
break;		return (error);
}		}
if (j == nitems(nvdimm_SPA_uuid_list) && bootverbose) {
printf("Unknown SPA UUID %d ", nfitaddr->RangeIndex);		static int
printf_uuid((struct uuid *)&nfitaddr->RangeGuid);		nvdimm_spa_detach(device_t dev)
printf("\n");		{
}		struct SPA_mapping *spa;
(*i)++;
		spa = device_get_softc(dev);
		nvdimm_spa_fini_one(spa);
return (0);		return (0);
}		}

static int		static int
nvdimm_spa_init1(ACPI_TABLE_NFIT *nfitbl)		nvdimm_spa_init(void)
{		{
struct nvdimm_SPA_uuid_list_elm *sle;		struct nvdimm_SPA_uuid_list_elm *sle;
int error, i;		int error, i;

for (i = 0; i < nitems(nvdimm_SPA_uuid_list); i++) {		for (i = 0; i < nitems(nvdimm_SPA_uuid_list); i++) {
sle = &nvdimm_SPA_uuid_list[i];		sle = &nvdimm_SPA_uuid_list[i];
error = parse_uuid(sle->u_id_str, &sle->u_id);		error = parse_uuid(sle->u_id_str, &sle->u_id);
if (error != 0) {		if (error != 0) {
if (bootverbose)		if (bootverbose)
printf("nvdimm_identify: error %d parsing "		printf("nvdimm_spa_init: error %d parsing "
"known SPA UUID %d %s\n", error, i,		"known SPA UUID %d %s\n", error, i,
sle->u_id_str);		sle->u_id_str);
return (error);		return (error);
}		}
}		}

error = nvdimm_iterate_nfit(nfitbl, ACPI_NFIT_TYPE_SYSTEM_ADDRESS,
nvdimm_spa_count, &spa_mappings_cnt);
if (error != 0)
return (error);
spa_mappings = malloc(sizeof(struct SPA_mapping) * spa_mappings_cnt,
M_NVDIMM, M_WAITOK \| M_ZERO);
i = 0;
error = nvdimm_iterate_nfit(nfitbl, ACPI_NFIT_TYPE_SYSTEM_ADDRESS,
nvdimm_spa_parse, &i);
if (error != 0) {
free(spa_mappings, M_NVDIMM);
spa_mappings = NULL;
return (error);
}
return (0);		return (0);
}		}

static void		static int
nvdimm_spa_g_init(struct g_class *mp __unused)		nvdimm_spa_modev(struct module mod, int what, void arg)
{		{
ACPI_TABLE_NFIT *nfitbl;
ACPI_STATUS status;
int error;		int error;

spa_mappings_cnt = 0;		switch (what) {
spa_mappings = NULL;		case MOD_LOAD:
if (acpi_disabled("nvdimm"))		error = nvdimm_spa_init();
return;		break;
status = AcpiGetTable(ACPI_SIG_NFIT, 1, (ACPI_TABLE_HEADER **)&nfitbl);
if (ACPI_FAILURE(status)) {		case MOD_UNLOAD:
if (bootverbose)		case MOD_QUIESCE:
printf("nvdimm_spa_g_init: cannot find NFIT\n");		error = 0;
return;		break;

		default:
		error = EOPNOTSUPP;
		break;
}		}
error = nvdimm_spa_init1(nfitbl);
if (error != 0)		return (error);
printf("nvdimm_spa_g_init: error %d\n", error);
AcpiPutTable(&nfitbl->Header);
}		}

static void		static device_method_t nvdimm_spa_methods[] = {
nvdimm_spa_g_fini(struct g_class *mp __unused)		DEVMETHOD(device_identify, nvdimm_spa_identify),
{		DEVMETHOD(device_probe, nvdimm_spa_probe),
int i;		DEVMETHOD(device_attach, nvdimm_spa_attach),
		DEVMETHOD(device_detach, nvdimm_spa_detach),
		DEVMETHOD_END
		};

if (spa_mappings == NULL)		static driver_t nvdimm_spa_driver = {
return;		"nvdimm_spa",
for (i = 0; i < spa_mappings_cnt; i++)		nvdimm_spa_methods,
nvdimm_spa_fini_one(&spa_mappings[i]);		sizeof(struct SPA_mapping),
free(spa_mappings, M_NVDIMM);		};
spa_mappings = NULL;
spa_mappings_cnt = 0;		static devclass_t nvdimm_spa_devclass;
}		DRIVER_MODULE(nvdimm_spa, acpi, nvdimm_spa_driver, nvdimm_spa_devclass,
		nvdimm_spa_modev, 0);
		MODULE_DEPEND(nvdimm_spa, acpi, 1, 1, 1);