xref: /freebsd/sys/dev/vmgenc/vmgenc_acpi.c (revision edf8578117e8844e02c0121147f45e4609b30680)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2019 Conrad Meyer <cem@FreeBSD.org>.  All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27 
28 /*
29  * VM Generation Counter driver
30  *
31  * See, e.g., the "Virtual Machine Generation ID" white paper:
32  * https://go.microsoft.com/fwlink/p/?LinkID=260709 , and perhaps also:
33  * https://docs.microsoft.com/en-us/windows/win32/hyperv_v2/virtual-machine-generation-identifier ,
34  * https://azure.microsoft.com/en-us/blog/accessing-and-using-azure-vm-unique-id/
35  *
36  * Microsoft introduced the concept in 2013 or so and seems to have
37  * successfully driven it to a consensus standard among hypervisors, not just
38  * HyperV/Azure:
39  * - QEMU: https://bugzilla.redhat.com/show_bug.cgi?id=1118834
40  * - VMware/ESXi: https://kb.vmware.com/s/article/2032586
41  * - Xen: https://github.com/xenserver/xen-4.5/blob/master/tools/firmware/hvmloader/acpi/dsdt.asl#L456
42  */
43 
44 #include <sys/cdefs.h>
45 #include <sys/param.h>
46 #include <sys/bus.h>
47 #include <sys/eventhandler.h>
48 #include <sys/kernel.h>
49 #include <sys/lock.h>
50 #include <sys/malloc.h>
51 #include <sys/module.h>
52 #include <sys/mutex.h>
53 #include <sys/random.h>
54 #include <sys/sysctl.h>
55 #include <sys/systm.h>
56 
57 #include <contrib/dev/acpica/include/acpi.h>
58 
59 #include <dev/acpica/acpivar.h>
60 #include <dev/random/random_harvestq.h>
61 #include <dev/vmgenc/vmgenc_acpi.h>
62 
63 #ifndef	ACPI_NOTIFY_STATUS_CHANGED
64 #define	ACPI_NOTIFY_STATUS_CHANGED	0x80
65 #endif
66 
67 #define	GUID_BYTES	16
68 
69 static const char *vmgenc_ids[] = {
70 	"VM_GEN_COUNTER",
71 	NULL
72 };
73 #if 0
74 MODULE_PNP_INFO("Z:_CID", acpi, vmgenc, vmgenc_ids, nitems(vmgenc_ids) - 1);
75 #endif
76 
77 struct vmgenc_softc {
78 	volatile void	*vmg_pguid;
79 	uint8_t		vmg_cache_guid[GUID_BYTES];
80 };
81 
82 static void
83 vmgenc_harvest_all(const void *p, size_t sz)
84 {
85 	size_t nbytes;
86 
87 	while (sz > 0) {
88 		nbytes = MIN(sz,
89 		    sizeof(((struct harvest_event *)0)->he_entropy));
90 		random_harvest_direct(p, nbytes, RANDOM_PURE_VMGENID);
91 		p = (const char *)p + nbytes;
92 		sz -= nbytes;
93 	}
94 }
95 
96 static void
97 vmgenc_status_changed(void *context)
98 {
99 	uint8_t guid[GUID_BYTES];
100 	struct vmgenc_softc *sc;
101 	device_t dev;
102 
103 	dev = context;
104 	sc = device_get_softc(dev);
105 
106 	/* Check for spurious notify events. */
107 	memcpy(guid, __DEVOLATILE(void *, sc->vmg_pguid), sizeof(guid));
108 	if (memcmp(guid, sc->vmg_cache_guid, GUID_BYTES) == 0)
109 		return; /* No change. */
110 
111 	/* Update cache. */
112 	memcpy(sc->vmg_cache_guid, guid, GUID_BYTES);
113 
114 	vmgenc_harvest_all(sc->vmg_cache_guid, sizeof(sc->vmg_cache_guid));
115 
116 	EVENTHANDLER_INVOKE(acpi_vmgenc_event);
117 	acpi_UserNotify("VMGenerationCounter", acpi_get_handle(dev), 0);
118 }
119 
120 static void
121 vmgenc_notify(ACPI_HANDLE h, UINT32 notify, void *context)
122 {
123 	device_t dev;
124 
125 	dev = context;
126 	switch (notify) {
127 	case ACPI_NOTIFY_STATUS_CHANGED:
128 		/*
129 		 * We're possibly in GPE / interrupt context, kick the event up
130 		 * to a taskqueue.
131 		 */
132 		AcpiOsExecute(OSL_NOTIFY_HANDLER, vmgenc_status_changed, dev);
133 		break;
134 	default:
135 		device_printf(dev, "unknown notify %#x\n", notify);
136 		break;
137 	}
138 }
139 
140 static int
141 vmgenc_probe(device_t dev)
142 {
143 	int rv;
144 
145 	if (acpi_disabled("vmgenc"))
146 		return (ENXIO);
147 	rv = ACPI_ID_PROBE(device_get_parent(dev), dev,
148 	    __DECONST(char **, vmgenc_ids), NULL);
149 	if (rv <= 0)
150 		device_set_desc(dev, "VM Generation Counter");
151 	return (rv);
152 }
153 
154 static const char *
155 vmgenc_acpi_getname(ACPI_HANDLE handle, char data[static 256])
156 {
157     ACPI_BUFFER buf;
158 
159     buf.Length = 256;
160     buf.Pointer = data;
161 
162     if (ACPI_SUCCESS(AcpiGetName(handle, ACPI_FULL_PATHNAME, &buf)))
163 	return (data);
164     return ("(unknown)");
165 }
166 
167 static int
168 acpi_GetPackedUINT64(device_t dev, ACPI_HANDLE handle, char *path,
169     uint64_t *out)
170 {
171 	char hpath[256];
172 	ACPI_STATUS status;
173 	ACPI_BUFFER buf;
174 	ACPI_OBJECT param[3];
175 
176 	buf.Pointer = param;
177 	buf.Length = sizeof(param);
178 	status = AcpiEvaluateObject(handle, path, NULL, &buf);
179 	if (!ACPI_SUCCESS(status)) {
180 		device_printf(dev, "%s(%s::%s()): %s\n", __func__,
181 		    vmgenc_acpi_getname(handle, hpath), path,
182 		    AcpiFormatException(status));
183 		return (ENXIO);
184 	}
185 	if (param[0].Type != ACPI_TYPE_PACKAGE) {
186 		device_printf(dev, "%s(%s::%s()): Wrong type %#x\n", __func__,
187 		    vmgenc_acpi_getname(handle, hpath), path,
188 		    param[0].Type);
189 		return (ENXIO);
190 	}
191 	if (param[0].Package.Count != 2) {
192 		device_printf(dev, "%s(%s::%s()): Wrong number of results %u\n",
193 		    __func__, vmgenc_acpi_getname(handle, hpath), path,
194 		    param[0].Package.Count);
195 		return (ENXIO);
196 	}
197 	if (param[0].Package.Elements[0].Type != ACPI_TYPE_INTEGER ||
198 	    param[0].Package.Elements[1].Type != ACPI_TYPE_INTEGER) {
199 		device_printf(dev, "%s(%s::%s()): Wrong type results %#x, %#x\n",
200 		    __func__, vmgenc_acpi_getname(handle, hpath), path,
201 		    param[0].Package.Elements[0].Type,
202 		    param[0].Package.Elements[1].Type);
203 		return (ENXIO);
204 	}
205 
206 	*out = (param[0].Package.Elements[0].Integer.Value & UINT32_MAX) |
207 	    ((uint64_t)param[0].Package.Elements[1].Integer.Value << 32);
208 	if (*out == 0)
209 		return (ENXIO);
210 	return (0);
211 
212 }
213 
214 static int
215 vmgenc_attach(device_t dev)
216 {
217 	struct vmgenc_softc *sc;
218 	uint64_t guid_physaddr;
219 	ACPI_HANDLE h;
220 	int error;
221 
222 	h = acpi_get_handle(dev);
223 	sc = device_get_softc(dev);
224 
225 	error = acpi_GetPackedUINT64(dev, h, "ADDR", &guid_physaddr);
226 	if (error != 0)
227 		return (error);
228 
229 	SYSCTL_ADD_OPAQUE(device_get_sysctl_ctx(dev),
230 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "guid",
231 	    CTLFLAG_RD, sc->vmg_cache_guid, GUID_BYTES, "",
232 	    "latest cached VM generation counter (128-bit UUID)");
233 
234 	sc->vmg_pguid = AcpiOsMapMemory(guid_physaddr, GUID_BYTES);
235 	memcpy(sc->vmg_cache_guid, __DEVOLATILE(void *, sc->vmg_pguid),
236 	    sizeof(sc->vmg_cache_guid));
237 
238 	random_harvest_register_source(RANDOM_PURE_VMGENID);
239 	vmgenc_harvest_all(sc->vmg_cache_guid, sizeof(sc->vmg_cache_guid));
240 
241 	AcpiInstallNotifyHandler(h, ACPI_DEVICE_NOTIFY, vmgenc_notify, dev);
242 	return (0);
243 }
244 
245 static device_method_t vmgenc_methods[] = {
246 	DEVMETHOD(device_probe,		vmgenc_probe),
247 	DEVMETHOD(device_attach,	vmgenc_attach),
248 	DEVMETHOD_END
249 };
250 
251 static driver_t vmgenc_driver = {
252 	"vmgenc",
253 	vmgenc_methods,
254 	sizeof(struct vmgenc_softc),
255 };
256 
257 DRIVER_MODULE(vmgenc, acpi, vmgenc_driver, NULL, NULL);
258 MODULE_DEPEND(vmgenc, acpi, 1, 1, 1);
259 MODULE_DEPEND(vemgenc, random_harvestq, 1, 1, 1);
260