1/*-
2 * Copyright (c) 2013 The FreeBSD Foundation
3 * All rights reserved.
4 *
5 * This software was developed by Benno Rice under sponsorship from
6 * the FreeBSD Foundation.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: stable/11/stand/efi/loader/copy.c 346483 2019-04-21 04:35:49Z kevans $");
31
32#include <sys/param.h>
33
34#include <stand.h>
35#include <bootstrap.h>
36
37#include <efi.h>
38#include <efilib.h>
39
40#include "loader_efi.h"
41
42#if defined(__i386__) || defined(__amd64__)
43#include <machine/cpufunc.h>
44#include <machine/specialreg.h>
45
46/*
47 * The code is excerpted from sys/x86/x86/identcpu.c: identify_cpu(),
48 * identify_hypervisor(), and dev/hyperv/vmbus/hyperv.c: hyperv_identify().
49 */
50#define CPUID_LEAF_HV_MAXLEAF		0x40000000
51#define CPUID_LEAF_HV_INTERFACE		0x40000001
52#define CPUID_LEAF_HV_FEATURES		0x40000003
53#define CPUID_LEAF_HV_LIMITS		0x40000005
54#define CPUID_HV_IFACE_HYPERV		0x31237648	/* HV#1 */
55#define CPUID_HV_MSR_TIME_REFCNT	0x0002	/* MSR_HV_TIME_REF_COUNT */
56#define CPUID_HV_MSR_HYPERCALL		0x0020
57
58static int
59running_on_hyperv(void)
60{
61	char hv_vendor[16];
62	uint32_t regs[4];
63
64	do_cpuid(1, regs);
65	if ((regs[2] & CPUID2_HV) == 0)
66		return (0);
67
68	do_cpuid(CPUID_LEAF_HV_MAXLEAF, regs);
69	if (regs[0] < CPUID_LEAF_HV_LIMITS)
70		return (0);
71
72	((uint32_t *)&hv_vendor)[0] = regs[1];
73	((uint32_t *)&hv_vendor)[1] = regs[2];
74	((uint32_t *)&hv_vendor)[2] = regs[3];
75	hv_vendor[12] = '\0';
76	if (strcmp(hv_vendor, "Microsoft Hv") != 0)
77		return (0);
78
79	do_cpuid(CPUID_LEAF_HV_INTERFACE, regs);
80	if (regs[0] != CPUID_HV_IFACE_HYPERV)
81		return (0);
82
83	do_cpuid(CPUID_LEAF_HV_FEATURES, regs);
84	if ((regs[0] & CPUID_HV_MSR_HYPERCALL) == 0)
85		return (0);
86	if ((regs[0] & CPUID_HV_MSR_TIME_REFCNT) == 0)
87		return (0);
88
89	return (1);
90}
91
92#define KERNEL_PHYSICAL_BASE (2*1024*1024)
93
94static void
95efi_verify_staging_size(unsigned long *nr_pages)
96{
97	UINTN sz;
98	EFI_MEMORY_DESCRIPTOR *map = NULL, *p;
99	EFI_PHYSICAL_ADDRESS start, end;
100	UINTN key, dsz;
101	UINT32 dver;
102	EFI_STATUS status;
103	int i, ndesc;
104	unsigned long available_pages = 0;
105
106	sz = 0;
107
108	for (;;) {
109		status = BS->GetMemoryMap(&sz, map, &key, &dsz, &dver);
110		if (!EFI_ERROR(status))
111			break;
112
113		if (status != EFI_BUFFER_TOO_SMALL) {
114			printf("Can't read memory map: %lu\n",
115			    EFI_ERROR_CODE(status));
116			goto out;
117		}
118
119		free(map);
120
121		/* Allocate 10 descriptors more than the size reported,
122		 * to allow for any fragmentation caused by calling
123		 * malloc */
124		map = malloc(sz + (10 * dsz));
125		if (map == NULL) {
126			printf("Unable to allocate memory\n");
127			goto out;
128		}
129	}
130
131	ndesc = sz / dsz;
132	for (i = 0, p = map; i < ndesc;
133	     i++, p = NextMemoryDescriptor(p, dsz)) {
134		start = p->PhysicalStart;
135		end = start + p->NumberOfPages * EFI_PAGE_SIZE;
136
137		if (KERNEL_PHYSICAL_BASE < start ||
138		    KERNEL_PHYSICAL_BASE >= end)
139			continue;
140
141		available_pages = p->NumberOfPages -
142			((KERNEL_PHYSICAL_BASE - start) >> EFI_PAGE_SHIFT);
143		break;
144	}
145
146	if (available_pages == 0) {
147		printf("Can't find valid memory map for staging area!\n");
148		goto out;
149	}
150
151	i++;
152	p = NextMemoryDescriptor(p, dsz);
153
154	for ( ; i < ndesc;
155	     i++, p = NextMemoryDescriptor(p, dsz)) {
156		if (p->Type != EfiConventionalMemory &&
157		    p->Type != EfiLoaderData)
158			break;
159
160		if (p->PhysicalStart != end)
161			break;
162
163		end = p->PhysicalStart + p->NumberOfPages * EFI_PAGE_SIZE;
164
165		available_pages += p->NumberOfPages;
166	}
167
168	if (*nr_pages > available_pages) {
169		printf("Staging area's size is reduced: %ld -> %ld!\n",
170		    *nr_pages, available_pages);
171		*nr_pages = available_pages;
172	}
173out:
174	free(map);
175}
176#endif /* __i386__ || __amd64__ */
177
178#ifndef EFI_STAGING_SIZE
179#define	EFI_STAGING_SIZE	64
180#endif
181
182EFI_PHYSICAL_ADDRESS	staging, staging_end;
183int			stage_offset_set = 0;
184ssize_t			stage_offset;
185
186int
187efi_copy_init(void)
188{
189	EFI_STATUS	status;
190
191	unsigned long nr_pages;
192
193	nr_pages = EFI_SIZE_TO_PAGES((EFI_STAGING_SIZE) * 1024 * 1024);
194
195#if defined(__i386__) || defined(__amd64__)
196	/*
197	 * We'll decrease nr_pages, if it's too big. Currently we only
198	 * apply this to FreeBSD VM running on Hyper-V. Why? Please see
199	 * https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=211746#c28
200	 */
201	if (running_on_hyperv())
202		efi_verify_staging_size(&nr_pages);
203
204	/*
205	 * The staging area must reside in the the first 1GB physical
206	 * memory: see elf64_exec() in
207	 * boot/efi/loader/arch/amd64/elf64_freebsd.c.
208	 */
209	staging = 1024*1024*1024;
210	status = BS->AllocatePages(AllocateMaxAddress, EfiLoaderData,
211	    nr_pages, &staging);
212#else
213	status = BS->AllocatePages(AllocateAnyPages, EfiLoaderData,
214	    nr_pages, &staging);
215#endif
216	if (EFI_ERROR(status)) {
217		printf("failed to allocate staging area: %lu\n",
218		    EFI_ERROR_CODE(status));
219		return (status);
220	}
221	staging_end = staging + nr_pages * EFI_PAGE_SIZE;
222
223#if defined(__aarch64__) || defined(__arm__)
224	/*
225	 * Round the kernel load address to a 2MiB value. This is needed
226	 * because the kernel builds a page table based on where it has
227	 * been loaded in physical address space. As the kernel will use
228	 * either a 1MiB or 2MiB page for this we need to make sure it
229	 * is correctly aligned for both cases.
230	 */
231	staging = roundup2(staging, 2 * 1024 * 1024);
232#endif
233
234	return (0);
235}
236
237void *
238efi_translate(vm_offset_t ptr)
239{
240
241	return ((void *)(ptr + stage_offset));
242}
243
244ssize_t
245efi_copyin(const void *src, vm_offset_t dest, const size_t len)
246{
247
248	if (!stage_offset_set) {
249		stage_offset = (vm_offset_t)staging - dest;
250		stage_offset_set = 1;
251	}
252
253	/* XXX: Callers do not check for failure. */
254	if (dest + stage_offset + len > staging_end) {
255		errno = ENOMEM;
256		return (-1);
257	}
258	bcopy(src, (void *)(dest + stage_offset), len);
259	return (len);
260}
261
262ssize_t
263efi_copyout(const vm_offset_t src, void *dest, const size_t len)
264{
265
266	/* XXX: Callers do not check for failure. */
267	if (src + stage_offset + len > staging_end) {
268		errno = ENOMEM;
269		return (-1);
270	}
271	bcopy((void *)(src + stage_offset), dest, len);
272	return (len);
273}
274
275
276ssize_t
277efi_readin(const int fd, vm_offset_t dest, const size_t len)
278{
279
280	if (dest + stage_offset + len > staging_end) {
281		errno = ENOMEM;
282		return (-1);
283	}
284	return (read(fd, (void *)(dest + stage_offset), len));
285}
286
287void
288efi_copy_finish(void)
289{
290	uint64_t	*src, *dst, *last;
291
292	src = (uint64_t *)(uintptr_t)staging;
293	dst = (uint64_t *)(uintptr_t)(staging - stage_offset);
294	last = (uint64_t *)(uintptr_t)staging_end;
295
296	while (src < last)
297		*dst++ = *src++;
298}
299