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