1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25 /*
26 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
27 * Copyright 2015 Toomas Soome <tsoome@me.com>
28 */
29
30 /*
31 * This file contains all the functions that manipulate the file
32 * system where the GRUB menu resides.
33 */
34 #include <stdio.h>
35 #include <errno.h>
36 #include <stdlib.h>
37 #include <strings.h>
38 #include <unistd.h>
39 #include <fcntl.h>
40 #include <assert.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include <sys/mount.h>
44 #include <sys/mntent.h>
45 #include <sys/mnttab.h>
46 #include <sys/efi_partition.h>
47 #include <sys/vtoc.h>
48 #include <sys/fs/ufs_mount.h>
49 #include <sys/dktp/fdisk.h>
50 #include <libfstyp.h>
51 #if defined(i386) || defined(__amd64)
52 #include <libfdisk.h>
53 #endif
54
55 #include "libgrub_impl.h"
56
57 static int
slice_match(const char * physpath,int slice)58 slice_match(const char *physpath, int slice)
59 {
60 const char *pos;
61
62 /* always match whole disk slice */
63 if (slice == SLCNUM_WHOLE_DISK)
64 return (0);
65
66 return ((pos = strrchr(physpath, slice)) == NULL ||
67 pos[1] != 0 || pos[-1] != ':');
68 }
69
70 /*
71 * Returns zero if path contains ufs
72 */
73 static int
slice_ufs(const char * path)74 slice_ufs(const char *path)
75 {
76 int fd, ret;
77 const char *id;
78 fstyp_handle_t hdl;
79
80 fd = open(path, O_RDONLY);
81 if ((ret = fstyp_init(fd, 0, NULL, &hdl)) == 0) {
82 ret = fstyp_ident(hdl, "ufs", &id);
83 fstyp_fini(hdl);
84 }
85 (void) close(fd);
86 return (ret);
87 }
88
89
90 static int
get_sol_prtnum(const char * physpath)91 get_sol_prtnum(const char *physpath)
92 {
93 int i, fd;
94 char *pos;
95 size_t sz;
96 struct mboot *mb;
97 struct ipart *ipart;
98 char boot_sect[512];
99 char rdev[MAXNAMELEN];
100 #if defined(i386) || defined(__amd64)
101 ext_part_t *epp;
102 int ext_part_found = 0;
103 #endif
104
105 (void) snprintf(rdev, sizeof (rdev), "/devices%s,raw", physpath);
106
107 if ((pos = strrchr(rdev, ':')) == NULL)
108 return (PRTNUM_INVALID);
109
110 /*
111 * first check for EFI partitioning, efi_alloc_and_read()
112 * will return partition number.
113 */
114 if ((fd = open(rdev, O_RDONLY|O_NDELAY)) >= 0) {
115 struct dk_gpt *vtoc;
116
117 if ((i = efi_alloc_and_read(fd, &vtoc)) >= 0) {
118 /* zfs is using V_USR */
119 if (vtoc->efi_parts[i].p_tag != V_USR)
120 i = PRTNUM_INVALID; /* error */
121 efi_free(vtoc);
122 (void) close(fd);
123 return (i);
124 }
125 (void) close(fd);
126 } else {
127 return (PRTNUM_INVALID);
128 }
129
130 pos[1] = SLCNUM_WHOLE_DISK;
131
132 fd = open(rdev, O_RDONLY);
133 sz = read(fd, boot_sect, sizeof (boot_sect));
134 (void) close(fd);
135
136 if (sz != sizeof (boot_sect))
137 return (PRTNUM_INVALID);
138
139 /* parse fdisk table */
140 mb = (struct mboot *)(uintptr_t)boot_sect;
141 ipart = (struct ipart *)(uintptr_t)mb->parts;
142 for (i = 0; i < FD_NUMPART; ++i) {
143 if (ipart[i].systid == SUNIXOS || ipart[i].systid == SUNIXOS2)
144 return (i);
145
146 #if defined(i386) || defined(__amd64)
147 if (!fdisk_is_dos_extended(ipart[i].systid) ||
148 (ext_part_found == 1))
149 continue;
150
151 ext_part_found = 1;
152
153 if (libfdisk_init(&epp, rdev, NULL, FDISK_READ_DISK) ==
154 FDISK_SUCCESS) {
155 uint32_t begs, nums;
156 int pno;
157 int rval;
158
159 rval = fdisk_get_solaris_part(epp, &pno, &begs, &nums);
160
161 libfdisk_fini(&epp);
162
163 if (rval == FDISK_SUCCESS)
164 return (pno - 1);
165 }
166 #endif
167 }
168 return (PRTNUM_INVALID);
169 }
170
171 /*
172 * Get physpath, topfs and bootfs for ZFS root dataset.
173 * Return 0 on success, non-zero (not errno) on failure.
174 */
175 static int
get_zfs_root(zfs_handle_t * zfh,grub_fs_t * fs,grub_root_t * root)176 get_zfs_root(zfs_handle_t *zfh, grub_fs_t *fs, grub_root_t *root)
177 {
178 int ret;
179 zpool_handle_t *zph;
180 const char *name;
181
182 if (zfs_get_type(zfh) != ZFS_TYPE_FILESYSTEM ||
183 (name = zfs_get_name(zfh)) == NULL ||
184 (zph = zpool_open(fs->gf_lzfh, name)) == NULL)
185 return (-1);
186
187 if ((ret = zpool_get_physpath(zph, root->gr_physpath,
188 sizeof (root->gr_physpath))) == 0 &&
189 (ret = zpool_get_prop(zph, ZPOOL_PROP_BOOTFS,
190 root->gr_fs[GRBM_ZFS_BOOTFS].gfs_dev,
191 sizeof (root->gr_fs[GRBM_ZFS_BOOTFS].gfs_dev), NULL,
192 B_FALSE)) == 0) {
193
194 (void) strlcpy(root->gr_fs[GRBM_ZFS_TOPFS].gfs_dev, name,
195 sizeof (root->gr_fs[GRBM_ZFS_TOPFS].gfs_dev));
196 (void) grub_fsd_get_mountp(root->gr_fs + GRBM_ZFS_BOOTFS,
197 MNTTYPE_ZFS);
198 (void) grub_fsd_get_mountp(root->gr_fs + GRBM_ZFS_TOPFS,
199 MNTTYPE_ZFS);
200 }
201
202 zpool_close(zph);
203 return (ret);
204 }
205
206 /*
207 * On entry physpath parameter supposed to contain:
208 * <disk_physpath>[<space><disk_physpath>]*.
209 * Retrieves first <disk_physpath> that matches both partition and slice.
210 * If any partition and slice is acceptable, first <disk_physpath> is returned.
211 */
212 static int
get_one_physpath(char * physpath,uint_t prtnum,uint_t slcnum)213 get_one_physpath(char *physpath, uint_t prtnum, uint_t slcnum)
214 {
215 int ret;
216 char *tmp, *tok;
217
218 if (!IS_SLCNUM_VALID(slcnum) && !IS_PRTNUM_VALID(prtnum)) {
219 (void) strtok(physpath, " ");
220 return (0);
221 }
222
223 if ((tmp = strdup(physpath)) == NULL)
224 return (errno);
225
226 ret = ENODEV;
227 for (tok = strtok(tmp, " "); tok != NULL; tok = strtok(NULL, " ")) {
228 if ((ret = (slice_match(tok, slcnum) != 0 ||
229 get_sol_prtnum(tok) != prtnum)) == 0) {
230 (void) strcpy(physpath, tok);
231 break;
232 }
233 }
234
235 free(tmp);
236 if (ret)
237 ret = ENODEV;
238 return (ret);
239 }
240
241 static int
zfs_bootsign(zfs_handle_t * zfh,void * data)242 zfs_bootsign(zfs_handle_t *zfh, void *data)
243 {
244 grub_barg_t *barg;
245 grub_menu_t *menu;
246 struct stat st;
247 char path[MAXPATHLEN];
248
249 barg = (grub_barg_t *)data;
250 menu = barg->gb_entry->ge_menu;
251
252 do {
253 if (get_zfs_root(zfh, &menu->gm_fs, &barg->gb_root) != 0 ||
254 get_one_physpath(barg->gb_root.gr_physpath, barg->gb_prtnum,
255 barg->gb_slcnum) != 0)
256 break;
257
258 /*
259 * if top zfs dataset is not mounted, mount it now
260 */
261 if (barg->gb_root.gr_fs[GRBM_ZFS_TOPFS].gfs_mountp[0] == 0) {
262 if (grub_fsd_mount_tmp(barg->gb_root.gr_fs +
263 GRBM_ZFS_TOPFS, MNTTYPE_ZFS) != 0)
264 break;
265 }
266
267 /* check that bootsign exists and it is a regular file */
268 (void) snprintf(path, sizeof (path), "%s%s",
269 barg->gb_root.gr_fs[GRBM_ZFS_TOPFS].gfs_mountp,
270 barg->gb_bootsign);
271
272 if (lstat(path, &st) != 0 || S_ISREG(st.st_mode) == 0 ||
273 (st.st_mode & S_IRUSR) == 0)
274 break;
275
276 (void) strlcpy(barg->gb_root.gr_fstyp, MNTTYPE_ZFS,
277 sizeof (barg->gb_root.gr_fstyp));
278 barg->gb_walkret = 0;
279 /* LINTED: E_CONSTANT_CONDITION */
280 } while (0);
281
282 grub_fsd_umount_tmp(barg->gb_root.gr_fs + GRBM_ZFS_TOPFS);
283 zfs_close(zfh);
284
285 /* return non-zero to terminate the walk */
286 return (barg->gb_walkret == 0);
287 }
288
289 static int
get_devlink(di_devlink_t dl,void * arg)290 get_devlink(di_devlink_t dl, void *arg)
291 {
292 const char *path;
293 grub_barg_t *barg;
294
295 barg = (grub_barg_t *)arg;
296 if ((path = di_devlink_path(dl)) != NULL)
297 (void) strlcpy(barg->gb_root.gr_fs[GRBM_UFS].gfs_dev, path,
298 sizeof (barg->gb_root.gr_fs[GRBM_UFS].gfs_dev));
299 return (DI_WALK_TERMINATE);
300 }
301
302 static int
ufs_bootsign_check(grub_barg_t * barg)303 ufs_bootsign_check(grub_barg_t *barg)
304 {
305 int ret;
306 struct stat st;
307 grub_menu_t *mp;
308 char path[MAXPATHLEN];
309
310 mp = barg->gb_entry->ge_menu;
311
312 /* get /dev/dsk link */
313 if (di_devlink_walk(mp->gm_fs.gf_dvlh, "^dsk/",
314 barg->gb_root.gr_physpath, DI_PRIMARY_LINK, barg, get_devlink) != 0)
315 return (errno);
316 /*
317 * if disk is not mounted, mount it now
318 */
319 if (grub_fsd_get_mountp(barg->gb_root.gr_fs + GRBM_UFS,
320 MNTTYPE_UFS) != 0) {
321 if ((ret =
322 slice_ufs(barg->gb_root.gr_fs[GRBM_UFS].gfs_dev)) != 0 ||
323 (ret = grub_fsd_mount_tmp(barg->gb_root.gr_fs + GRBM_UFS,
324 MNTTYPE_UFS)) != 0)
325 return (ret);
326 }
327
328 (void) snprintf(path, sizeof (path), "%s%s",
329 barg->gb_root.gr_fs[GRBM_UFS].gfs_mountp, barg->gb_bootsign);
330
331 if (lstat(path, &st) == 0 && S_ISREG(st.st_mode) &&
332 (st.st_mode & S_IRUSR) != 0) {
333 barg->gb_walkret = 0;
334 (void) strlcpy(barg->gb_root.gr_fstyp, MNTTYPE_UFS,
335 sizeof (barg->gb_root.gr_fstyp));
336 }
337
338 grub_fsd_umount_tmp(barg->gb_root.gr_fs + GRBM_UFS);
339 return (barg->gb_walkret);
340 }
341
342 static int
ufs_bootsign(di_node_t node,di_minor_t minor,void * arg)343 ufs_bootsign(di_node_t node, di_minor_t minor, void *arg)
344 {
345 uint_t prtnum;
346 char *name, *path;
347 grub_barg_t *barg;
348
349 barg = (grub_barg_t *)arg;
350
351 if (di_minor_spectype(minor) != S_IFBLK)
352 return (DI_WALK_CONTINUE);
353
354 name = di_minor_name(minor);
355 if (name[0] != barg->gb_slcnum || name[1] != 0)
356 return (DI_WALK_CONTINUE);
357
358 path = di_devfs_path(node);
359 (void) snprintf(barg->gb_root.gr_physpath,
360 sizeof (barg->gb_root.gr_physpath), "%s:%c", path, barg->gb_slcnum);
361 di_devfs_path_free(path);
362
363 prtnum = get_sol_prtnum(barg->gb_root.gr_physpath);
364 if (!IS_PRTNUM_VALID(prtnum))
365 return (DI_WALK_CONTINUE);
366
367 /*
368 * check only specified partition, slice
369 */
370
371 if (IS_PRTNUM_VALID(barg->gb_prtnum)) {
372 if (prtnum != barg->gb_prtnum || ufs_bootsign_check(barg) != 0)
373 return (DI_WALK_CONTINUE);
374 return (DI_WALK_TERMINATE);
375 }
376
377 /*
378 * Walk through all slices in found solaris partition
379 */
380
381 barg->gb_prtnum = prtnum;
382 minor = DI_MINOR_NIL;
383
384 while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
385
386 if (di_minor_spectype(minor) != S_IFBLK)
387 continue;
388
389 name = di_minor_name(minor);
390 if (!IS_SLCNUM_VALID(name[0]) || name[1] != 0)
391 continue;
392
393 barg->gb_slcnum = name[0];
394 path = strrchr(barg->gb_root.gr_physpath, ':');
395 path[1] = barg->gb_slcnum;
396
397 if (ufs_bootsign_check(barg) == 0)
398 return (DI_WALK_TERMINATE);
399 }
400
401 barg->gb_prtnum = (uint_t)PRTNUM_INVALID;
402 barg->gb_slcnum = (uint_t)SLCNUM_WHOLE_DISK;
403 return (DI_WALK_CONTINUE);
404 }
405
406 /*
407 * Differs from what GRUB is doing: GRUB searchs through all disks seen by bios
408 * for bootsign, if bootsign is found on ufs slice GRUB sets it as a root,
409 * if on zfs, then GRUB uses zfs slice as root only if bootsign wasn't found
410 * on other slices.
411 * That function first searches through all top datasets of active zpools,
412 * then if bootsign still not found walks through all disks and tries to
413 * find ufs slice with the bootsign.
414 */
415 int
grub_find_bootsign(grub_barg_t * barg)416 grub_find_bootsign(grub_barg_t *barg)
417 {
418 grub_menu_t *mp;
419 mp = barg->gb_entry->ge_menu;
420
421 /* try to find bootsign over zfs pools */
422 barg->gb_walkret = EG_BOOTSIGN;
423 (void) zfs_iter_root(mp->gm_fs.gf_lzfh, zfs_bootsign, barg);
424
425 /* try ufs now */
426 if (barg->gb_walkret != 0 && di_walk_minor(mp->gm_fs.gf_diroot,
427 DDI_NT_BLOCK, 0, barg, ufs_bootsign) != 0)
428 return (errno);
429
430 return (barg->gb_walkret);
431 }
432
433 /*
434 * Get current root file system.
435 * Return 0 on success, errno code on failure.
436 */
437 int
grub_current_root(grub_fs_t * fs,grub_root_t * root)438 grub_current_root(grub_fs_t *fs, grub_root_t *root)
439 {
440 int rc = 0;
441 FILE *fp = NULL;
442 char *name = NULL;
443 zfs_handle_t *zfh = NULL;
444 struct mnttab mp = {0};
445 struct mnttab mpref = {0};
446 char buf[MAXNAMELEN] = {0};
447
448 mpref.mnt_mountp = "/";
449
450 if ((fp = fopen(MNTTAB, "r")) == NULL)
451 return (errno);
452
453 /*
454 * getmntany returns non-zero for failure, and sets errno
455 */
456 rc = getmntany(fp, &mp, &mpref);
457 if (rc != 0)
458 rc = errno;
459
460 (void) fclose(fp);
461
462 if (rc != 0)
463 return (rc);
464
465 (void) strlcpy(root->gr_fstyp, mp.mnt_fstype, sizeof (root->gr_fstyp));
466
467 if (strcmp(root->gr_fstyp, MNTTYPE_ZFS) == 0) {
468
469 (void) strlcpy(buf, mp.mnt_special, sizeof (buf));
470 if ((name = strtok(buf, "/")) == NULL)
471 return (EG_CURROOT);
472
473 if ((zfh = zfs_open(fs->gf_lzfh, name, ZFS_TYPE_FILESYSTEM)) ==
474 NULL)
475 return (EG_OPENZFS);
476
477 /*
478 * get_zfs_root returns non-zero on failure, not errno.
479 */
480 if (get_zfs_root(zfh, fs, root))
481 rc = EG_CURROOT;
482 else
483 /*
484 * For mirrored root physpath would contain the list of
485 * all bootable devices, pick up the first one.
486 */
487 rc = get_one_physpath(root->gr_physpath, SLCNUM_INVALID,
488 PRTNUM_INVALID);
489
490 zfs_close(zfh);
491
492 } else if (strcmp(mp.mnt_fstype, MNTTYPE_UFS) == 0) {
493 (void) strlcpy(root->gr_fs[GRBM_UFS].gfs_dev, mp.mnt_special,
494 sizeof (root->gr_fs[GRBM_UFS].gfs_dev));
495 (void) strlcpy(root->gr_fs[GRBM_UFS].gfs_mountp, mp.mnt_mountp,
496 sizeof (root->gr_fs[GRBM_UFS].gfs_mountp));
497 } else {
498 rc = EG_UNKNOWNFS;
499 }
500
501 return (rc);
502 }
503
504 grub_fsdesc_t *
grub_get_rootfsd(const grub_root_t * root)505 grub_get_rootfsd(const grub_root_t *root)
506 {
507 grub_fsdesc_t *fsd = NULL;
508
509 assert(root);
510 if (strcmp(MNTTYPE_UFS, root->gr_fstyp) == 0)
511 fsd = (grub_fsdesc_t *)root->gr_fs + GRBM_UFS;
512 else if (strcmp(MNTTYPE_ZFS, root->gr_fstyp) == 0)
513 fsd = (grub_fsdesc_t *)root->gr_fs + GRBM_ZFS_BOOTFS;
514
515 return (fsd);
516 }
517
518 /*
519 * Gets file systems mount point if any.
520 * Return 0 if filesystem is mounted, errno on failure.
521 */
522 int
grub_fsd_get_mountp(grub_fsdesc_t * fsd,char * fstyp)523 grub_fsd_get_mountp(grub_fsdesc_t *fsd, char *fstyp)
524 {
525 int rc;
526 FILE *fp = NULL;
527 struct mnttab mp = {0};
528 struct mnttab mpref = {0};
529
530 fsd->gfs_mountp[0] = 0;
531
532 if ((fp = fopen(MNTTAB, "r")) == NULL)
533 return (errno);
534
535 mpref.mnt_special = fsd->gfs_dev;
536 mpref.mnt_fstype = fstyp;
537
538 if ((rc = getmntany(fp, &mp, &mpref)) == 0)
539 (void) strlcpy(fsd->gfs_mountp, mp.mnt_mountp,
540 sizeof (fsd->gfs_mountp));
541 else
542 rc = EG_GETMNTTAB;
543
544 (void) fclose(fp);
545 return (rc);
546 }
547
548 static const char tmp_mountp[] = "/tmp/.libgrubmgmt.%s.XXXXXX";
549
550 /*
551 * Mount file system at tmp_mountp.
552 * Return 0 on success, errno on failure.
553 */
554 int
grub_fsd_mount_tmp(grub_fsdesc_t * fsd,const char * fstyp)555 grub_fsd_mount_tmp(grub_fsdesc_t *fsd, const char *fstyp)
556 {
557 const char *pos;
558 void *data = NULL;
559 int dtsz = 0;
560 struct ufs_args ufs_args = {UFSMNT_LARGEFILES};
561 char mntopts[MNT_LINE_MAX] = "";
562 int rc = 0;
563
564 assert(fsd);
565 assert(!fsd->gfs_is_tmp_mounted);
566
567 fsd->gfs_mountp[0] = 0;
568
569 if (strcmp(fstyp, MNTTYPE_UFS) == 0) {
570 (void) strlcpy(mntopts, MNTOPT_LARGEFILES, sizeof (mntopts));
571 data = &ufs_args;
572 dtsz = sizeof (ufs_args);
573 } else if (strcmp(fstyp, MNTTYPE_ZFS) != 0) {
574 return (EG_UNKNOWNFS);
575 }
576
577 /* construct name for temporary mount point */
578 pos = strrchr(fsd->gfs_dev, '/');
579 pos = (pos == NULL) ? fsd->gfs_dev : pos + 1;
580
581 (void) snprintf(fsd->gfs_mountp, sizeof (fsd->gfs_mountp),
582 tmp_mountp, pos);
583 if (mkdtemp(fsd->gfs_mountp) != NULL) {
584 if ((rc = mount(fsd->gfs_dev, fsd->gfs_mountp,
585 MS_DATA | MS_OPTIONSTR | MS_RDONLY,
586 fstyp, data, dtsz, mntopts, sizeof (mntopts))) != 0) {
587 /*
588 * mount failed, collect errno and remove temp dir
589 */
590 rc = errno;
591 (void) rmdir(fsd->gfs_mountp);
592 }
593 } else {
594 rc = errno;
595 }
596
597 if (rc != 0)
598 fsd->gfs_mountp[0] = 0;
599
600 /*
601 * Note that valid values for gfs_is_tmp_mounted are 0,1.
602 * Any other value indicates that something bad happened.
603 * Probably grub_fsd_umount_tmp() wasn't called or didn't
604 * work as expected.
605 */
606 fsd->gfs_is_tmp_mounted += (rc == 0);
607 return (rc);
608 }
609
610 /*
611 * Unmount file system at tmp_mountp.
612 */
613 void
grub_fsd_umount_tmp(grub_fsdesc_t * fsd)614 grub_fsd_umount_tmp(grub_fsdesc_t *fsd)
615 {
616 if (fsd == NULL)
617 return;
618
619 if (fsd->gfs_is_tmp_mounted) {
620 if (fsd->gfs_mountp[0] != 0) {
621 (void) umount2(fsd->gfs_mountp, 0);
622 (void) rmdir(fsd->gfs_mountp);
623 fsd->gfs_mountp[0] = 0;
624 }
625 fsd->gfs_is_tmp_mounted = 0;
626 }
627 }
628