blob: 254d7877f6bfec3f71ab8215081f0aad5a399650 [file] [log] [blame]
Angel Pons118a9c72020-04-02 23:48:34 +02001/* SPDX-License-Identifier: GPL-2.0-only */
Aaron Durbin0424c952015-03-28 23:56:22 -05002
3#include <boot_device.h>
Julius Wernercefe89e2019-11-06 19:29:44 -08004#include <cbmem.h>
Aaron Durbin0424c952015-03-28 23:56:22 -05005#include <console/console.h>
6#include <fmap.h>
Julius Wernerfdabf3f2020-05-06 17:06:35 -07007#include <metadata_hash.h>
Aaron Durbin0424c952015-03-28 23:56:22 -05008#include <stddef.h>
9#include <string.h>
Julius Wernercefe89e2019-11-06 19:29:44 -080010#include <symbols.h>
Aaron Durbin0424c952015-03-28 23:56:22 -050011
Aaron Durbinbf1e4812016-05-10 15:12:08 -050012#include "fmap_config.h"
13
Aaron Durbin0424c952015-03-28 23:56:22 -050014/*
15 * See http://code.google.com/p/flashmap/ for more information on FMAP.
16 */
17
Arthur Heymansdba22d22019-11-20 19:57:49 +010018static int fmap_print_once;
Julius Wernerc8931972021-04-16 16:48:32 -070019static struct region_device fmap_cache;
Duncan Lauriebc2c0a32016-02-09 09:17:56 -080020
Julius Wernercefe89e2019-11-06 19:29:44 -080021#define print_once(...) do { \
Arthur Heymansdba22d22019-11-20 19:57:49 +010022 if (!fmap_print_once) \
Julius Wernercefe89e2019-11-06 19:29:44 -080023 printk(__VA_ARGS__); \
24 } while (0)
25
Furquan Shaikhb33a2b02019-09-26 23:51:46 -070026uint64_t get_fmap_flash_offset(void)
27{
28 return FMAP_OFFSET;
29}
30
Julius Wernerfdabf3f2020-05-06 17:06:35 -070031static int verify_fmap(const struct fmap *fmap)
Julius Wernercefe89e2019-11-06 19:29:44 -080032{
Julius Wernerfdabf3f2020-05-06 17:06:35 -070033 if (memcmp(fmap->signature, FMAP_SIGNATURE, sizeof(fmap->signature)))
34 return -1;
35
36 static bool done = false;
37 if (!CONFIG(CBFS_VERIFICATION) || !ENV_INITIAL_STAGE || done)
38 return 0; /* Only need to check hash in first stage. */
39
40 if (metadata_hash_verify_fmap(fmap, FMAP_SIZE) != VB2_SUCCESS)
41 return -1;
42
43 done = true;
44 return 0;
Julius Wernercefe89e2019-11-06 19:29:44 -080045}
46
47static void report(const struct fmap *fmap)
48{
49 print_once(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %#x.\n",
50 fmap->name, fmap->ver_major, fmap->ver_minor, FMAP_OFFSET);
51 print_once(BIOS_DEBUG, "FMAP: base = %#llx size = %#x #areas = %d\n",
52 (long long)fmap->base, fmap->size, fmap->nareas);
Arthur Heymansdba22d22019-11-20 19:57:49 +010053 fmap_print_once = 1;
Julius Wernercefe89e2019-11-06 19:29:44 -080054}
55
Julius Wernerc8931972021-04-16 16:48:32 -070056static void setup_preram_cache(struct region_device *cache_rdev)
Julius Wernercefe89e2019-11-06 19:29:44 -080057{
Julius Werner7fc92862019-11-18 13:01:06 -080058 if (CONFIG(NO_FMAP_CACHE))
59 return;
60
Josie Nordrumc3cc1582020-09-09 12:57:13 -060061 /* No need to use FMAP cache in SMM */
62 if (ENV_SMM)
63 return;
64
Julius Wernercefe89e2019-11-06 19:29:44 -080065 if (!ENV_ROMSTAGE_OR_BEFORE) {
66 /* We get here if ramstage makes an FMAP access before calling
67 cbmem_initialize(). We should avoid letting it come to that,
68 so print a warning. */
69 print_once(BIOS_WARNING,
70 "WARNING: Post-RAM FMAP access too early for cache!\n");
71 return;
72 }
73
Julius Wernercefe89e2019-11-06 19:29:44 -080074 struct fmap *fmap = (struct fmap *)_fmap_cache;
Martin Roth1594e8f2020-07-15 13:57:54 -060075 if (!(ENV_INITIAL_STAGE)) {
76 /* NOTE: This assumes that the first stage will make
Julius Wernercefe89e2019-11-06 19:29:44 -080077 at least one FMAP access (usually from finding CBFS). */
Julius Wernerfdabf3f2020-05-06 17:06:35 -070078 if (!verify_fmap(fmap))
Julius Wernercefe89e2019-11-06 19:29:44 -080079 goto register_cache;
80
81 printk(BIOS_ERR, "ERROR: FMAP cache corrupted?!\n");
Julius Wernerfdabf3f2020-05-06 17:06:35 -070082 if (CONFIG(TOCTOU_SAFETY))
83 die("TOCTOU safety relies on FMAP cache");
Julius Wernercefe89e2019-11-06 19:29:44 -080084 }
85
86 /* In case we fail below, make sure the cache is invalid. */
87 memset(fmap->signature, 0, sizeof(fmap->signature));
88
89 boot_device_init();
90 const struct region_device *boot_rdev = boot_device_ro();
91 if (!boot_rdev)
92 return;
93
94 /* memlayout statically guarantees that the FMAP_CACHE is big enough. */
95 if (rdev_readat(boot_rdev, fmap, FMAP_OFFSET, FMAP_SIZE) != FMAP_SIZE)
96 return;
Julius Wernerfdabf3f2020-05-06 17:06:35 -070097 if (verify_fmap(fmap))
Julius Wernercefe89e2019-11-06 19:29:44 -080098 return;
99 report(fmap);
100
101register_cache:
Julius Wernerc8931972021-04-16 16:48:32 -0700102 rdev_chain_mem(cache_rdev, fmap, FMAP_SIZE);
Julius Wernercefe89e2019-11-06 19:29:44 -0800103}
104
Furquan Shaikhb33a2b02019-09-26 23:51:46 -0700105static int find_fmap_directory(struct region_device *fmrd)
Aaron Durbin0424c952015-03-28 23:56:22 -0500106{
107 const struct region_device *boot;
108 struct fmap *fmap;
Aaron Durbinbf1e4812016-05-10 15:12:08 -0500109 size_t offset = FMAP_OFFSET;
Aaron Durbin0424c952015-03-28 23:56:22 -0500110
Julius Wernercefe89e2019-11-06 19:29:44 -0800111 /* Try FMAP cache first */
Julius Wernerc8931972021-04-16 16:48:32 -0700112 if (!region_device_sz(&fmap_cache))
Arthur Heymansdba22d22019-11-20 19:57:49 +0100113 setup_preram_cache(&fmap_cache);
Julius Wernerc8931972021-04-16 16:48:32 -0700114 if (region_device_sz(&fmap_cache))
115 return rdev_chain_full(fmrd, &fmap_cache);
Patrick Rudolph6d787c22019-09-12 13:21:37 +0200116
Aaron Durbin0424c952015-03-28 23:56:22 -0500117 boot_device_init();
118 boot = boot_device_ro();
119
120 if (boot == NULL)
121 return -1;
122
Julius Wernercefe89e2019-11-06 19:29:44 -0800123 fmap = rdev_mmap(boot, offset, sizeof(struct fmap));
Aaron Durbin0424c952015-03-28 23:56:22 -0500124
125 if (fmap == NULL)
126 return -1;
127
Julius Wernerfdabf3f2020-05-06 17:06:35 -0700128 if (verify_fmap(fmap)) {
129 printk(BIOS_ERR, "FMAP missing or corrupted at offset 0x%zx!\n",
130 offset);
Aaron Durbin0424c952015-03-28 23:56:22 -0500131 rdev_munmap(boot, fmap);
132 return -1;
133 }
134
Julius Wernercefe89e2019-11-06 19:29:44 -0800135 report(fmap);
Aaron Durbin0424c952015-03-28 23:56:22 -0500136
137 rdev_munmap(boot, fmap);
138
Julius Wernercefe89e2019-11-06 19:29:44 -0800139 return rdev_chain(fmrd, boot, offset, FMAP_SIZE);
Aaron Durbin0424c952015-03-28 23:56:22 -0500140}
141
142int fmap_locate_area_as_rdev(const char *name, struct region_device *area)
143{
144 struct region ar;
145
146 if (fmap_locate_area(name, &ar))
147 return -1;
148
149 return boot_device_ro_subregion(&ar, area);
150}
151
Aaron Durbinbccaab82016-08-12 12:42:04 -0500152int fmap_locate_area_as_rdev_rw(const char *name, struct region_device *area)
153{
154 struct region ar;
155
156 if (fmap_locate_area(name, &ar))
157 return -1;
158
159 return boot_device_rw_subregion(&ar, area);
160}
161
Aaron Durbin0424c952015-03-28 23:56:22 -0500162int fmap_locate_area(const char *name, struct region *ar)
163{
164 struct region_device fmrd;
165 size_t offset;
166
Jakub Czapiga5446bdb2020-12-10 12:21:52 +0100167 if (name == NULL || ar == NULL)
168 return -1;
169
Aaron Durbin0424c952015-03-28 23:56:22 -0500170 if (find_fmap_directory(&fmrd))
171 return -1;
172
173 /* Start reading the areas just after fmap header. */
174 offset = sizeof(struct fmap);
175
176 while (1) {
177 struct fmap_area *area;
178
179 area = rdev_mmap(&fmrd, offset, sizeof(*area));
180
181 if (area == NULL)
182 return -1;
183
184 if (strcmp((const char *)area->name, name)) {
185 rdev_munmap(&fmrd, area);
186 offset += sizeof(struct fmap_area);
187 continue;
188 }
189
Duncan Lauriebc2c0a32016-02-09 09:17:56 -0800190 printk(BIOS_DEBUG, "FMAP: area %s found @ %x (%d bytes)\n",
191 name, area->offset, area->size);
Aaron Durbin0424c952015-03-28 23:56:22 -0500192
193 ar->offset = area->offset;
194 ar->size = area->size;
195
196 rdev_munmap(&fmrd, area);
197
198 return 0;
199 }
200
201 printk(BIOS_DEBUG, "FMAP: area %s not found\n", name);
202
203 return -1;
204}
Patrick Georgi99526902015-07-09 11:27:44 +0200205
206int fmap_find_region_name(const struct region * const ar,
207 char name[FMAP_STRLEN])
208{
209 struct region_device fmrd;
210 size_t offset;
211
Jakub Czapiga5446bdb2020-12-10 12:21:52 +0100212 if (name == NULL || ar == NULL)
213 return -1;
214
Patrick Georgi99526902015-07-09 11:27:44 +0200215 if (find_fmap_directory(&fmrd))
216 return -1;
217
218 /* Start reading the areas just after fmap header. */
219 offset = sizeof(struct fmap);
220
221 while (1) {
222 struct fmap_area *area;
223
224 area = rdev_mmap(&fmrd, offset, sizeof(*area));
225
226 if (area == NULL)
227 return -1;
228
229 if ((ar->offset != area->offset) ||
230 (ar->size != area->size)) {
231 rdev_munmap(&fmrd, area);
232 offset += sizeof(struct fmap_area);
233 continue;
234 }
235
236 printk(BIOS_DEBUG, "FMAP: area (%zx, %zx) found, named %s\n",
237 ar->offset, ar->size, area->name);
238
239 memcpy(name, area->name, FMAP_STRLEN);
240
241 rdev_munmap(&fmrd, area);
242
243 return 0;
244 }
245
246 printk(BIOS_DEBUG, "FMAP: area (%zx, %zx) not found\n",
247 ar->offset, ar->size);
248
249 return -1;
250}
T Michael Turney19fcc892019-03-20 14:37:34 -0700251
252ssize_t fmap_read_area(const char *name, void *buffer, size_t size)
253{
254 struct region_device rdev;
255 if (fmap_locate_area_as_rdev(name, &rdev))
256 return -1;
257 return rdev_readat(&rdev, buffer, 0,
258 MIN(size, region_device_sz(&rdev)));
259}
260
261ssize_t fmap_overwrite_area(const char *name, const void *buffer, size_t size)
262{
263 struct region_device rdev;
264
265 if (fmap_locate_area_as_rdev_rw(name, &rdev))
266 return -1;
267 if (size > region_device_sz(&rdev))
268 return -1;
269 if (rdev_eraseat(&rdev, 0, region_device_sz(&rdev)) < 0)
270 return -1;
271 return rdev_writeat(&rdev, buffer, 0, size);
272}
Patrick Rudolph6d787c22019-09-12 13:21:37 +0200273
Julius Wernercefe89e2019-11-06 19:29:44 -0800274static void fmap_register_cbmem_cache(int unused)
Patrick Rudolph6d787c22019-09-12 13:21:37 +0200275{
276 const struct cbmem_entry *e;
Patrick Rudolph6d787c22019-09-12 13:21:37 +0200277
278 /* Find the FMAP cache installed by previous stage */
279 e = cbmem_entry_find(CBMEM_ID_FMAP);
280 /* Don't set fmap_cache so that find_fmap_directory will use regular path */
281 if (!e)
282 return;
283
Julius Wernerc8931972021-04-16 16:48:32 -0700284 rdev_chain_mem(&fmap_cache, cbmem_entry_start(e), cbmem_entry_size(e));
Patrick Rudolph6d787c22019-09-12 13:21:37 +0200285}
286
287/*
288 * The main reason to copy the FMAP into CBMEM is to make it available to the
289 * OS on every architecture. As side effect use the CBMEM copy as cache.
290 */
Julius Wernercefe89e2019-11-06 19:29:44 -0800291static void fmap_setup_cbmem_cache(int unused)
Patrick Rudolph6d787c22019-09-12 13:21:37 +0200292{
293 struct region_device fmrd;
294
295 if (find_fmap_directory(&fmrd))
296 return;
297
298 /* Reloads the FMAP even on ACPI S3 resume */
299 const size_t s = region_device_sz(&fmrd);
300 struct fmap *fmap = cbmem_add(CBMEM_ID_FMAP, s);
301 if (!fmap) {
302 printk(BIOS_ERR, "ERROR: Failed to allocate CBMEM\n");
303 return;
304 }
305
306 const ssize_t ret = rdev_readat(&fmrd, fmap, 0, s);
307 if (ret != s) {
308 printk(BIOS_ERR, "ERROR: Failed to read FMAP into CBMEM\n");
309 cbmem_entry_remove(cbmem_entry_find(CBMEM_ID_FMAP));
310 return;
311 }
312
313 /* Finally advertise the cache for the current stage */
Julius Wernercefe89e2019-11-06 19:29:44 -0800314 fmap_register_cbmem_cache(unused);
Patrick Rudolph6d787c22019-09-12 13:21:37 +0200315}
316
Julius Wernercefe89e2019-11-06 19:29:44 -0800317ROMSTAGE_CBMEM_INIT_HOOK(fmap_setup_cbmem_cache)
318RAMSTAGE_CBMEM_INIT_HOOK(fmap_register_cbmem_cache)
319POSTCAR_CBMEM_INIT_HOOK(fmap_register_cbmem_cache)