Debian Codegraph @

src/shared/find-esp.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <linux/magic.h>
4 #include <stdlib.h>
5 #include <sys/vfs.h>
6 #include <unistd.h>
7
8 #include "sd-device.h"
9 #include "sd-gpt.h"
10 #include "sd-id128.h"
11
12 #include "alloc-util.h"
13 #include "blkid-util.h"
14 #include "btrfs-util.h"
15 #include "chase.h"
16 #include "device-util.h"
17 #include "devnum-util.h"
18 #include "env-util.h"
19 #include "errno-util.h"
20 #include "fd-util.h"
21 #include "find-esp.h"
22 #include "parse-util.h"
23 #include "path-util.h"
24 #include "stat-util.h"
25 #include "string-util.h"
26 #include "strv.h"
27 #include "virt.h"
28
29 typedef enum VerifyESPFlags {
30 VERIFY_ESP_SEARCHING = 1 << 0, /* Downgrade various "not found" logs to debug level */
31 VERIFY_ESP_UNPRIVILEGED_MODE = 1 << 1, /* Call into udev rather than blkid */
32 VERIFY_ESP_SKIP_FSTYPE_CHECK = 1 << 2, /* Skip filesystem check */
33 VERIFY_ESP_SKIP_DEVICE_CHECK = 1 << 3, /* Skip device node check */
34 VERIFY_ESP_SKIP_FSROOT_CHECK = 1 << 4, /* Skip fsroot check */
35 } VerifyESPFlags;
36
37 static VerifyESPFlags verify_esp_flags_init(int unprivileged_mode, const char *env_name_for_relaxing) {
38 VerifyESPFlags flags = 0;
39 int r;
40
41 assert(env_name_for_relaxing);
42
43 if (unprivileged_mode < 0)
44 unprivileged_mode = geteuid() != 0;
45 if (unprivileged_mode)
46 flags |= VERIFY_ESP_UNPRIVILEGED_MODE;
47
48 r = getenv_bool(env_name_for_relaxing);
49 if (r < 0 && r != -ENXIO)
50 log_debug_errno(r, "Failed to parse $%s environment variable, assuming false.", env_name_for_relaxing);
51 else if (r > 0)
52 flags |= VERIFY_ESP_SKIP_FSTYPE_CHECK | VERIFY_ESP_SKIP_DEVICE_CHECK | VERIFY_ESP_SKIP_FSROOT_CHECK;
53
54 if (detect_container() > 0)
55 flags |= VERIFY_ESP_SKIP_DEVICE_CHECK;
56
57 return flags;
58 }
59
60 static int verify_esp_blkid(
61 dev_t devid,
62 VerifyESPFlags flags,
63 uint32_t *ret_part,
64 uint64_t *ret_pstart,
65 uint64_t *ret_psize,
66 sd_id128_t *ret_uuid) {
67
68 sd_id128_t uuid = SD_ID128_NULL;
69 uint64_t pstart = 0, psize = 0;
70 uint32_t part = 0;
71
72 #if HAVE_BLKID
73 _cleanup_(blkid_free_probep) blkid_probe b = NULL;
74 _cleanup_free_ char *node = NULL;
75 bool searching = FLAGS_SET(flags, VERIFY_ESP_SEARCHING);
76 const char *v;
77 int r;
78
79 r = dlopen_libblkid(LOG_DEBUG);
80 if (r < 0)
81 return r;
82
83 r = devname_from_devnum(S_IFBLK, devid, &node);
84 if (r < 0)
85 return log_error_errno(r, "Failed to get device path for " DEVNUM_FORMAT_STR ": %m", DEVNUM_FORMAT_VAL(devid));
86
87 errno = 0;
88 b = sym_blkid_new_probe_from_filename(node);
89 if (!b)
90 return log_error_errno(errno ?: SYNTHETIC_ERRNO(ENOMEM), "Failed to open file system \"%s\": %m", node);
91
92 sym_blkid_probe_enable_superblocks(b, 1);
93 sym_blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE);
94 sym_blkid_probe_enable_partitions(b, 1);
95 sym_blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS);
96
97 errno = 0;
98 r = sym_blkid_do_safeprobe(b);
99 if (r == -2)
100 return log_error_errno(SYNTHETIC_ERRNO(ENODEV), "File system \"%s\" is ambiguous.", node);
101 if (r == 1)
102 return log_error_errno(SYNTHETIC_ERRNO(ENODEV), "File system \"%s\" does not contain a label.", node);
103 if (r != 0)
104 return log_error_errno(errno ?: SYNTHETIC_ERRNO(EIO), "Failed to probe file system \"%s\": %m", node);
105
106 r = sym_blkid_probe_lookup_value(b, "TYPE", &v, NULL);
107 if (r != 0)
108 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
109 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
110 "No filesystem found on \"%s\".", node);
111 if (!streq(v, "vfat"))
112 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
113 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
114 "File system \"%s\" is not FAT.", node);
115
116 r = sym_blkid_probe_lookup_value(b, "PART_ENTRY_SCHEME", &v, NULL);
117 if (r != 0)
118 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
119 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
120 "File system \"%s\" is not located on a partitioned block device.", node);
121 if (!streq(v, "gpt"))
122 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
123 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
124 "File system \"%s\" is not on a GPT partition table.", node);
125
126 errno = 0;
127 r = sym_blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL);
128 if (r != 0)
129 return log_error_errno(errno ?: EIO, "Failed to probe partition type UUID of \"%s\": %m", node);
130 if (sd_id128_string_equal(v, SD_GPT_ESP) <= 0)
131 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
132 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
133 "File system \"%s\" has wrong type for an EFI System Partition (ESP).", node);
134
135 r = blkid_probe_lookup_value_id128(b, "PART_ENTRY_UUID", &uuid);
136 if (r < 0)
137 return log_error_errno(r, "Failed to probe partition entry UUID of \"%s\": %m", node);
138
139 errno = 0;
140 r = sym_blkid_probe_lookup_value(b, "PART_ENTRY_NUMBER", &v, NULL);
141 if (r != 0)
142 return log_error_errno(errno ?: SYNTHETIC_ERRNO(EIO), "Failed to probe partition number of \"%s\": %m", node);
143 r = safe_atou32(v, &part);
144 if (r < 0)
145 return log_error_errno(r, "Failed to parse PART_ENTRY_NUMBER field.");
146
147 r = blkid_probe_lookup_value_u64(b, "PART_ENTRY_OFFSET", &pstart);
148 if (r < 0)
149 return log_error_errno(r, "Failed to probe partition offset of \"%s\": %m", node);
150
151 r = blkid_probe_lookup_value_u64(b, "PART_ENTRY_SIZE", &psize);
152 if (r < 0)
153 return log_error_errno(r, "Failed to probe partition size of \"%s\": %m", node);
154 #endif
155
156 if (ret_part)
157 *ret_part = part;
158 if (ret_pstart)
159 *ret_pstart = pstart;
160 if (ret_psize)
161 *ret_psize = psize;
162 if (ret_uuid)
163 *ret_uuid = uuid;
164
165 return 0;
166 }
167
168 static int verify_esp_udev(
169 dev_t devid,
170 VerifyESPFlags flags,
171 uint32_t *ret_part,
172 uint64_t *ret_pstart,
173 uint64_t *ret_psize,
174 sd_id128_t *ret_uuid) {
175
176 bool searching = FLAGS_SET(flags, VERIFY_ESP_SEARCHING);
177 _cleanup_(sd_device_unrefp) sd_device *d = NULL;
178 sd_id128_t uuid = SD_ID128_NULL;
179 uint64_t pstart = 0, psize = 0;
180 uint32_t part = 0;
181 const char *node, *v;
182 int r;
183
184 r = sd_device_new_from_devnum(&d, 'b', devid);
185 if (r < 0)
186 return log_error_errno(r, "Failed to get device from device number: %m");
187
188 r = sd_device_get_devname(d, &node);
189 if (r < 0)
190 return log_device_error_errno(d, r, "Failed to get device node: %m");
191
192 r = sd_device_get_property_value(d, "ID_FS_TYPE", &v);
193 if (r < 0)
194 return log_device_error_errno(d, r, "Failed to get device property: %m");
195 if (!streq(v, "vfat"))
196 return log_device_full_errno(d,
197 searching ? LOG_DEBUG : LOG_ERR,
198 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
199 "File system \"%s\" is not FAT.", node );
200
201 r = sd_device_get_property_value(d, "ID_PART_ENTRY_SCHEME", &v);
202 if (r < 0)
203 return log_device_full_errno(d,
204 searching && r == -ENOENT ? LOG_DEBUG : LOG_ERR,
205 searching && r == -ENOENT ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : r,
206 "Failed to get device property: %m");
207 if (!streq(v, "gpt"))
208 return log_device_full_errno(d,
209 searching ? LOG_DEBUG : LOG_ERR,
210 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
211 "File system \"%s\" is not on a GPT partition table.", node);
212
213 r = sd_device_get_property_value(d, "ID_PART_ENTRY_TYPE", &v);
214 if (r < 0)
215 return log_device_error_errno(d, r, "Failed to get device property: %m");
216 if (sd_id128_string_equal(v, SD_GPT_ESP) <= 0)
217 return log_device_full_errno(d,
218 searching ? LOG_DEBUG : LOG_ERR,
219 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
220 "File system \"%s\" has wrong type for an EFI System Partition (ESP).", node);
221
222 r = sd_device_get_property_value(d, "ID_PART_ENTRY_UUID", &v);
223 if (r < 0)
224 return log_device_error_errno(d, r, "Failed to get device property: %m");
225 r = sd_id128_from_string(v, &uuid);
226 if (r < 0)
227 return log_device_error_errno(d, r, "Partition \"%s\" has invalid UUID \"%s\".", node, v);
228
229 r = sd_device_get_property_value(d, "ID_PART_ENTRY_NUMBER", &v);
230 if (r < 0)
231 return log_device_error_errno(d, r, "Failed to get device property: %m");
232 r = safe_atou32(v, &part);
233 if (r < 0)
234 return log_device_error_errno(d, r, "Failed to parse PART_ENTRY_NUMBER field.");
235
236 r = sd_device_get_property_value(d, "ID_PART_ENTRY_OFFSET", &v);
237 if (r < 0)
238 return log_device_error_errno(d, r, "Failed to get device property: %m");
239 r = safe_atou64(v, &pstart);
240 if (r < 0)
241 return log_device_error_errno(d, r, "Failed to parse PART_ENTRY_OFFSET field.");
242
243 r = sd_device_get_property_value(d, "ID_PART_ENTRY_SIZE", &v);
244 if (r < 0)
245 return log_device_error_errno(d, r, "Failed to get device property: %m");
246 r = safe_atou64(v, &psize);
247 if (r < 0)
248 return log_device_error_errno(d, r, "Failed to parse PART_ENTRY_SIZE field.");
249
250 if (ret_part)
251 *ret_part = part;
252 if (ret_pstart)
253 *ret_pstart = pstart;
254 if (ret_psize)
255 *ret_psize = psize;
256 if (ret_uuid)
257 *ret_uuid = uuid;
258
259 return 0;
260 }
261
262 static int verify_fsroot_dir(
263 const char *path,
264 int fd,
265 VerifyESPFlags flags,
266 dev_t *ret_dev) {
267
268 bool searching = FLAGS_SET(flags, VERIFY_ESP_SEARCHING),
269 unprivileged_mode = FLAGS_SET(flags, VERIFY_ESP_UNPRIVILEGED_MODE);
270 int r;
271
272 /* Checks if the specified directory is at the root of its file system, and returns device
273 * major/minor of the device, if it is. */
274
275 assert(path);
276 assert(fd >= 0);
277
278 struct statx sx;
279 r = xstatx_full(fd, /* path= */ NULL,
280 /* statx_flags= */ 0,
281 /* xstatx_flags= */ 0,
282 STATX_TYPE|STATX_INO,
283 /* optional_mask = */ 0,
284 STATX_ATTR_MOUNT_ROOT,
285 &sx);
286 if (r < 0)
287 return log_full_errno((searching && r == -ENOENT) ||
288 (unprivileged_mode && ERRNO_IS_NEG_PRIVILEGE(r)) ? LOG_DEBUG : LOG_ERR, r,
289 "Failed to determine block device node of \"%s\": %m", path);
290
291 r = statx_verify_directory(&sx);
292 if (r < 0)
293 return log_error_errno(r, "Path \"%s\" is not a directory", path);
294
295 if (!FLAGS_SET(sx.stx_attributes, STATX_ATTR_MOUNT_ROOT))
296 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
297 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
298 "Directory \"%s\" is not the root of the file system.", path);
299
300 if (!ret_dev)
301 return 0;
302
303 if (sx.stx_dev_major == 0) /* Hmm, maybe a btrfs device, and the caller asked for the backing device? Then let's try to get it. */
304 return btrfs_get_block_device_fd(fd, ret_dev);
305
306 *ret_dev = makedev(sx.stx_dev_major, sx.stx_dev_minor);
307 return 0;
308 }
309
310 static int verify_esp(
311 int rfd,
312 const char *path,
313 char **ret_path,
314 int *ret_fd,
315 uint32_t *ret_part,
316 uint64_t *ret_pstart,
317 uint64_t *ret_psize,
318 sd_id128_t *ret_uuid,
319 dev_t *ret_devid,
320 VerifyESPFlags flags) {
321
322 bool searching = FLAGS_SET(flags, VERIFY_ESP_SEARCHING),
323 unprivileged_mode = FLAGS_SET(flags, VERIFY_ESP_UNPRIVILEGED_MODE);
324 int r;
325
326 assert(wildcard_fd_is_valid(rfd));
327 assert(path);
328
329 /* This logs about all errors, except:
330 *
331 * -ENOENT → if 'searching' is set, and the dir doesn't exist
332 * -EADDRNOTAVAIL → if 'searching' is set, and the dir doesn't look like an ESP
333 * -EACESS → if 'unprivileged_mode' is set, and we have trouble accessing the thing
334 */
335
336 /* Non-root user can only check the status, so if an error occurred in the following, it does not cause any
337 * issues. Let's also, silence the error messages. */
338
339 _cleanup_free_ char *p = NULL;
340 _cleanup_close_ int fd = -EBADF;
341 r = chaseat(rfd, rfd, path, CHASE_TRIGGER_AUTOFS, &p, &fd);
342 if (r < 0)
343 return log_full_errno((searching && r == -ENOENT) ||
344 (unprivileged_mode && ERRNO_IS_PRIVILEGE(r)) ? LOG_DEBUG : LOG_ERR,
345 r, "Failed to open directory \"%s\": %m", path);
346
347 if (!FLAGS_SET(flags, VERIFY_ESP_SKIP_FSTYPE_CHECK)) {
348
349 r = fd_is_fs_type(fd, MSDOS_SUPER_MAGIC);
350 if (r < 0)
351 return log_full_errno((unprivileged_mode && r == -EACCES) ? LOG_DEBUG : LOG_ERR, r,
352 "Failed to check file system type of \"%s\": %m", p);
353 if (!r)
354 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
355 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
356 "File system \"%s\" is not a FAT EFI System Partition (ESP) file system.", p);
357 }
358
359 dev_t devid = 0;
360 if (!FLAGS_SET(flags, VERIFY_ESP_SKIP_FSROOT_CHECK)) {
361 r = verify_fsroot_dir(p, fd, flags, FLAGS_SET(flags, VERIFY_ESP_SKIP_DEVICE_CHECK) ? NULL : &devid);
362 if (r < 0)
363 return r;
364 }
365
366 /* In a container we don't have access to block devices, skip this part of the verification, we trust
367 * the container manager set everything up correctly on its own. */
368 if (FLAGS_SET(flags, VERIFY_ESP_SKIP_DEVICE_CHECK)) {
369
370 if (ret_part)
371 *ret_part = 0;
372 if (ret_pstart)
373 *ret_pstart = 0;
374 if (ret_psize)
375 *ret_psize = 0;
376 if (ret_uuid)
377 *ret_uuid = SD_ID128_NULL;
378
379 } else {
380 if (devnum_is_zero(devid))
381 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
382 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
383 "Could not determine backing block device of directory \"%s\" (btrfs RAID?).", p);
384
385 /* If we are unprivileged we ask udev for the metadata about the partition. If we are privileged we
386 * use blkid instead. Why? Because this code is called from 'bootctl' which is pretty much an
387 * emergency recovery tool that should also work when udev isn't up (i.e. from the emergency shell),
388 * however blkid can't work if we have no privileges to access block devices directly, which is why
389 * we use udev in that case. */
390 if (unprivileged_mode)
391 r = verify_esp_udev(devid, flags, ret_part, ret_pstart, ret_psize, ret_uuid);
392 else
393 r = verify_esp_blkid(devid, flags, ret_part, ret_pstart, ret_psize, ret_uuid);
394 if (r < 0)
395 return r;
396 }
397
398 if (ret_path)
399 *ret_path = TAKE_PTR(p);
400 if (ret_fd)
401 *ret_fd = TAKE_FD(fd);
402 if (ret_devid)
403 *ret_devid = devid;
404
405 return 0;
406 }
407
408 int find_esp_and_warn_at_full(
409 int rfd,
410 const char *path,
411 int unprivileged_mode,
412 char **ret_path,
413 int *ret_fd,
414 uint32_t *ret_part,
415 uint64_t *ret_pstart,
416 uint64_t *ret_psize,
417 sd_id128_t *ret_uuid,
418 dev_t *ret_devid) {
419
420 VerifyESPFlags flags;
421 int r;
422
423 assert(wildcard_fd_is_valid(rfd));
424
425 /* This logs about all errors except:
426 *
427 * -ENOKEY → when we can't find the partition
428 * -EACCESS → when unprivileged_mode is true, and we can't access something
429 */
430
431 flags = verify_esp_flags_init(unprivileged_mode, "SYSTEMD_RELAX_ESP_CHECKS");
432
433 if (path)
434 return verify_esp(rfd, path, ret_path, ret_fd, ret_part, ret_pstart, ret_psize, ret_uuid, ret_devid, flags);
435
436 path = getenv("SYSTEMD_ESP_PATH");
437 if (path) {
438 _cleanup_free_ char *p = NULL;
439 _cleanup_close_ int fd = -EBADF;
440 struct stat st;
441
442 if (!path_is_valid(path) || !path_is_absolute(path))
443 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
444 "$SYSTEMD_ESP_PATH does not refer to an absolute path, refusing to use it: \"%s\"",
445 path);
446
447 r = chaseat(rfd, rfd, path, CHASE_TRIGGER_AUTOFS, &p, &fd);
448 if (r < 0)
449 return log_error_errno(r, "Failed to resolve path \"%s\": %m", path);
450
451 /* Note: when the user explicitly configured things with an env var we won't validate the
452 * path beyond checking it refers to a directory. After all we want this to be useful for
453 * testing. */
454
455 if (fstat(fd, &st) < 0)
456 return log_error_errno(errno, "Failed to stat '%s': %m", p);
457 r = stat_verify_directory(&st);
458 if (r < 0)
459 return log_error_errno(r, "ESP path '%s' is not a directory.", p);
460
461 if (ret_path)
462 *ret_path = TAKE_PTR(p);
463 if (ret_fd)
464 *ret_fd = TAKE_FD(fd);
465 if (ret_part)
466 *ret_part = 0;
467 if (ret_pstart)
468 *ret_pstart = 0;
469 if (ret_psize)
470 *ret_psize = 0;
471 if (ret_uuid)
472 *ret_uuid = SD_ID128_NULL;
473 if (ret_devid)
474 *ret_devid = st.st_dev;
475
476 return 0;
477 }
478
479 FOREACH_STRING(dir, "/efi", "/boot", "/boot/efi") {
480 r = verify_esp(rfd,
481 dir,
482 ret_path,
483 ret_fd,
484 ret_part,
485 ret_pstart,
486 ret_psize,
487 ret_uuid,
488 ret_devid,
489 flags | VERIFY_ESP_SEARCHING);
490 if (r >= 0)
491 return 0;
492 if (!IN_SET(r, -ENOENT, -EADDRNOTAVAIL, -ENOTDIR, -ENOTTY)) /* This one is not it */
493 return r;
494 }
495
496 /* No logging here */
497 return -ENOKEY;
498 }
499
500 int find_esp_and_warn_full(
501 const char *root,
502 const char *path,
503 int unprivileged_mode,
504 char **ret_path,
505 int *ret_fd,
506 uint32_t *ret_part,
507 uint64_t *ret_pstart,
508 uint64_t *ret_psize,
509 sd_id128_t *ret_uuid,
510 dev_t *ret_devid) {
511
512 int r;
513
514 _cleanup_close_ int rfd = -EBADF;
515 if (empty_or_root(root))
516 rfd = XAT_FDROOT;
517 else {
518 rfd = open(root, O_PATH|O_DIRECTORY|O_CLOEXEC);
519 if (rfd < 0)
520 return -errno;
521 }
522
523 _cleanup_close_ int fd = -EBADF;
524 _cleanup_free_ char *p = NULL;
525 uint32_t part;
526 uint64_t pstart, psize;
527 sd_id128_t uuid;
528 dev_t devid;
529 r = find_esp_and_warn_at_full(
530 rfd,
531 path,
532 unprivileged_mode,
533 ret_path ? &p : NULL,
534 ret_fd ? &fd : NULL,
535 ret_part ? &part : NULL,
536 ret_pstart ? &pstart : NULL,
537 ret_psize ? &psize : NULL,
538 ret_uuid ? &uuid : NULL,
539 ret_devid ? &devid : NULL);
540 if (r < 0)
541 return r;
542
543 if (ret_path) {
544 r = chaseat_prefix_root(p, root, ret_path);
545 if (r < 0)
546 return r;
547 }
548 if (ret_fd)
549 *ret_fd = TAKE_FD(fd);
550 if (ret_part)
551 *ret_part = part;
552 if (ret_pstart)
553 *ret_pstart = pstart;
554 if (ret_psize)
555 *ret_psize = psize;
556 if (ret_uuid)
557 *ret_uuid = uuid;
558 if (ret_devid)
559 *ret_devid = devid;
560
561 return 0;
562 }
563
564 static int verify_xbootldr_blkid(
565 dev_t devid,
566 VerifyESPFlags flags,
567 sd_id128_t *ret_uuid) {
568
569 sd_id128_t uuid = SD_ID128_NULL;
570
571 #if HAVE_BLKID
572 bool searching = FLAGS_SET(flags, VERIFY_ESP_SEARCHING);
573 _cleanup_(blkid_free_probep) blkid_probe b = NULL;
574 _cleanup_free_ char *node = NULL;
575 const char *type, *v;
576 int r;
577
578 r = dlopen_libblkid(LOG_DEBUG);
579 if (r < 0)
580 return r;
581
582 r = devname_from_devnum(S_IFBLK, devid, &node);
583 if (r < 0)
584 return log_error_errno(r, "Failed to get block device path for " DEVNUM_FORMAT_STR ": %m",
585 DEVNUM_FORMAT_VAL(devid));
586
587 errno = 0;
588 b = sym_blkid_new_probe_from_filename(node);
589 if (!b)
590 return log_error_errno(errno_or_else(ENOMEM), "%s: Failed to create blkid probe: %m", node);
591
592 sym_blkid_probe_enable_partitions(b, 1);
593 sym_blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS);
594
595 errno = 0;
596 r = sym_blkid_do_safeprobe(b);
597 if (r == _BLKID_SAFEPROBE_AMBIGUOUS)
598 return log_error_errno(SYNTHETIC_ERRNO(ENODEV), "%s: File system is ambiguous.", node);
599 if (r == _BLKID_SAFEPROBE_NOT_FOUND)
600 return log_error_errno(SYNTHETIC_ERRNO(ENODEV), "%s: File system does not contain a label.", node);
601 if (r == _BLKID_SAFEPROBE_ERROR)
602 return log_error_errno(errno_or_else(EIO), "%s: Failed to probe file system: %m", node);
603
604 assert(r == _BLKID_SAFEPROBE_FOUND);
605
606 r = sym_blkid_probe_lookup_value(b, "PART_ENTRY_SCHEME", &type, NULL);
607 if (r != 0)
608 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
609 searching ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : SYNTHETIC_ERRNO(EIO),
610 "%s: Failed to probe PART_ENTRY_SCHEME.", node);
611 if (streq(type, "gpt")) {
612
613 errno = 0;
614 r = sym_blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL);
615 if (r != 0)
616 return log_error_errno(errno_or_else(EIO), "%s: Failed to probe PART_ENTRY_TYPE: %m", node);
617 if (sd_id128_string_equal(v, SD_GPT_XBOOTLDR) <= 0)
618 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
619 searching ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : SYNTHETIC_ERRNO(ENODEV),
620 "%s: Partition has wrong PART_ENTRY_TYPE=%s for XBOOTLDR partition.", node, v);
621
622 r = blkid_probe_lookup_value_id128(b, "PART_ENTRY_UUID", &uuid);
623 if (r < 0)
624 return log_error_errno(r, "%s: Failed to probe PART_ENTRY_UUID: %m", node);
625
626 } else if (streq(type, "dos")) {
627
628 errno = 0;
629 r = sym_blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL);
630 if (r != 0)
631 return log_error_errno(errno_or_else(EIO), "%s: Failed to probe PART_ENTRY_TYPE: %m", node);
632 if (!streq(v, "0xea"))
633 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
634 searching ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : SYNTHETIC_ERRNO(ENODEV),
635 "%s: Wrong PART_ENTRY_TYPE=%s for XBOOTLDR partition.", node, v);
636
637 } else
638 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
639 searching ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : SYNTHETIC_ERRNO(ENODEV),
640 "%s: Not on a GPT or DOS partition table (PART_ENTRY_SCHEME=%s).", node, type);
641 #endif
642
643 if (ret_uuid)
644 *ret_uuid = uuid;
645
646 return 0;
647 }
648
649 static int verify_xbootldr_udev(
650 dev_t devid,
651 VerifyESPFlags flags,
652 sd_id128_t *ret_uuid) {
653
654 bool searching = FLAGS_SET(flags, VERIFY_ESP_SEARCHING);
655 _cleanup_(sd_device_unrefp) sd_device *d = NULL;
656 sd_id128_t uuid = SD_ID128_NULL;
657 const char *node, *type, *v;
658 int r;
659
660 r = sd_device_new_from_devnum(&d, 'b', devid);
661 if (r < 0)
662 return log_error_errno(r, "Failed to get block device for " DEVNUM_FORMAT_STR ": %m", DEVNUM_FORMAT_VAL(devid));
663
664 r = sd_device_get_devname(d, &node);
665 if (r < 0)
666 return log_device_error_errno(d, r, "Failed to get device node: %m");
667
668 r = sd_device_get_property_value(d, "ID_PART_ENTRY_SCHEME", &type);
669 if (r < 0)
670 return log_device_full_errno(d,
671 searching && r == -ENOENT ? LOG_DEBUG : LOG_ERR,
672 searching && r == -ENOENT ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : r,
673 "Failed to query ID_PART_ENTRY_SCHEME: %m");
674
675 if (streq(type, "gpt")) {
676
677 r = sd_device_get_property_value(d, "ID_PART_ENTRY_TYPE", &v);
678 if (r < 0)
679 return log_device_error_errno(d, r, "Failed to query ID_PART_ENTRY_TYPE: %m");
680
681 r = sd_id128_string_equal(v, SD_GPT_XBOOTLDR);
682 if (r < 0)
683 return log_device_error_errno(d, r, "Failed to parse ID_PART_ENTRY_TYPE=%s: %m", v);
684 if (r == 0)
685 return log_device_full_errno(
686 d,
687 searching ? LOG_DEBUG : LOG_ERR,
688 searching ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : SYNTHETIC_ERRNO(ENODEV),
689 "Partition has wrong ID_PART_ENTRY_TYPE=%s for XBOOTLDR partition.", v);
690
691 r = sd_device_get_property_value(d, "ID_PART_ENTRY_UUID", &v);
692 if (r < 0)
693 return log_device_error_errno(d, r, "Failed to query ID_PART_ENTRY_UUID: %m");
694 r = sd_id128_from_string(v, &uuid);
695 if (r < 0)
696 return log_device_error_errno(d, r, "Partition has invalid UUID ID_PART_ENTRY_TYPE=%s: %m", v);
697
698 } else if (streq(type, "dos")) {
699
700 r = sd_device_get_property_value(d, "ID_PART_ENTRY_TYPE", &v);
701 if (r < 0)
702 return log_device_error_errno(d, r, "Failed to query ID_PART_ENTRY_TYPE: %m");
703 if (!streq(v, "0xea"))
704 return log_device_full_errno(
705 d,
706 searching ? LOG_DEBUG : LOG_ERR,
707 searching ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : SYNTHETIC_ERRNO(ENODEV),
708 "Wrong ID_PART_ENTRY_TYPE=%s for XBOOTLDR partition.", v);
709
710 } else
711 return log_device_full_errno(
712 d,
713 searching ? LOG_DEBUG : LOG_ERR,
714 searching ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : SYNTHETIC_ERRNO(ENODEV),
715 "Not on a GPT or DOS partition table (ID_PART_ENTRY_SCHEME=%s).", type);
716
717 if (ret_uuid)
718 *ret_uuid = uuid;
719
720 return 0;
721 }
722
723 static int verify_xbootldr(
724 int rfd,
725 const char *path,
726 VerifyESPFlags flags,
727 char **ret_path,
728 int *ret_fd,
729 sd_id128_t *ret_uuid,
730 dev_t *ret_devid) {
731
732 bool searching = FLAGS_SET(flags, VERIFY_ESP_SEARCHING),
733 unprivileged_mode = FLAGS_SET(flags, VERIFY_ESP_UNPRIVILEGED_MODE);
734 int r;
735
736 assert(wildcard_fd_is_valid(rfd));
737 assert(path);
738
739 _cleanup_free_ char *p = NULL;
740 _cleanup_close_ int fd = -EBADF;
741 r = chaseat(rfd, rfd, path, CHASE_TRIGGER_AUTOFS, &p, &fd);
742 if (r < 0)
743 return log_full_errno((searching && r == -ENOENT) ||
744 (unprivileged_mode && ERRNO_IS_PRIVILEGE(r)) ? LOG_DEBUG : LOG_ERR,
745 r, "Failed to open directory \"%s\": %m", path);
746
747 dev_t devid = 0;
748 if (!FLAGS_SET(flags, VERIFY_ESP_SKIP_FSROOT_CHECK)) {
749 r = verify_fsroot_dir(p, fd, flags, FLAGS_SET(flags, VERIFY_ESP_SKIP_DEVICE_CHECK) ? NULL : &devid);
750 if (r < 0)
751 return r;
752 }
753
754 if (FLAGS_SET(flags, VERIFY_ESP_SKIP_DEVICE_CHECK)) {
755 if (ret_uuid)
756 *ret_uuid = SD_ID128_NULL;
757 } else {
758 if (devnum_is_zero(devid))
759 return log_full_errno(searching ? LOG_DEBUG : LOG_ERR,
760 SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV),
761 "Could not determine backing block device of directory \"%s\" (btrfs RAID?).%s",
762 p,
763 searching ? "" :
764 "\nHint: set $SYSTEMD_RELAX_XBOOTLDR_CHECKS=yes environment variable "
765 "to bypass this and further verifications for the directory.");
766
767 if (unprivileged_mode)
768 r = verify_xbootldr_udev(devid, flags, ret_uuid);
769 else
770 r = verify_xbootldr_blkid(devid, flags, ret_uuid);
771 if (r < 0)
772 return r;
773 }
774
775 if (ret_path)
776 *ret_path = TAKE_PTR(p);
777 if (ret_fd)
778 *ret_fd = TAKE_FD(fd);
779 if (ret_devid)
780 *ret_devid = devid;
781
782 return 0;
783 }
784
785 int find_xbootldr_and_warn_at_full(
786 int rfd,
787 const char *path,
788 int unprivileged_mode,
789 char **ret_path,
790 int *ret_fd,
791 sd_id128_t *ret_uuid,
792 dev_t *ret_devid) {
793
794 VerifyESPFlags flags;
795 int r;
796
797 /* Similar to find_esp_and_warn(), but finds the XBOOTLDR partition. Returns the same errors. */
798
799 assert(wildcard_fd_is_valid(rfd));
800
801 flags = verify_esp_flags_init(unprivileged_mode, "SYSTEMD_RELAX_XBOOTLDR_CHECKS");
802
803 if (path)
804 return verify_xbootldr(rfd, path, flags, ret_path, ret_fd, ret_uuid, ret_devid);
805
806 path = getenv("SYSTEMD_XBOOTLDR_PATH");
807 if (path) {
808 _cleanup_free_ char *p = NULL;
809 _cleanup_close_ int fd = -EBADF;
810 struct stat st;
811
812 if (!path_is_valid(path) || !path_is_absolute(path))
813 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
814 "$SYSTEMD_XBOOTLDR_PATH does not refer to an absolute path, refusing to use it: \"%s\"",
815 path);
816
817 r = chaseat(rfd, rfd, path, CHASE_TRIGGER_AUTOFS, &p, &fd);
818 if (r < 0)
819 return log_error_errno(r, "Failed to resolve path \"%s\": %m", p);
820
821 if (fstat(fd, &st) < 0)
822 return log_error_errno(errno, "Failed to stat '%s': %m", p);
823 r = stat_verify_directory(&st);
824 if (r < 0)
825 return log_error_errno(r, "XBOOTLDR path '%s' is not a directory.", p);
826
827 if (ret_path)
828 *ret_path = TAKE_PTR(p);
829 if (ret_fd)
830 *ret_fd = TAKE_FD(fd);
831 if (ret_uuid)
832 *ret_uuid = SD_ID128_NULL;
833 if (ret_devid)
834 *ret_devid = st.st_dev;
835
836 return 0;
837 }
838
839 r = verify_xbootldr(
840 rfd,
841 "/boot",
842 flags | VERIFY_ESP_SEARCHING,
843 ret_path,
844 ret_fd,
845 ret_uuid,
846 ret_devid);
847 if (r < 0) {
848 if (!IN_SET(r, -ENOENT, -EADDRNOTAVAIL, -ENOTDIR, -ENOTTY)) /* This one is not it */
849 return r;
850
851 return -ENOKEY;
852 }
853
854 return 0;
855 }
856
857 int find_xbootldr_and_warn_full(
858 const char *root,
859 const char *path,
860 int unprivileged_mode,
861 char **ret_path,
862 int *ret_fd,
863 sd_id128_t *ret_uuid,
864 dev_t *ret_devid) {
865
866 int r;
867
868 _cleanup_close_ int rfd = -EBADF;
869 if (empty_or_root(root))
870 rfd = XAT_FDROOT;
871 else {
872 rfd = open(root, O_PATH|O_DIRECTORY|O_CLOEXEC);
873 if (rfd < 0)
874 return -errno;
875 }
876
877 _cleanup_close_ int fd = -EBADF;
878 _cleanup_free_ char *p = NULL;
879 sd_id128_t uuid;
880 dev_t devid;
881 r = find_xbootldr_and_warn_at_full(
882 rfd,
883 path,
884 unprivileged_mode,
885 ret_path ? &p : NULL,
886 ret_fd ? &fd : NULL,
887 ret_uuid ? &uuid : NULL,
888 ret_devid ? &devid : NULL);
889 if (r < 0)
890 return r;
891
892 if (ret_path) {
893 r = chaseat_prefix_root(p, root, ret_path);
894 if (r < 0)
895 return r;
896 }
897 if (ret_fd)
898 *ret_fd = TAKE_FD(fd);
899 if (ret_uuid)
900 *ret_uuid = uuid;
901 if (ret_devid)
902 *ret_devid = devid;
903
904 return 0;
905 }