1 /*-
2 * Copyright (c) 2017 Netflix, Inc.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26 #include <sys/cdefs.h>
27 __FBSDID("$FreeBSD$");
28
29 #include <sys/param.h>
30 #include <sys/ucred.h>
31 #include <sys/mount.h>
32
33 #undef MAX
34 #undef MIN
35
36 #include <assert.h>
37 #include <efivar.h>
38 #include <errno.h>
39 #include <libgeom.h>
40 #include <paths.h>
41 #include <stdio.h>
42 #include <string.h>
43
44 #include "efichar.h"
45
46 #include "efi-osdep.h"
47 #include "efivar-dp.h"
48
49 #include "uefi-dplib.h"
50
51 #define MAX_DP_SANITY 4096 /* Biggest device path in bytes */
52 #define MAX_DP_TEXT_LEN 4096 /* Longest string rep of dp */
53
54 #define ValidLen(dp) (DevicePathNodeLength(dp) >= sizeof(EFI_DEVICE_PATH_PROTOCOL) && \
55 DevicePathNodeLength(dp) < MAX_DP_SANITY)
56
57 #define G_PART "PART"
58 #define G_LABEL "LABEL"
59 #define G_DISK "DISK"
60
61 static const char *
geom_pp_attr(struct gmesh * mesh,struct gprovider * pp,const char * attr)62 geom_pp_attr(struct gmesh *mesh, struct gprovider *pp, const char *attr)
63 {
64 struct gconfig *conf;
65
66 LIST_FOREACH(conf, &pp->lg_config, lg_config) {
67 if (strcmp(conf->lg_name, attr) != 0)
68 continue;
69 return (conf->lg_val);
70 }
71 return (NULL);
72 }
73
74 static struct gprovider *
find_provider_by_efimedia(struct gmesh * mesh,const char * efimedia)75 find_provider_by_efimedia(struct gmesh *mesh, const char *efimedia)
76 {
77 struct gclass *classp;
78 struct ggeom *gp;
79 struct gprovider *pp;
80 const char *val;
81
82 /*
83 * Find the partition class so we can search it...
84 */
85 LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
86 if (strcasecmp(classp->lg_name, G_PART) == 0)
87 break;
88 }
89 if (classp == NULL)
90 return (NULL);
91
92 /*
93 * Each geom will have a number of providers, search each
94 * one of them for the efimedia that matches.
95 */
96 /* XXX just used gpart class since I know it's the only one, but maybe I should search all classes */
97 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
98 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
99 val = geom_pp_attr(mesh, pp, "efimedia");
100 if (val == NULL)
101 continue;
102 if (strcasecmp(efimedia, val) == 0)
103 return (pp);
104 }
105 }
106
107 return (NULL);
108 }
109
110 static struct gprovider *
find_provider_by_name(struct gmesh * mesh,const char * name)111 find_provider_by_name(struct gmesh *mesh, const char *name)
112 {
113 struct gclass *classp;
114 struct ggeom *gp;
115 struct gprovider *pp;
116
117 LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
118 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
119 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
120 if (strcmp(pp->lg_name, name) == 0)
121 return (pp);
122 }
123 }
124 }
125
126 return (NULL);
127 }
128
129
130 static int
efi_hd_to_unix(struct gmesh * mesh,const_efidp dp,char ** dev,char ** relpath,char ** abspath)131 efi_hd_to_unix(struct gmesh *mesh, const_efidp dp, char **dev, char **relpath, char **abspath)
132 {
133 int rv = 0, n, i;
134 const_efidp media, file, walker;
135 size_t len, mntlen;
136 char buf[MAX_DP_TEXT_LEN];
137 char *pwalk;
138 struct gprovider *pp, *provider;
139 struct gconsumer *cp;
140 struct statfs *mnt;
141
142 walker = media = dp;
143
144 /*
145 * Now, we can either have a filepath node next, or the end.
146 * Otherwise, it's an error.
147 */
148 if (!ValidLen(walker))
149 return (EINVAL);
150 walker = (const_efidp)NextDevicePathNode(walker);
151 if ((uintptr_t)walker - (uintptr_t)dp > MAX_DP_SANITY)
152 return (EINVAL);
153 if (DevicePathType(walker) == MEDIA_DEVICE_PATH &&
154 DevicePathSubType(walker) == MEDIA_FILEPATH_DP)
155 file = walker;
156 else if (DevicePathType(walker) == MEDIA_DEVICE_PATH &&
157 DevicePathType(walker) == END_DEVICE_PATH_TYPE)
158 file = NULL;
159 else
160 return (EINVAL);
161
162 /*
163 * Format this node. We're going to look for it as a efimedia
164 * attribute of some geom node. Once we find that node, we use it
165 * as the device it comes from, at least provisionally.
166 */
167 len = efidp_format_device_path_node(buf, sizeof(buf), media);
168 if (len > sizeof(buf))
169 return (EINVAL);
170
171 pp = find_provider_by_efimedia(mesh, buf);
172 if (pp == NULL) {
173 rv = ENOENT;
174 goto errout;
175 }
176
177 *dev = strdup(pp->lg_name);
178 if (*dev == NULL) {
179 rv = ENOMEM;
180 goto errout;
181 }
182
183 /*
184 * No file specified, just return the device. Don't even look
185 * for a mountpoint. XXX Sane?
186 */
187 if (file == NULL)
188 goto errout;
189
190 /*
191 * Now extract the relative path. The next node in the device path should
192 * be a filesystem node. If not, we have issues.
193 */
194 *relpath = efidp_extract_file_path(file);
195 if (*relpath == NULL) {
196 rv = ENOMEM;
197 goto errout;
198 }
199 for (pwalk = *relpath; *pwalk; pwalk++)
200 if (*pwalk == '\\')
201 *pwalk = '/';
202
203 /*
204 * To find the absolute path, we have to look for where we're mounted.
205 * We only look a little hard, since looking too hard can come up with
206 * false positives (imagine a graid, one of whose devices is *dev).
207 */
208 n = getfsstat(NULL, 0, MNT_NOWAIT) + 1;
209 if (n < 0) {
210 rv = errno;
211 goto errout;
212 }
213 mntlen = sizeof(struct statfs) * n;
214 mnt = malloc(mntlen);
215 n = getfsstat(mnt, mntlen, MNT_NOWAIT);
216 if (n < 0) {
217 rv = errno;
218 goto errout;
219 }
220 provider = pp;
221 for (i = 0; i < n; i++) {
222 /*
223 * Skip all pseudo filesystems. This also skips the real filesytsem
224 * of ZFS. There's no EFI designator for ZFS in the standard, so
225 * we'll need to invent one, but its decoding will be handled in
226 * a separate function.
227 */
228 if (mnt[i].f_mntfromname[0] != '/')
229 continue;
230
231 /*
232 * First see if it is directly attached
233 */
234 if (strcmp(provider->lg_name, mnt[i].f_mntfromname + 5) == 0)
235 break;
236
237 /*
238 * Next see if it is attached via one of the physical disk's
239 * labels.
240 */
241 LIST_FOREACH(cp, &provider->lg_consumers, lg_consumer) {
242 pp = cp->lg_provider;
243 if (strcmp(pp->lg_geom->lg_class->lg_name, G_LABEL) != 0)
244 continue;
245 if (strcmp(g_device_path(pp->lg_name), mnt[i].f_mntfromname) == 0)
246 goto break2;
247 }
248 /* Not the one, try the next mount point */
249 }
250 break2:
251
252 /*
253 * No mountpoint found, no absolute path possible
254 */
255 if (i >= n)
256 goto errout;
257
258 /*
259 * Construct absolute path and we're finally done.
260 */
261 if (strcmp(mnt[i].f_mntonname, "/") == 0)
262 asprintf(abspath, "/%s", *relpath);
263 else
264 asprintf(abspath, "%s/%s", mnt[i].f_mntonname, *relpath);
265
266 errout:
267 if (rv != 0) {
268 free(*dev);
269 *dev = NULL;
270 free(*relpath);
271 *relpath = NULL;
272 }
273 return (rv);
274 }
275
276 /*
277 * Translate the passed in device_path to a unix path via the following
278 * algorithm.
279 *
280 * If dp, dev or path NULL, return EDOOFUS. XXX wise?
281 *
282 * Set *path = NULL; *dev = NULL;
283 *
284 * Walk through the device_path until we find either a media device path.
285 * Return EINVAL if not found. Return EINVAL if walking dp would
286 * land us more than sanity size away from the start (4k).
287 *
288 * If we find a media descriptor, we search through the geom mesh to see if we
289 * can find a matching node. If no match is found in the mesh that matches,
290 * return ENXIO.
291 *
292 * Once we find a matching node, we search to see if there is a filesystem
293 * mounted on it. If we find nothing, then search each of the devices that are
294 * mounted to see if we can work up the geom tree to find the matching node. if
295 * we still can't find anything, *dev = sprintf("/dev/%s", provider_name
296 * of the original node we found), but return ENOTBLK.
297 *
298 * Record the dev of the mountpoint in *dev.
299 *
300 * Once we find something, check to see if the next node in the device path is
301 * the end of list. If so, return the mountpoint.
302 *
303 * If the next node isn't a File path node, return EFTYPE.
304 *
305 * Extract the path from the File path node(s). translate any \ file separators
306 * to /. Append the result to the mount point. Copy the resulting path into
307 * *path. Stat that path. If it is not found, return the errorr from stat.
308 *
309 * Finally, check to make sure the resulting path is still on the same
310 * device. If not, return ENODEV.
311 *
312 * Otherwise return 0.
313 *
314 * The dev or full path that's returned is malloced, so needs to be freed when
315 * the caller is done about it. Unlike many other functions, we can return data
316 * with an error code, so pay attention.
317 */
318 int
efivar_device_path_to_unix_path(const_efidp dp,char ** dev,char ** relpath,char ** abspath)319 efivar_device_path_to_unix_path(const_efidp dp, char **dev, char **relpath, char **abspath)
320 {
321 const_efidp walker;
322 struct gmesh mesh;
323 int rv = 0;
324
325 /*
326 * Sanity check args, fail early
327 */
328 if (dp == NULL || dev == NULL || relpath == NULL || abspath == NULL)
329 return (EDOOFUS);
330
331 *dev = NULL;
332 *relpath = NULL;
333 *abspath = NULL;
334
335 /*
336 * Find the first media device path we can. If we go too far,
337 * assume the passed in device path is bogus. If we hit the end
338 * then we didn't find a media device path, so signal that error.
339 */
340 walker = dp;
341 if (!ValidLen(walker))
342 return (EINVAL);
343 while (DevicePathType(walker) != MEDIA_DEVICE_PATH &&
344 DevicePathType(walker) != END_DEVICE_PATH_TYPE) {
345 walker = (const_efidp)NextDevicePathNode(walker);
346 if ((uintptr_t)walker - (uintptr_t)dp > MAX_DP_SANITY)
347 return (EINVAL);
348 if (!ValidLen(walker))
349 return (EINVAL);
350 }
351 if (DevicePathType(walker) != MEDIA_DEVICE_PATH)
352 return (EINVAL);
353
354 /*
355 * There's several types of media paths. We're only interested in the
356 * hard disk path, as it's really the only relevant one to booting. The
357 * CD path just might also be relevant, and would be easy to add, but
358 * isn't supported. A file path too is relevant, but at this stage, it's
359 * premature because we're trying to translate a specification for a device
360 * and path on that device into a unix path, or at the very least, a
361 * geom device : path-on-device.
362 *
363 * Also, ZFS throws a bit of a monkey wrench in here since it doesn't have
364 * a device path type (it creates a new virtual device out of one or more
365 * storage devices).
366 *
367 * For all of them, we'll need to know the geoms, so allocate / free the
368 * geom mesh here since it's safer than doing it in each sub-function
369 * which may have many error exits.
370 */
371 if (geom_gettree(&mesh))
372 return (ENOMEM);
373
374 rv = EINVAL;
375 if (DevicePathSubType(walker) == MEDIA_HARDDRIVE_DP)
376 rv = efi_hd_to_unix(&mesh, walker, dev, relpath, abspath);
377 #ifdef notyet
378 else if (is_cdrom_device(walker))
379 rv = efi_cdrom_to_unix(&mesh, walker, dev, relpath, abspath);
380 else if (is_floppy_device(walker))
381 rv = efi_floppy_to_unix(&mesh, walker, dev, relpath, abspath);
382 else if (is_zpool_device(walker))
383 rv = efi_zpool_to_unix(&mesh, walker, dev, relpath, abspath);
384 #endif
385 geom_deletetree(&mesh);
386
387 return (rv);
388 }
389
390 /*
391 * Construct the EFI path to a current unix path as follows.
392 *
393 * The path may be of one of three forms:
394 * 1) /path/to/file -- full path to a file. The file need not be present,
395 * but /path/to must be. It must reside on a local filesystem
396 * mounted on a GPT or MBR partition.
397 * 2) //path/to/file -- Shorthand for 'On the EFI partition, \path\to\file'
398 * where 'The EFI Partition' is a partiton that's type is 'efi'
399 * on the same disk that / is mounted from. If there are multiple
400 * or no 'efi' parittions on that disk, or / isn't on a disk that
401 * we can trace back to a physical device, an error will result
402 * 3) [/dev/]geom-name:/path/to/file -- Use the specified partition
403 * (and it must be a GPT or MBR partition) with the specified
404 * path. The latter is not authenticated.
405 * all path forms translate any \ characters to / before further processing.
406 * When a file path node is created, all / characters are translated back
407 * to \.
408 *
409 * For paths of the first form:
410 * find where the filesystem is mount (either the file directly, or
411 * its parent directory).
412 * translate any logical device name (eg lable) to a physical one
413 * If not possible, return ENXIO
414 * If the physical path is unsupported (Eg not on a GPT or MBR disk),
415 * return ENXIO
416 * Create a media device path node.
417 * append the relative path from the mountpoint to the media device node
418 * as a file path.
419 *
420 * For paths matching the second form:
421 * find the EFI partition corresponding to the root fileystem.
422 * If none found, return ENXIO
423 * Create a media device path node for the found partition
424 * Append a File Path to the end for the rest of the file.
425 *
426 * For paths of the third form
427 * Translate the geom-name passed in into a physical partition
428 * name.
429 * Return ENXIO if the translation fails
430 * Make a media device path for it
431 * append the part after the : as a File path node.
432 */
433
434 static char *
path_to_file_dp(const char * relpath)435 path_to_file_dp(const char *relpath)
436 {
437 char *rv;
438
439 asprintf(&rv, "File(%s)", relpath);
440 return rv;
441 }
442
443 static char *
find_geom_efi_on_root(struct gmesh * mesh)444 find_geom_efi_on_root(struct gmesh *mesh)
445 {
446 struct statfs buf;
447 const char *dev;
448 struct gprovider *pp;
449 // struct ggeom *disk;
450 struct gconsumer *cp;
451
452 /*
453 * Find /'s geom. Assume it's mounted on /dev/ and filter out all the
454 * filesystems that aren't.
455 */
456 if (statfs("/", &buf) != 0)
457 return (NULL);
458 dev = buf.f_mntfromname;
459 if (*dev != '/' || strncmp(dev, _PATH_DEV, sizeof(_PATH_DEV) - 1) != 0)
460 return (NULL);
461 dev += sizeof(_PATH_DEV) -1;
462 pp = find_provider_by_name(mesh, dev);
463 if (pp == NULL)
464 return (NULL);
465
466 /*
467 * If the provider is a LABEL, find it's outer PART class, if any. We
468 * only operate on partitions.
469 */
470 if (strcmp(pp->lg_geom->lg_class->lg_name, G_LABEL) == 0) {
471 LIST_FOREACH(cp, &pp->lg_consumers, lg_consumer) {
472 if (strcmp(cp->lg_provider->lg_geom->lg_class->lg_name, G_PART) == 0) {
473 pp = cp->lg_provider;
474 break;
475 }
476 }
477 }
478 if (strcmp(pp->lg_geom->lg_class->lg_name, G_PART) != 0)
479 return (NULL);
480
481 #if 0
482 /* This doesn't work because we can't get the data to walk UP the tree it seems */
483
484 /*
485 * Now that we've found the PART that we have mounted as root, find the
486 * first efi typed partition that's a peer, if any.
487 */
488 LIST_FOREACH(cp, &pp->lg_consumers, lg_consumer) {
489 if (strcmp(cp->lg_provider->lg_geom->lg_class->lg_name, G_DISK) == 0) {
490 disk = cp->lg_provider->lg_geom;
491 break;
492 }
493 }
494 if (disk == NULL) /* This is very bad -- old nested partitions -- no support ? */
495 return (NULL);
496 #endif
497
498 #if 0
499 /* This doesn't work because we can't get the data to walk UP the tree it seems */
500
501 /*
502 * With the disk provider, we can look for its consumers to see if any are the proper type.
503 */
504 LIST_FOREACH(pp, &disk->lg_consumer, lg_consumer) {
505 type = geom_pp_attr(mesh, pp, "type");
506 if (type == NULL)
507 continue;
508 if (strcmp(type, "efi") != 0)
509 continue;
510 efimedia = geom_pp_attr(mesh, pp, "efimedia");
511 if (efimedia == NULL)
512 return (NULL);
513 return strdup(efimedia);
514 }
515 #endif
516 return (NULL);
517 }
518
519
520 static char *
find_geom_efimedia(struct gmesh * mesh,const char * dev)521 find_geom_efimedia(struct gmesh *mesh, const char *dev)
522 {
523 struct gprovider *pp;
524 const char *efimedia;
525
526 pp = find_provider_by_name(mesh, dev);
527 if (pp == NULL)
528 return (NULL);
529 efimedia = geom_pp_attr(mesh, pp, "efimedia");
530 if (efimedia == NULL)
531 return (NULL);
532 return strdup(efimedia);
533 }
534
535 static int
build_dp(const char * efimedia,const char * relpath,efidp * dp)536 build_dp(const char *efimedia, const char *relpath, efidp *dp)
537 {
538 char *fp, *dptxt = NULL, *cp, *rp;
539 int rv = 0;
540 efidp out = NULL;
541 size_t len;
542
543 rp = strdup(relpath);
544 for (cp = rp; *cp; cp++)
545 if (*cp == '/')
546 *cp = '\\';
547 fp = path_to_file_dp(rp);
548 free(rp);
549 if (fp == NULL) {
550 rv = ENOMEM;
551 goto errout;
552 }
553
554 asprintf(&dptxt, "%s/%s", efimedia, fp);
555 out = malloc(8192);
556 len = efidp_parse_device_path(dptxt, out, 8192);
557 if (len > 8192) {
558 rv = ENOMEM;
559 goto errout;
560 }
561 if (len == 0) {
562 rv = EINVAL;
563 goto errout;
564 }
565
566 *dp = out;
567 errout:
568 if (rv) {
569 free(out);
570 }
571 free(dptxt);
572 free(fp);
573
574 return rv;
575 }
576
577 /* Handles //path/to/file */
578 /*
579 * Which means: find the disk that has /. Then look for a EFI partition
580 * and use that for the efimedia and /path/to/file as relative to that.
581 * Not sure how ZFS will work here since we can't easily make the leap
582 * to the geom from the zpool.
583 */
584 static int
efipart_to_dp(struct gmesh * mesh,char * path,efidp * dp)585 efipart_to_dp(struct gmesh *mesh, char *path, efidp *dp)
586 {
587 char *efimedia = NULL;
588 int rv;
589
590 efimedia = find_geom_efi_on_root(mesh);
591 #ifdef notyet
592 if (efimedia == NULL)
593 efimedia = find_efi_on_zfsroot(dev);
594 #endif
595 if (efimedia == NULL) {
596 rv = ENOENT;
597 goto errout;
598 }
599
600 rv = build_dp(efimedia, path + 1, dp);
601 errout:
602 free(efimedia);
603
604 return rv;
605 }
606
607 /* Handles [/dev/]geom:[/]path/to/file */
608 /* Handles zfs-dataset:[/]path/to/file (this may include / ) */
609 static int
dev_path_to_dp(struct gmesh * mesh,char * path,efidp * dp)610 dev_path_to_dp(struct gmesh *mesh, char *path, efidp *dp)
611 {
612 char *relpath, *dev, *efimedia = NULL;
613 int rv = 0;
614
615 relpath = strchr(path, ':');
616 assert(relpath != NULL);
617 *relpath++ = '\0';
618
619 dev = path;
620 if (strncmp(dev, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
621 dev += sizeof(_PATH_DEV) -1;
622
623 efimedia = find_geom_efimedia(mesh, dev);
624 #ifdef notyet
625 if (efimedia == NULL)
626 find_zfs_efi_media(dev);
627 #endif
628 if (efimedia == NULL) {
629 rv = ENOENT;
630 goto errout;
631 }
632 rv = build_dp(efimedia, relpath, dp);
633 errout:
634 free(efimedia);
635
636 return rv;
637 }
638
639 /* Handles /path/to/file */
640 static int
path_to_dp(struct gmesh * mesh,char * path,efidp * dp)641 path_to_dp(struct gmesh *mesh, char *path, efidp *dp)
642 {
643 struct statfs buf;
644 char *rp = NULL, *ep, *dev, *efimedia = NULL;
645 int rv = 0;
646
647 rp = realpath(path, NULL);
648 if (rp == NULL) {
649 rv = errno;
650 goto errout;
651 }
652
653 if (statfs(rp, &buf) != 0) {
654 rv = errno;
655 goto errout;
656 }
657
658 dev = buf.f_mntfromname;
659 if (strncmp(dev, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
660 dev += sizeof(_PATH_DEV) -1;
661 ep = rp + strlen(buf.f_mntonname);
662
663 efimedia = find_geom_efimedia(mesh, dev);
664 #ifdef notyet
665 if (efimedia == NULL)
666 find_zfs_efi_media(dev);
667 #endif
668 if (efimedia == NULL) {
669 rv = ENOENT;
670 goto errout;
671 }
672
673 rv = build_dp(efimedia, ep, dp);
674 errout:
675 free(efimedia);
676 free(rp);
677 if (rv != 0) {
678 free(*dp);
679 *dp = NULL;
680 }
681 return (rv);
682 }
683
684 int
efivar_unix_path_to_device_path(const char * path,efidp * dp)685 efivar_unix_path_to_device_path(const char *path, efidp *dp)
686 {
687 char *modpath = NULL, *cp;
688 int rv = ENOMEM;
689 struct gmesh mesh;
690
691 /*
692 * Fail early for clearly bogus things
693 */
694 if (path == NULL || dp == NULL)
695 return (EDOOFUS);
696
697 /*
698 * We'll need the goem mesh to grovel through it to find the
699 * efimedia attribute for any devices we find. Grab it here
700 * and release it to simplify the error paths out of the
701 * subordinate functions
702 */
703 if (geom_gettree(&mesh))
704 return (errno);
705
706 /*
707 * Convert all \ to /. We'll convert them back again when
708 * we encode the file. Boot loaders are expected to cope.
709 */
710 modpath = strdup(path);
711 if (modpath == NULL)
712 goto out;
713 for (cp = modpath; *cp; cp++)
714 if (*cp == '\\')
715 *cp = '/';
716
717 if (modpath[0] == '/' && modpath[1] == '/') /* Handle //foo/bar/baz */
718 rv = efipart_to_dp(&mesh, modpath, dp);
719 else if (strchr(modpath, ':')) /* Handle dev:/bar/baz */
720 rv = dev_path_to_dp(&mesh, modpath, dp);
721 else /* Handle /a/b/c */
722 rv = path_to_dp(&mesh, modpath, dp);
723
724 out:
725 geom_deletetree(&mesh);
726 free(modpath);
727
728 return (rv);
729 }
730