7029 want per-process exploit mitigation features (secflags) 7030 want basic address space layout randomization (aslr) 7031 noexec_user_stack should be a secflag 7032 want a means to forbid mappings around NULL.
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 /* 23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2013, Joyent Inc. All rights reserved. 25 * Copyright (c) 2015 by Delphix. All rights reserved. 26 */ 27 28 /* 29 * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 30 */ 31 32 /* 33 * This module contains functions used to bring up and tear down the 34 * Virtual Platform: [un]mounting file-systems, [un]plumbing network 35 * interfaces, [un]configuring devices, establishing resource controls, 36 * and creating/destroying the zone in the kernel. These actions, on 37 * the way up, ready the zone; on the way down, they halt the zone. 38 * See the much longer block comment at the beginning of zoneadmd.c 39 * for a bigger picture of how the whole program functions. 40 * 41 * This module also has primary responsibility for the layout of "scratch 42 * zones." These are mounted, but inactive, zones that are used during 43 * operating system upgrade and potentially other administrative action. The 44 * scratch zone environment is similar to the miniroot environment. The zone's 45 * actual root is mounted read-write on /a, and the standard paths (/usr, 46 * /sbin, /lib) all lead to read-only copies of the running system's binaries. 47 * This allows the administrative tools to manipulate the zone using "-R /a" 48 * without relying on any binaries in the zone itself. 49 * 50 * If the scratch zone is on an alternate root (Live Upgrade [LU] boot 51 * environment), then we must resolve the lofs mounts used there to uncover 52 * writable (unshared) resources. Shared resources, though, are always 53 * read-only. In addition, if the "same" zone with a different root path is 54 * currently running, then "/b" inside the zone points to the running zone's 55 * root. This allows LU to synchronize configuration files during the upgrade 56 * process. 57 * 58 * To construct this environment, this module creates a tmpfs mount on 59 * $ZONEPATH/lu. Inside this scratch area, the miniroot-like environment as 60 * described above is constructed on the fly. The zone is then created using 61 * $ZONEPATH/lu as the root. 62 * 63 * Note that scratch zones are inactive. The zone's bits are not running and 64 * likely cannot be run correctly until upgrade is done. Init is not running 65 * there, nor is SMF. Because of this, the "mounted" state of a scratch zone 66 * is not a part of the usual halt/ready/boot state machine. 67 */ 68 69 #include <sys/param.h> 70 #include <sys/mount.h> 71 #include <sys/mntent.h> 72 #include <sys/socket.h> 73 #include <sys/utsname.h> 74 #include <sys/types.h> 75 #include <sys/stat.h> 76 #include <sys/sockio.h> 77 #include <sys/stropts.h> 78 #include <sys/conf.h> 79 #include <sys/systeminfo.h> 80 #include <sys/secflags.h> 81 82 #include <libdlpi.h> 83 #include <libdllink.h> 84 #include <libdlvlan.h> 85 86 #include <inet/tcp.h> 87 #include <arpa/inet.h> 88 #include <netinet/in.h> 89 #include <net/route.h> 90 91 #include <stdio.h> 92 #include <errno.h> 93 #include <fcntl.h> 94 #include <unistd.h> 95 #include <rctl.h> 96 #include <stdlib.h> 97 #include <string.h> 98 #include <strings.h> 99 #include <wait.h> 100 #include <limits.h> 101 #include <libgen.h> 102 #include <libzfs.h> 103 #include <libdevinfo.h> 104 #include <zone.h> 105 #include <assert.h> 106 #include <libcontract.h> 107 #include <libcontract_priv.h> 108 #include <uuid/uuid.h> 109 110 #include <sys/mntio.h> 111 #include <sys/mnttab.h> 112 #include <sys/fs/autofs.h> /* for _autofssys() */ 113 #include <sys/fs/lofs_info.h> 114 #include <sys/fs/zfs.h> 115 116 #include <pool.h> 117 #include <sys/pool.h> 118 #include <sys/priocntl.h> 119 120 #include <libbrand.h> 121 #include <sys/brand.h> 122 #include <libzonecfg.h> 123 #include <synch.h> 124 125 #include "zoneadmd.h" 126 #include <tsol/label.h> 127 #include <libtsnet.h> 128 #include <sys/priv.h> 129 #include <libinetutil.h> 130 131 #define V4_ADDR_LEN 32 132 #define V6_ADDR_LEN 128 133 134 #define RESOURCE_DEFAULT_OPTS \ 135 MNTOPT_RO "," MNTOPT_LOFS_NOSUB "," MNTOPT_NODEVICES 136 137 #define DFSTYPES "/etc/dfs/fstypes" 138 #define MAXTNZLEN 2048 139 140 #define ALT_MOUNT(mount_cmd) ((mount_cmd) != Z_MNT_BOOT) 141 142 /* a reasonable estimate for the number of lwps per process */ 143 #define LWPS_PER_PROCESS 10 144 145 /* for routing socket */ 146 static int rts_seqno = 0; 147 148 /* mangled zone name when mounting in an alternate root environment */ 149 static char kernzone[ZONENAME_MAX]; 150 151 /* array of cached mount entries for resolve_lofs */ 152 static struct mnttab *resolve_lofs_mnts, *resolve_lofs_mnt_max; 153 154 /* for Trusted Extensions */ 155 static tsol_zcent_t *get_zone_label(zlog_t *, priv_set_t *); 156 static int tsol_mounts(zlog_t *, char *, char *); 157 static void tsol_unmounts(zlog_t *, char *); 158 159 static m_label_t *zlabel = NULL; 160 static m_label_t *zid_label = NULL; 161 static priv_set_t *zprivs = NULL; 162 163 static const char *DFLT_FS_ALLOWED = "hsfs,smbfs,nfs,nfs3,nfs4,nfsdyn"; 164 165 /* from libsocket, not in any header file */ 166 extern int getnetmaskbyaddr(struct in_addr, struct in_addr *); 167 168 /* from zoneadmd */ 169 extern char query_hook[]; 170 171 /* 172 * For each "net" resource configured in zonecfg, we track a zone_addr_list_t 173 * node in a linked list that is sorted by linkid. The list is constructed as 174 * the xml configuration file is parsed, and the information 175 * contained in each node is added to the kernel before the zone is 176 * booted, to be retrieved and applied from within the exclusive-IP NGZ 177 * on boot. 178 */ 179 typedef struct zone_addr_list { 180 struct zone_addr_list *za_next; 181 datalink_id_t za_linkid; /* datalink_id_t of interface */ 182 struct zone_nwiftab za_nwiftab; /* address, defrouter properties */ 183 } zone_addr_list_t; 184 185 /* 186 * An optimization for build_mnttable: reallocate (and potentially copy the 187 * data) only once every N times through the loop. 188 */ 189 #define MNTTAB_HUNK 32 190 191 /* some handy macros */ 192 #define SIN(s) ((struct sockaddr_in *)s) 193 #define SIN6(s) ((struct sockaddr_in6 *)s) 194 195 /* 196 * Private autofs system call 197 */ 198 extern int _autofssys(int, void *); 199 200 static int 201 autofs_cleanup(zoneid_t zoneid) 202 { 203 /* 204 * Ask autofs to unmount all trigger nodes in the given zone. 205 */ 206 return (_autofssys(AUTOFS_UNMOUNTALL, (void *)zoneid)); 207 } 208 209 static void 210 free_mnttable(struct mnttab *mnt_array, uint_t nelem) 211 { 212 uint_t i; 213 214 if (mnt_array == NULL) 215 return; 216 for (i = 0; i < nelem; i++) { 217 free(mnt_array[i].mnt_mountp); 218 free(mnt_array[i].mnt_fstype); 219 free(mnt_array[i].mnt_special); 220 free(mnt_array[i].mnt_mntopts); 221 assert(mnt_array[i].mnt_time == NULL); 222 } 223 free(mnt_array); 224 } 225 226 /* 227 * Build the mount table for the zone rooted at "zroot", storing the resulting 228 * array of struct mnttabs in "mnt_arrayp" and the number of elements in the 229 * array in "nelemp". 230 */ 231 static int 232 build_mnttable(zlog_t *zlogp, const char *zroot, size_t zrootlen, FILE *mnttab, 233 struct mnttab **mnt_arrayp, uint_t *nelemp) 234 { 235 struct mnttab mnt; 236 struct mnttab *mnts; 237 struct mnttab *mnp; 238 uint_t nmnt; 239 240 rewind(mnttab); 241 resetmnttab(mnttab); 242 nmnt = 0; 243 mnts = NULL; 244 while (getmntent(mnttab, &mnt) == 0) { 245 struct mnttab *tmp_array; 246 247 if (strncmp(mnt.mnt_mountp, zroot, zrootlen) != 0) 248 continue; 249 if (nmnt % MNTTAB_HUNK == 0) { 250 tmp_array = realloc(mnts, 251 (nmnt + MNTTAB_HUNK) * sizeof (*mnts)); 252 if (tmp_array == NULL) { 253 free_mnttable(mnts, nmnt); 254 return (-1); 255 } 256 mnts = tmp_array; 257 } 258 mnp = &mnts[nmnt++]; 259 260 /* 261 * Zero out any fields we're not using. 262 */ 263 (void) memset(mnp, 0, sizeof (*mnp)); 264 265 if (mnt.mnt_special != NULL) 266 mnp->mnt_special = strdup(mnt.mnt_special); 267 if (mnt.mnt_mntopts != NULL) 268 mnp->mnt_mntopts = strdup(mnt.mnt_mntopts); 269 mnp->mnt_mountp = strdup(mnt.mnt_mountp); 270 mnp->mnt_fstype = strdup(mnt.mnt_fstype); 271 if ((mnt.mnt_special != NULL && mnp->mnt_special == NULL) || 272 (mnt.mnt_mntopts != NULL && mnp->mnt_mntopts == NULL) || 273 mnp->mnt_mountp == NULL || mnp->mnt_fstype == NULL) { 274 zerror(zlogp, B_TRUE, "memory allocation failed"); 275 free_mnttable(mnts, nmnt); 276 return (-1); 277 } 278 } 279 *mnt_arrayp = mnts; 280 *nelemp = nmnt; 281 return (0); 282 } 283 284 /* 285 * This is an optimization. The resolve_lofs function is used quite frequently 286 * to manipulate file paths, and on a machine with a large number of zones, 287 * there will be a huge number of mounted file systems. Thus, we trigger a 288 * reread of the list of mount points 289 */ 290 static void 291 lofs_discard_mnttab(void) 292 { 293 free_mnttable(resolve_lofs_mnts, 294 resolve_lofs_mnt_max - resolve_lofs_mnts); 295 resolve_lofs_mnts = resolve_lofs_mnt_max = NULL; 296 } 297 298 static int 299 lofs_read_mnttab(zlog_t *zlogp) 300 { 301 FILE *mnttab; 302 uint_t nmnts; 303 304 if ((mnttab = fopen(MNTTAB, "r")) == NULL) 305 return (-1); 306 if (build_mnttable(zlogp, "", 0, mnttab, &resolve_lofs_mnts, 307 &nmnts) == -1) { 308 (void) fclose(mnttab); 309 return (-1); 310 } 311 (void) fclose(mnttab); 312 resolve_lofs_mnt_max = resolve_lofs_mnts + nmnts; 313 return (0); 314 } 315 316 /* 317 * This function loops over potential loopback mounts and symlinks in a given 318 * path and resolves them all down to an absolute path. 319 */ 320 void 321 resolve_lofs(zlog_t *zlogp, char *path, size_t pathlen) 322 { 323 int len, arlen; 324 const char *altroot; 325 char tmppath[MAXPATHLEN]; 326 boolean_t outside_altroot; 327 328 if ((len = resolvepath(path, tmppath, sizeof (tmppath))) == -1) 329 return; 330 tmppath[len] = '\0'; 331 (void) strlcpy(path, tmppath, sizeof (tmppath)); 332 333 /* This happens once per zoneadmd operation. */ 334 if (resolve_lofs_mnts == NULL && lofs_read_mnttab(zlogp) == -1) 335 return; 336 337 altroot = zonecfg_get_root(); 338 arlen = strlen(altroot); 339 outside_altroot = B_FALSE; 340 for (;;) { 341 struct mnttab *mnp; 342 343 /* Search in reverse order to find longest match */ 344 for (mnp = resolve_lofs_mnt_max - 1; mnp >= resolve_lofs_mnts; 345 mnp--) { 346 if (mnp->mnt_fstype == NULL || 347 mnp->mnt_mountp == NULL || 348 mnp->mnt_special == NULL) 349 continue; 350 len = strlen(mnp->mnt_mountp); 351 if (strncmp(mnp->mnt_mountp, path, len) == 0 && 352 (path[len] == '/' || path[len] == '\0')) 353 break; 354 } 355 if (mnp < resolve_lofs_mnts) 356 break; 357 /* If it's not a lofs then we're done */ 358 if (strcmp(mnp->mnt_fstype, MNTTYPE_LOFS) != 0) 359 break; 360 if (outside_altroot) { 361 char *cp; 362 int olen = sizeof (MNTOPT_RO) - 1; 363 364 /* 365 * If we run into a read-only mount outside of the 366 * alternate root environment, then the user doesn't 367 * want this path to be made read-write. 368 */ 369 if (mnp->mnt_mntopts != NULL && 370 (cp = strstr(mnp->mnt_mntopts, MNTOPT_RO)) != 371 NULL && 372 (cp == mnp->mnt_mntopts || cp[-1] == ',') && 373 (cp[olen] == '\0' || cp[olen] == ',')) { 374 break; 375 } 376 } else if (arlen > 0 && 377 (strncmp(mnp->mnt_special, altroot, arlen) != 0 || 378 (mnp->mnt_special[arlen] != '\0' && 379 mnp->mnt_special[arlen] != '/'))) { 380 outside_altroot = B_TRUE; 381 } 382 /* use temporary buffer because new path might be longer */ 383 (void) snprintf(tmppath, sizeof (tmppath), "%s%s", 384 mnp->mnt_special, path + len); 385 if ((len = resolvepath(tmppath, path, pathlen)) == -1) 386 break; 387 path[len] = '\0'; 388 } 389 } 390 391 /* 392 * For a regular mount, check if a replacement lofs mount is needed because the 393 * referenced device is already mounted somewhere. 394 */ 395 static int 396 check_lofs_needed(zlog_t *zlogp, struct zone_fstab *fsptr) 397 { 398 struct mnttab *mnp; 399 zone_fsopt_t *optptr, *onext; 400 401 /* This happens once per zoneadmd operation. */ 402 if (resolve_lofs_mnts == NULL && lofs_read_mnttab(zlogp) == -1) 403 return (-1); 404 405 /* 406 * If this special node isn't already in use, then it's ours alone; 407 * no need to worry about conflicting mounts. 408 */ 409 for (mnp = resolve_lofs_mnts; mnp < resolve_lofs_mnt_max; 410 mnp++) { 411 if (strcmp(mnp->mnt_special, fsptr->zone_fs_special) == 0) 412 break; 413 } 414 if (mnp >= resolve_lofs_mnt_max) 415 return (0); 416 417 /* 418 * Convert this duplicate mount into a lofs mount. 419 */ 420 (void) strlcpy(fsptr->zone_fs_special, mnp->mnt_mountp, 421 sizeof (fsptr->zone_fs_special)); 422 (void) strlcpy(fsptr->zone_fs_type, MNTTYPE_LOFS, 423 sizeof (fsptr->zone_fs_type)); 424 fsptr->zone_fs_raw[0] = '\0'; 425 426 /* 427 * Discard all but one of the original options and set that to our 428 * default set of options used for resources. 429 */ 430 optptr = fsptr->zone_fs_options; 431 if (optptr == NULL) { 432 optptr = malloc(sizeof (*optptr)); 433 if (optptr == NULL) { 434 zerror(zlogp, B_TRUE, "cannot mount %s", 435 fsptr->zone_fs_dir); 436 return (-1); 437 } 438 } else { 439 while ((onext = optptr->zone_fsopt_next) != NULL) { 440 optptr->zone_fsopt_next = onext->zone_fsopt_next; 441 free(onext); 442 } 443 } 444 (void) strcpy(optptr->zone_fsopt_opt, RESOURCE_DEFAULT_OPTS); 445 optptr->zone_fsopt_next = NULL; 446 fsptr->zone_fs_options = optptr; 447 return (0); 448 } 449 450 int 451 make_one_dir(zlog_t *zlogp, const char *prefix, const char *subdir, mode_t mode, 452 uid_t userid, gid_t groupid) 453 { 454 char path[MAXPATHLEN]; 455 struct stat st; 456 457 if (snprintf(path, sizeof (path), "%s%s", prefix, subdir) > 458 sizeof (path)) { 459 zerror(zlogp, B_FALSE, "pathname %s%s is too long", prefix, 460 subdir); 461 return (-1); 462 } 463 464 if (lstat(path, &st) == 0) { 465 /* 466 * We don't check the file mode since presumably the zone 467 * administrator may have had good reason to change the mode, 468 * and we don't need to second guess him. 469 */ 470 if (!S_ISDIR(st.st_mode)) { 471 if (S_ISREG(st.st_mode)) { 472 /* 473 * Allow readonly mounts of /etc/ files; this 474 * is needed most by Trusted Extensions. 475 */ 476 if (strncmp(subdir, "/etc/", 477 strlen("/etc/")) != 0) { 478 zerror(zlogp, B_FALSE, 479 "%s is not in /etc", path); 480 return (-1); 481 } 482 } else { 483 zerror(zlogp, B_FALSE, 484 "%s is not a directory", path); 485 return (-1); 486 } 487 } 488 return (0); 489 } 490 491 if (mkdirp(path, mode) != 0) { 492 if (errno == EROFS) 493 zerror(zlogp, B_FALSE, "Could not mkdir %s.\nIt is on " 494 "a read-only file system in this local zone.\nMake " 495 "sure %s exists in the global zone.", path, subdir); 496 else 497 zerror(zlogp, B_TRUE, "mkdirp of %s failed", path); 498 return (-1); 499 } 500 501 (void) chown(path, userid, groupid); 502 return (0); 503 } 504 505 static void 506 free_remote_fstypes(char **types) 507 { 508 uint_t i; 509 510 if (types == NULL) 511 return; 512 for (i = 0; types[i] != NULL; i++) 513 free(types[i]); 514 free(types); 515 } 516 517 static char ** 518 get_remote_fstypes(zlog_t *zlogp) 519 { 520 char **types = NULL; 521 FILE *fp; 522 char buf[MAXPATHLEN]; 523 char fstype[MAXPATHLEN]; 524 uint_t lines = 0; 525 uint_t i; 526 527 if ((fp = fopen(DFSTYPES, "r")) == NULL) { 528 zerror(zlogp, B_TRUE, "failed to open %s", DFSTYPES); 529 return (NULL); 530 } 531 /* 532 * Count the number of lines 533 */ 534 while (fgets(buf, sizeof (buf), fp) != NULL) 535 lines++; 536 if (lines == 0) /* didn't read anything; empty file */ 537 goto out; 538 rewind(fp); 539 /* 540 * Allocate enough space for a NULL-terminated array. 541 */ 542 types = calloc(lines + 1, sizeof (char *)); 543 if (types == NULL) { 544 zerror(zlogp, B_TRUE, "memory allocation failed"); 545 goto out; 546 } 547 i = 0; 548 while (fgets(buf, sizeof (buf), fp) != NULL) { 549 /* LINTED - fstype is big enough to hold buf */ 550 if (sscanf(buf, "%s", fstype) == 0) { 551 zerror(zlogp, B_FALSE, "unable to parse %s", DFSTYPES); 552 free_remote_fstypes(types); 553 types = NULL; 554 goto out; 555 } 556 types[i] = strdup(fstype); 557 if (types[i] == NULL) { 558 zerror(zlogp, B_TRUE, "memory allocation failed"); 559 free_remote_fstypes(types); 560 types = NULL; 561 goto out; 562 } 563 i++; 564 } 565 out: 566 (void) fclose(fp); 567 return (types); 568 } 569 570 static boolean_t 571 is_remote_fstype(const char *fstype, char *const *remote_fstypes) 572 { 573 uint_t i; 574 575 if (remote_fstypes == NULL) 576 return (B_FALSE); 577 for (i = 0; remote_fstypes[i] != NULL; i++) { 578 if (strcmp(remote_fstypes[i], fstype) == 0) 579 return (B_TRUE); 580 } 581 return (B_FALSE); 582 } 583 584 /* 585 * This converts a zone root path (normally of the form .../root) to a Live 586 * Upgrade scratch zone root (of the form .../lu). 587 */ 588 static void 589 root_to_lu(zlog_t *zlogp, char *zroot, size_t zrootlen, boolean_t isresolved) 590 { 591 if (!isresolved && zonecfg_in_alt_root()) 592 resolve_lofs(zlogp, zroot, zrootlen); 593 (void) strcpy(strrchr(zroot, '/') + 1, "lu"); 594 } 595 596 /* 597 * The general strategy for unmounting filesystems is as follows: 598 * 599 * - Remote filesystems may be dead, and attempting to contact them as 600 * part of a regular unmount may hang forever; we want to always try to 601 * forcibly unmount such filesystems and only fall back to regular 602 * unmounts if the filesystem doesn't support forced unmounts. 603 * 604 * - We don't want to unnecessarily corrupt metadata on local 605 * filesystems (ie UFS), so we want to start off with graceful unmounts, 606 * and only escalate to doing forced unmounts if we get stuck. 607 * 608 * We start off walking backwards through the mount table. This doesn't 609 * give us strict ordering but ensures that we try to unmount submounts 610 * first. We thus limit the number of failed umount2(2) calls. 611 * 612 * The mechanism for determining if we're stuck is to count the number 613 * of failed unmounts each iteration through the mount table. This 614 * gives us an upper bound on the number of filesystems which remain 615 * mounted (autofs trigger nodes are dealt with separately). If at the 616 * end of one unmount+autofs_cleanup cycle we still have the same number 617 * of mounts that we started out with, we're stuck and try a forced 618 * unmount. If that fails (filesystem doesn't support forced unmounts) 619 * then we bail and are unable to teardown the zone. If it succeeds, 620 * we're no longer stuck so we continue with our policy of trying 621 * graceful mounts first. 622 * 623 * Zone must be down (ie, no processes or threads active). 624 */ 625 static int 626 unmount_filesystems(zlog_t *zlogp, zoneid_t zoneid, boolean_t unmount_cmd) 627 { 628 int error = 0; 629 FILE *mnttab; 630 struct mnttab *mnts; 631 uint_t nmnt; 632 char zroot[MAXPATHLEN + 1]; 633 size_t zrootlen; 634 uint_t oldcount = UINT_MAX; 635 boolean_t stuck = B_FALSE; 636 char **remote_fstypes = NULL; 637 638 if (zone_get_rootpath(zone_name, zroot, sizeof (zroot)) != Z_OK) { 639 zerror(zlogp, B_FALSE, "unable to determine zone root"); 640 return (-1); 641 } 642 if (unmount_cmd) 643 root_to_lu(zlogp, zroot, sizeof (zroot), B_FALSE); 644 645 (void) strcat(zroot, "/"); 646 zrootlen = strlen(zroot); 647 648 /* 649 * For Trusted Extensions unmount each higher level zone's mount 650 * of our zone's /export/home 651 */ 652 if (!unmount_cmd) 653 tsol_unmounts(zlogp, zone_name); 654 655 if ((mnttab = fopen(MNTTAB, "r")) == NULL) { 656 zerror(zlogp, B_TRUE, "failed to open %s", MNTTAB); 657 return (-1); 658 } 659 /* 660 * Use our hacky mntfs ioctl so we see everything, even mounts with 661 * MS_NOMNTTAB. 662 */ 663 if (ioctl(fileno(mnttab), MNTIOC_SHOWHIDDEN, NULL) < 0) { 664 zerror(zlogp, B_TRUE, "unable to configure %s", MNTTAB); 665 error++; 666 goto out; 667 } 668 669 /* 670 * Build the list of remote fstypes so we know which ones we 671 * should forcibly unmount. 672 */ 673 remote_fstypes = get_remote_fstypes(zlogp); 674 for (; /* ever */; ) { 675 uint_t newcount = 0; 676 boolean_t unmounted; 677 struct mnttab *mnp; 678 char *path; 679 uint_t i; 680 681 mnts = NULL; 682 nmnt = 0; 683 /* 684 * MNTTAB gives us a way to walk through mounted 685 * filesystems; we need to be able to walk them in 686 * reverse order, so we build a list of all mounted 687 * filesystems. 688 */ 689 if (build_mnttable(zlogp, zroot, zrootlen, mnttab, &mnts, 690 &nmnt) != 0) { 691 error++; 692 goto out; 693 } 694 for (i = 0; i < nmnt; i++) { 695 mnp = &mnts[nmnt - i - 1]; /* access in reverse order */ 696 path = mnp->mnt_mountp; 697 unmounted = B_FALSE; 698 /* 699 * Try forced unmount first for remote filesystems. 700 * 701 * Not all remote filesystems support forced unmounts, 702 * so if this fails (ENOTSUP) we'll continue on 703 * and try a regular unmount. 704 */ 705 if (is_remote_fstype(mnp->mnt_fstype, remote_fstypes)) { 706 if (umount2(path, MS_FORCE) == 0) 707 unmounted = B_TRUE; 708 } 709 /* 710 * Try forced unmount if we're stuck. 711 */ 712 if (stuck) { 713 if (umount2(path, MS_FORCE) == 0) { 714 unmounted = B_TRUE; 715 stuck = B_FALSE; 716 } else { 717 /* 718 * The first failure indicates a 719 * mount we won't be able to get 720 * rid of automatically, so we 721 * bail. 722 */ 723 error++; 724 zerror(zlogp, B_FALSE, 725 "unable to unmount '%s'", path); 726 free_mnttable(mnts, nmnt); 727 goto out; 728 } 729 } 730 /* 731 * Try regular unmounts for everything else. 732 */ 733 if (!unmounted && umount2(path, 0) != 0) 734 newcount++; 735 } 736 free_mnttable(mnts, nmnt); 737 738 if (newcount == 0) 739 break; 740 if (newcount >= oldcount) { 741 /* 742 * Last round didn't unmount anything; we're stuck and 743 * should start trying forced unmounts. 744 */ 745 stuck = B_TRUE; 746 } 747 oldcount = newcount; 748 749 /* 750 * Autofs doesn't let you unmount its trigger nodes from 751 * userland so we have to tell the kernel to cleanup for us. 752 */ 753 if (autofs_cleanup(zoneid) != 0) { 754 zerror(zlogp, B_TRUE, "unable to remove autofs nodes"); 755 error++; 756 goto out; 757 } 758 } 759 760 out: 761 free_remote_fstypes(remote_fstypes); 762 (void) fclose(mnttab); 763 return (error ? -1 : 0); 764 } 765 766 static int 767 fs_compare(const void *m1, const void *m2) 768 { 769 struct zone_fstab *i = (struct zone_fstab *)m1; 770 struct zone_fstab *j = (struct zone_fstab *)m2; 771 772 return (strcmp(i->zone_fs_dir, j->zone_fs_dir)); 773 } 774 775 /* 776 * Fork and exec (and wait for) the mentioned binary with the provided 777 * arguments. Returns (-1) if something went wrong with fork(2) or exec(2), 778 * returns the exit status otherwise. 779 * 780 * If we were unable to exec the provided pathname (for whatever 781 * reason), we return the special token ZEXIT_EXEC. The current value 782 * of ZEXIT_EXEC doesn't conflict with legitimate exit codes of the 783 * consumers of this function; any future consumers must make sure this 784 * remains the case. 785 */ 786 static int 787 forkexec(zlog_t *zlogp, const char *path, char *const argv[]) 788 { 789 pid_t child_pid; 790 int child_status = 0; 791 792 /* 793 * Do not let another thread localize a message while we are forking. 794 */ 795 (void) mutex_lock(&msglock); 796 child_pid = fork(); 797 (void) mutex_unlock(&msglock); 798 if (child_pid == -1) { 799 zerror(zlogp, B_TRUE, "could not fork for %s", argv[0]); 800 return (-1); 801 } else if (child_pid == 0) { 802 closefrom(0); 803 /* redirect stdin, stdout & stderr to /dev/null */ 804 (void) open("/dev/null", O_RDONLY); /* stdin */ 805 (void) open("/dev/null", O_WRONLY); /* stdout */ 806 (void) open("/dev/null", O_WRONLY); /* stderr */ 807 (void) execv(path, argv); 808 /* 809 * Since we are in the child, there is no point calling zerror() 810 * since there is nobody waiting to consume it. So exit with a 811 * special code that the parent will recognize and call zerror() 812 * accordingly. 813 */ 814 815 _exit(ZEXIT_EXEC); 816 } else { 817 (void) waitpid(child_pid, &child_status, 0); 818 } 819 820 if (WIFSIGNALED(child_status)) { 821 zerror(zlogp, B_FALSE, "%s unexpectedly terminated due to " 822 "signal %d", path, WTERMSIG(child_status)); 823 return (-1); 824 } 825 assert(WIFEXITED(child_status)); 826 if (WEXITSTATUS(child_status) == ZEXIT_EXEC) { 827 zerror(zlogp, B_FALSE, "failed to exec %s", path); 828 return (-1); 829 } 830 return (WEXITSTATUS(child_status)); 831 } 832 833 static int 834 isregfile(const char *path) 835 { 836 struct stat64 st; 837 838 if (stat64(path, &st) == -1) 839 return (-1); 840 841 return (S_ISREG(st.st_mode)); 842 } 843 844 static int 845 dofsck(zlog_t *zlogp, const char *fstype, const char *rawdev) 846 { 847 char cmdbuf[MAXPATHLEN]; 848 char *argv[5]; 849 int status; 850 851 /* 852 * We could alternatively have called /usr/sbin/fsck -F <fstype>, but 853 * that would cost us an extra fork/exec without buying us anything. 854 */ 855 if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/lib/fs/%s/fsck", fstype) 856 >= sizeof (cmdbuf)) { 857 zerror(zlogp, B_FALSE, "file-system type %s too long", fstype); 858 return (-1); 859 } 860 861 /* 862 * If it doesn't exist, that's OK: we verified this previously 863 * in zoneadm. 864 */ 865 if (isregfile(cmdbuf) == -1) 866 return (0); 867 868 argv[0] = "fsck"; 869 argv[1] = "-o"; 870 argv[2] = "p"; 871 argv[3] = (char *)rawdev; 872 argv[4] = NULL; 873 874 status = forkexec(zlogp, cmdbuf, argv); 875 if (status == 0 || status == -1) 876 return (status); 877 zerror(zlogp, B_FALSE, "fsck of '%s' failed with exit status %d; " 878 "run fsck manually", rawdev, status); 879 return (-1); 880 } 881 882 static int 883 domount(zlog_t *zlogp, const char *fstype, const char *opts, 884 const char *special, const char *directory) 885 { 886 char cmdbuf[MAXPATHLEN]; 887 char *argv[6]; 888 int status; 889 890 /* 891 * We could alternatively have called /usr/sbin/mount -F <fstype>, but 892 * that would cost us an extra fork/exec without buying us anything. 893 */ 894 if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/lib/fs/%s/mount", fstype) 895 >= sizeof (cmdbuf)) { 896 zerror(zlogp, B_FALSE, "file-system type %s too long", fstype); 897 return (-1); 898 } 899 argv[0] = "mount"; 900 if (opts[0] == '\0') { 901 argv[1] = (char *)special; 902 argv[2] = (char *)directory; 903 argv[3] = NULL; 904 } else { 905 argv[1] = "-o"; 906 argv[2] = (char *)opts; 907 argv[3] = (char *)special; 908 argv[4] = (char *)directory; 909 argv[5] = NULL; 910 } 911 912 status = forkexec(zlogp, cmdbuf, argv); 913 if (status == 0 || status == -1) 914 return (status); 915 if (opts[0] == '\0') 916 zerror(zlogp, B_FALSE, "\"%s %s %s\" " 917 "failed with exit code %d", 918 cmdbuf, special, directory, status); 919 else 920 zerror(zlogp, B_FALSE, "\"%s -o %s %s %s\" " 921 "failed with exit code %d", 922 cmdbuf, opts, special, directory, status); 923 return (-1); 924 } 925 926 /* 927 * Check if a given mount point path exists. 928 * If it does, make sure it doesn't contain any symlinks. 929 * Note that if "leaf" is false we're checking an intermediate 930 * component of the mount point path, so it must be a directory. 931 * If "leaf" is true, then we're checking the entire mount point 932 * path, so the mount point itself can be anything aside from a 933 * symbolic link. 934 * 935 * If the path is invalid then a negative value is returned. If the 936 * path exists and is a valid mount point path then 0 is returned. 937 * If the path doesn't exist return a positive value. 938 */ 939 static int 940 valid_mount_point(zlog_t *zlogp, const char *path, const boolean_t leaf) 941 { 942 struct stat statbuf; 943 char respath[MAXPATHLEN]; 944 int res; 945 946 if (lstat(path, &statbuf) != 0) { 947 if (errno == ENOENT) 948 return (1); 949 zerror(zlogp, B_TRUE, "can't stat %s", path); 950 return (-1); 951 } 952 if (S_ISLNK(statbuf.st_mode)) { 953 zerror(zlogp, B_FALSE, "%s is a symlink", path); 954 return (-1); 955 } 956 if (!leaf && !S_ISDIR(statbuf.st_mode)) { 957 zerror(zlogp, B_FALSE, "%s is not a directory", path); 958 return (-1); 959 } 960 if ((res = resolvepath(path, respath, sizeof (respath))) == -1) { 961 zerror(zlogp, B_TRUE, "unable to resolve path %s", path); 962 return (-1); 963 } 964 respath[res] = '\0'; 965 if (strcmp(path, respath) != 0) { 966 /* 967 * We don't like ".."s, "."s, or "//"s throwing us off 968 */ 969 zerror(zlogp, B_FALSE, "%s is not a canonical path", path); 970 return (-1); 971 } 972 return (0); 973 } 974 975 /* 976 * Validate a mount point path. A valid mount point path is an 977 * absolute path that either doesn't exist, or, if it does exists it 978 * must be an absolute canonical path that doesn't have any symbolic 979 * links in it. The target of a mount point path can be any filesystem 980 * object. (Different filesystems can support different mount points, 981 * for example "lofs" and "mntfs" both support files and directories 982 * while "ufs" just supports directories.) 983 * 984 * If the path is invalid then a negative value is returned. If the 985 * path exists and is a valid mount point path then 0 is returned. 986 * If the path doesn't exist return a positive value. 987 */ 988 int 989 valid_mount_path(zlog_t *zlogp, const char *rootpath, const char *spec, 990 const char *dir, const char *fstype) 991 { 992 char abspath[MAXPATHLEN], *slashp, *slashp_next; 993 int rv; 994 995 /* 996 * Sanity check the target mount point path. 997 * It must be a non-null string that starts with a '/'. 998 */ 999 if (dir[0] != '/') { 1000 /* Something went wrong. */ 1001 zerror(zlogp, B_FALSE, "invalid mount directory, " 1002 "type: \"%s\", special: \"%s\", dir: \"%s\"", 1003 fstype, spec, dir); 1004 return (-1); 1005 } 1006 1007 /* 1008 * Join rootpath and dir. Make sure abspath ends with '/', this 1009 * is added to all paths (even non-directory paths) to allow us 1010 * to detect the end of paths below. If the path already ends 1011 * in a '/', then that's ok too (although we'll fail the 1012 * cannonical path check in valid_mount_point()). 1013 */ 1014 if (snprintf(abspath, sizeof (abspath), 1015 "%s%s/", rootpath, dir) >= sizeof (abspath)) { 1016 zerror(zlogp, B_FALSE, "pathname %s%s is too long", 1017 rootpath, dir); 1018 return (-1); 1019 } 1020 1021 /* 1022 * Starting with rootpath, verify the mount path one component 1023 * at a time. Continue until we've evaluated all of abspath. 1024 */ 1025 slashp = &abspath[strlen(rootpath)]; 1026 assert(*slashp == '/'); 1027 do { 1028 slashp_next = strchr(slashp + 1, '/'); 1029 *slashp = '\0'; 1030 if (slashp_next != NULL) { 1031 /* This is an intermediary mount path component. */ 1032 rv = valid_mount_point(zlogp, abspath, B_FALSE); 1033 } else { 1034 /* This is the last component of the mount path. */ 1035 rv = valid_mount_point(zlogp, abspath, B_TRUE); 1036 } 1037 if (rv < 0) 1038 return (rv); 1039 *slashp = '/'; 1040 } while ((slashp = slashp_next) != NULL); 1041 return (rv); 1042 } 1043 1044 static int 1045 mount_one_dev_device_cb(void *arg, const char *match, const char *name) 1046 { 1047 di_prof_t prof = arg; 1048 1049 if (name == NULL) 1050 return (di_prof_add_dev(prof, match)); 1051 return (di_prof_add_map(prof, match, name)); 1052 } 1053 1054 static int 1055 mount_one_dev_symlink_cb(void *arg, const char *source, const char *target) 1056 { 1057 di_prof_t prof = arg; 1058 1059 return (di_prof_add_symlink(prof, source, target)); 1060 } 1061 1062 int 1063 vplat_get_iptype(zlog_t *zlogp, zone_iptype_t *iptypep) 1064 { 1065 zone_dochandle_t handle; 1066 1067 if ((handle = zonecfg_init_handle()) == NULL) { 1068 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 1069 return (-1); 1070 } 1071 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 1072 zerror(zlogp, B_FALSE, "invalid configuration"); 1073 zonecfg_fini_handle(handle); 1074 return (-1); 1075 } 1076 if (zonecfg_get_iptype(handle, iptypep) != Z_OK) { 1077 zerror(zlogp, B_FALSE, "invalid ip-type configuration"); 1078 zonecfg_fini_handle(handle); 1079 return (-1); 1080 } 1081 zonecfg_fini_handle(handle); 1082 return (0); 1083 } 1084 1085 /* 1086 * Apply the standard lists of devices/symlinks/mappings and the user-specified 1087 * list of devices (via zonecfg) to the /dev filesystem. The filesystem will 1088 * use these as a profile/filter to determine what exists in /dev. 1089 */ 1090 static int 1091 mount_one_dev(zlog_t *zlogp, char *devpath, zone_mnt_t mount_cmd) 1092 { 1093 char brand[MAXNAMELEN]; 1094 zone_dochandle_t handle = NULL; 1095 brand_handle_t bh = NULL; 1096 struct zone_devtab ztab; 1097 di_prof_t prof = NULL; 1098 int err; 1099 int retval = -1; 1100 zone_iptype_t iptype; 1101 const char *curr_iptype; 1102 1103 if (di_prof_init(devpath, &prof)) { 1104 zerror(zlogp, B_TRUE, "failed to initialize profile"); 1105 goto cleanup; 1106 } 1107 1108 /* 1109 * Get a handle to the brand info for this zone. 1110 * If we are mounting the zone, then we must always use the default 1111 * brand device mounts. 1112 */ 1113 if (ALT_MOUNT(mount_cmd)) { 1114 (void) strlcpy(brand, default_brand, sizeof (brand)); 1115 } else { 1116 (void) strlcpy(brand, brand_name, sizeof (brand)); 1117 } 1118 1119 if ((bh = brand_open(brand)) == NULL) { 1120 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 1121 goto cleanup; 1122 } 1123 1124 if (vplat_get_iptype(zlogp, &iptype) < 0) { 1125 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 1126 goto cleanup; 1127 } 1128 switch (iptype) { 1129 case ZS_SHARED: 1130 curr_iptype = "shared"; 1131 break; 1132 case ZS_EXCLUSIVE: 1133 curr_iptype = "exclusive"; 1134 break; 1135 } 1136 1137 if (brand_platform_iter_devices(bh, zone_name, 1138 mount_one_dev_device_cb, prof, curr_iptype) != 0) { 1139 zerror(zlogp, B_TRUE, "failed to add standard device"); 1140 goto cleanup; 1141 } 1142 1143 if (brand_platform_iter_link(bh, 1144 mount_one_dev_symlink_cb, prof) != 0) { 1145 zerror(zlogp, B_TRUE, "failed to add standard symlink"); 1146 goto cleanup; 1147 } 1148 1149 /* Add user-specified devices and directories */ 1150 if ((handle = zonecfg_init_handle()) == NULL) { 1151 zerror(zlogp, B_FALSE, "can't initialize zone handle"); 1152 goto cleanup; 1153 } 1154 if (err = zonecfg_get_handle(zone_name, handle)) { 1155 zerror(zlogp, B_FALSE, "can't get handle for zone " 1156 "%s: %s", zone_name, zonecfg_strerror(err)); 1157 goto cleanup; 1158 } 1159 if (err = zonecfg_setdevent(handle)) { 1160 zerror(zlogp, B_FALSE, "%s: %s", zone_name, 1161 zonecfg_strerror(err)); 1162 goto cleanup; 1163 } 1164 while (zonecfg_getdevent(handle, &ztab) == Z_OK) { 1165 if (di_prof_add_dev(prof, ztab.zone_dev_match)) { 1166 zerror(zlogp, B_TRUE, "failed to add " 1167 "user-specified device"); 1168 goto cleanup; 1169 } 1170 } 1171 (void) zonecfg_enddevent(handle); 1172 1173 /* Send profile to kernel */ 1174 if (di_prof_commit(prof)) { 1175 zerror(zlogp, B_TRUE, "failed to commit profile"); 1176 goto cleanup; 1177 } 1178 1179 retval = 0; 1180 1181 cleanup: 1182 if (bh != NULL) 1183 brand_close(bh); 1184 if (handle != NULL) 1185 zonecfg_fini_handle(handle); 1186 if (prof) 1187 di_prof_fini(prof); 1188 return (retval); 1189 } 1190 1191 static int 1192 mount_one(zlog_t *zlogp, struct zone_fstab *fsptr, const char *rootpath, 1193 zone_mnt_t mount_cmd) 1194 { 1195 char path[MAXPATHLEN]; 1196 char optstr[MAX_MNTOPT_STR]; 1197 zone_fsopt_t *optptr; 1198 int rv; 1199 1200 if ((rv = valid_mount_path(zlogp, rootpath, fsptr->zone_fs_special, 1201 fsptr->zone_fs_dir, fsptr->zone_fs_type)) < 0) { 1202 zerror(zlogp, B_FALSE, "%s%s is not a valid mount point", 1203 rootpath, fsptr->zone_fs_dir); 1204 return (-1); 1205 } else if (rv > 0) { 1206 /* The mount point path doesn't exist, create it now. */ 1207 if (make_one_dir(zlogp, rootpath, fsptr->zone_fs_dir, 1208 DEFAULT_DIR_MODE, DEFAULT_DIR_USER, 1209 DEFAULT_DIR_GROUP) != 0) { 1210 zerror(zlogp, B_FALSE, "failed to create mount point"); 1211 return (-1); 1212 } 1213 1214 /* 1215 * Now this might seem weird, but we need to invoke 1216 * valid_mount_path() again. Why? Because it checks 1217 * to make sure that the mount point path is canonical, 1218 * which it can only do if the path exists, so now that 1219 * we've created the path we have to verify it again. 1220 */ 1221 if ((rv = valid_mount_path(zlogp, rootpath, 1222 fsptr->zone_fs_special, fsptr->zone_fs_dir, 1223 fsptr->zone_fs_type)) < 0) { 1224 zerror(zlogp, B_FALSE, 1225 "%s%s is not a valid mount point", 1226 rootpath, fsptr->zone_fs_dir); 1227 return (-1); 1228 } 1229 } 1230 1231 (void) snprintf(path, sizeof (path), "%s%s", rootpath, 1232 fsptr->zone_fs_dir); 1233 1234 /* 1235 * In general the strategy here is to do just as much verification as 1236 * necessary to avoid crashing or otherwise doing something bad; if the 1237 * administrator initiated the operation via zoneadm(1m), he'll get 1238 * auto-verification which will let him know what's wrong. If he 1239 * modifies the zone configuration of a running zone and doesn't attempt 1240 * to verify that it's OK we won't crash but won't bother trying to be 1241 * too helpful either. zoneadm verify is only a couple keystrokes away. 1242 */ 1243 if (!zonecfg_valid_fs_type(fsptr->zone_fs_type)) { 1244 zerror(zlogp, B_FALSE, "cannot mount %s on %s: " 1245 "invalid file-system type %s", fsptr->zone_fs_special, 1246 fsptr->zone_fs_dir, fsptr->zone_fs_type); 1247 return (-1); 1248 } 1249 1250 /* 1251 * If we're looking at an alternate root environment, then construct 1252 * read-only loopback mounts as necessary. Note that any special 1253 * paths for lofs zone mounts in an alternate root must have 1254 * already been pre-pended with any alternate root path by the 1255 * time we get here. 1256 */ 1257 if (zonecfg_in_alt_root()) { 1258 struct stat64 st; 1259 1260 if (stat64(fsptr->zone_fs_special, &st) != -1 && 1261 S_ISBLK(st.st_mode)) { 1262 /* 1263 * If we're going to mount a block device we need 1264 * to check if that device is already mounted 1265 * somewhere else, and if so, do a lofs mount 1266 * of the device instead of a direct mount 1267 */ 1268 if (check_lofs_needed(zlogp, fsptr) == -1) 1269 return (-1); 1270 } else if (strcmp(fsptr->zone_fs_type, MNTTYPE_LOFS) == 0) { 1271 /* 1272 * For lofs mounts, the special node is inside the 1273 * alternate root. We need lofs resolution for 1274 * this case in order to get at the underlying 1275 * read-write path. 1276 */ 1277 resolve_lofs(zlogp, fsptr->zone_fs_special, 1278 sizeof (fsptr->zone_fs_special)); 1279 } 1280 } 1281 1282 /* 1283 * Run 'fsck -m' if there's a device to fsck. 1284 */ 1285 if (fsptr->zone_fs_raw[0] != '\0' && 1286 dofsck(zlogp, fsptr->zone_fs_type, fsptr->zone_fs_raw) != 0) { 1287 return (-1); 1288 } else if (isregfile(fsptr->zone_fs_special) == 1 && 1289 dofsck(zlogp, fsptr->zone_fs_type, fsptr->zone_fs_special) != 0) { 1290 return (-1); 1291 } 1292 1293 /* 1294 * Build up mount option string. 1295 */ 1296 optstr[0] = '\0'; 1297 if (fsptr->zone_fs_options != NULL) { 1298 (void) strlcpy(optstr, fsptr->zone_fs_options->zone_fsopt_opt, 1299 sizeof (optstr)); 1300 for (optptr = fsptr->zone_fs_options->zone_fsopt_next; 1301 optptr != NULL; optptr = optptr->zone_fsopt_next) { 1302 (void) strlcat(optstr, ",", sizeof (optstr)); 1303 (void) strlcat(optstr, optptr->zone_fsopt_opt, 1304 sizeof (optstr)); 1305 } 1306 } 1307 1308 if ((rv = domount(zlogp, fsptr->zone_fs_type, optstr, 1309 fsptr->zone_fs_special, path)) != 0) 1310 return (rv); 1311 1312 /* 1313 * The mount succeeded. If this was not a mount of /dev then 1314 * we're done. 1315 */ 1316 if (strcmp(fsptr->zone_fs_type, MNTTYPE_DEV) != 0) 1317 return (0); 1318 1319 /* 1320 * We just mounted an instance of a /dev filesystem, so now we 1321 * need to configure it. 1322 */ 1323 return (mount_one_dev(zlogp, path, mount_cmd)); 1324 } 1325 1326 static void 1327 free_fs_data(struct zone_fstab *fsarray, uint_t nelem) 1328 { 1329 uint_t i; 1330 1331 if (fsarray == NULL) 1332 return; 1333 for (i = 0; i < nelem; i++) 1334 zonecfg_free_fs_option_list(fsarray[i].zone_fs_options); 1335 free(fsarray); 1336 } 1337 1338 /* 1339 * This function initiates the creation of a small Solaris Environment for 1340 * scratch zone. The Environment creation process is split up into two 1341 * functions(build_mounted_pre_var() and build_mounted_post_var()). It 1342 * is done this way because: 1343 * We need to have both /etc and /var in the root of the scratchzone. 1344 * We loopback mount zone's own /etc and /var into the root of the 1345 * scratch zone. Unlike /etc, /var can be a seperate filesystem. So we 1346 * need to delay the mount of /var till the zone's root gets populated. 1347 * So mounting of localdirs[](/etc and /var) have been moved to the 1348 * build_mounted_post_var() which gets called only after the zone 1349 * specific filesystems are mounted. 1350 * 1351 * Note that the scratch zone we set up for updating the zone (Z_MNT_UPDATE) 1352 * does not loopback mount the zone's own /etc and /var into the root of the 1353 * scratch zone. 1354 */ 1355 static boolean_t 1356 build_mounted_pre_var(zlog_t *zlogp, char *rootpath, 1357 size_t rootlen, const char *zonepath, char *luroot, size_t lurootlen) 1358 { 1359 char tmp[MAXPATHLEN], fromdir[MAXPATHLEN]; 1360 const char **cpp; 1361 static const char *mkdirs[] = { 1362 "/system", "/system/contract", "/system/object", "/proc", 1363 "/dev", "/tmp", "/a", NULL 1364 }; 1365 char *altstr; 1366 FILE *fp; 1367 uuid_t uuid; 1368 1369 resolve_lofs(zlogp, rootpath, rootlen); 1370 (void) snprintf(luroot, lurootlen, "%s/lu", zonepath); 1371 resolve_lofs(zlogp, luroot, lurootlen); 1372 (void) snprintf(tmp, sizeof (tmp), "%s/bin", luroot); 1373 (void) symlink("./usr/bin", tmp); 1374 1375 /* 1376 * These are mostly special mount points; not handled here. (See 1377 * zone_mount_early.) 1378 */ 1379 for (cpp = mkdirs; *cpp != NULL; cpp++) { 1380 (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 1381 if (mkdir(tmp, 0755) != 0) { 1382 zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1383 return (B_FALSE); 1384 } 1385 } 1386 /* 1387 * This is here to support lucopy. If there's an instance of this same 1388 * zone on the current running system, then we mount its root up as 1389 * read-only inside the scratch zone. 1390 */ 1391 (void) zonecfg_get_uuid(zone_name, uuid); 1392 altstr = strdup(zonecfg_get_root()); 1393 if (altstr == NULL) { 1394 zerror(zlogp, B_TRUE, "memory allocation failed"); 1395 return (B_FALSE); 1396 } 1397 zonecfg_set_root(""); 1398 (void) strlcpy(tmp, zone_name, sizeof (tmp)); 1399 (void) zonecfg_get_name_by_uuid(uuid, tmp, sizeof (tmp)); 1400 if (zone_get_rootpath(tmp, fromdir, sizeof (fromdir)) == Z_OK && 1401 strcmp(fromdir, rootpath) != 0) { 1402 (void) snprintf(tmp, sizeof (tmp), "%s/b", luroot); 1403 if (mkdir(tmp, 0755) != 0) { 1404 zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1405 return (B_FALSE); 1406 } 1407 if (domount(zlogp, MNTTYPE_LOFS, RESOURCE_DEFAULT_OPTS, fromdir, 1408 tmp) != 0) { 1409 zerror(zlogp, B_TRUE, "cannot mount %s on %s", tmp, 1410 fromdir); 1411 return (B_FALSE); 1412 } 1413 } 1414 zonecfg_set_root(altstr); 1415 free(altstr); 1416 1417 if ((fp = zonecfg_open_scratch(luroot, B_TRUE)) == NULL) { 1418 zerror(zlogp, B_TRUE, "cannot open zone mapfile"); 1419 return (B_FALSE); 1420 } 1421 (void) ftruncate(fileno(fp), 0); 1422 if (zonecfg_add_scratch(fp, zone_name, kernzone, "/") == -1) { 1423 zerror(zlogp, B_TRUE, "cannot add zone mapfile entry"); 1424 } 1425 zonecfg_close_scratch(fp); 1426 (void) snprintf(tmp, sizeof (tmp), "%s/a", luroot); 1427 if (domount(zlogp, MNTTYPE_LOFS, "", rootpath, tmp) != 0) 1428 return (B_FALSE); 1429 (void) strlcpy(rootpath, tmp, rootlen); 1430 return (B_TRUE); 1431 } 1432 1433 1434 static boolean_t 1435 build_mounted_post_var(zlog_t *zlogp, zone_mnt_t mount_cmd, char *rootpath, 1436 const char *luroot) 1437 { 1438 char tmp[MAXPATHLEN], fromdir[MAXPATHLEN]; 1439 const char **cpp; 1440 const char **loopdirs; 1441 const char **tmpdirs; 1442 static const char *localdirs[] = { 1443 "/etc", "/var", NULL 1444 }; 1445 static const char *scr_loopdirs[] = { 1446 "/etc/lib", "/etc/fs", "/lib", "/sbin", "/platform", 1447 "/usr", NULL 1448 }; 1449 static const char *upd_loopdirs[] = { 1450 "/etc", "/kernel", "/lib", "/opt", "/platform", "/sbin", 1451 "/usr", "/var", NULL 1452 }; 1453 static const char *scr_tmpdirs[] = { 1454 "/tmp", "/var/run", NULL 1455 }; 1456 static const char *upd_tmpdirs[] = { 1457 "/tmp", "/var/run", "/var/tmp", NULL 1458 }; 1459 struct stat st; 1460 1461 if (mount_cmd == Z_MNT_SCRATCH) { 1462 /* 1463 * These are mounted read-write from the zone undergoing 1464 * upgrade. We must be careful not to 'leak' things from the 1465 * main system into the zone, and this accomplishes that goal. 1466 */ 1467 for (cpp = localdirs; *cpp != NULL; cpp++) { 1468 (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, 1469 *cpp); 1470 (void) snprintf(fromdir, sizeof (fromdir), "%s%s", 1471 rootpath, *cpp); 1472 if (mkdir(tmp, 0755) != 0) { 1473 zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1474 return (B_FALSE); 1475 } 1476 if (domount(zlogp, MNTTYPE_LOFS, "", fromdir, tmp) 1477 != 0) { 1478 zerror(zlogp, B_TRUE, "cannot mount %s on %s", 1479 tmp, *cpp); 1480 return (B_FALSE); 1481 } 1482 } 1483 } 1484 1485 if (mount_cmd == Z_MNT_UPDATE) 1486 loopdirs = upd_loopdirs; 1487 else 1488 loopdirs = scr_loopdirs; 1489 1490 /* 1491 * These are things mounted read-only from the running system because 1492 * they contain binaries that must match system. 1493 */ 1494 for (cpp = loopdirs; *cpp != NULL; cpp++) { 1495 (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 1496 if (mkdir(tmp, 0755) != 0) { 1497 if (errno != EEXIST) { 1498 zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1499 return (B_FALSE); 1500 } 1501 if (lstat(tmp, &st) != 0) { 1502 zerror(zlogp, B_TRUE, "cannot stat %s", tmp); 1503 return (B_FALSE); 1504 } 1505 /* 1506 * Ignore any non-directories encountered. These are 1507 * things that have been converted into symlinks 1508 * (/etc/fs and /etc/lib) and no longer need a lofs 1509 * fixup. 1510 */ 1511 if (!S_ISDIR(st.st_mode)) 1512 continue; 1513 } 1514 if (domount(zlogp, MNTTYPE_LOFS, RESOURCE_DEFAULT_OPTS, *cpp, 1515 tmp) != 0) { 1516 zerror(zlogp, B_TRUE, "cannot mount %s on %s", tmp, 1517 *cpp); 1518 return (B_FALSE); 1519 } 1520 } 1521 1522 if (mount_cmd == Z_MNT_UPDATE) 1523 tmpdirs = upd_tmpdirs; 1524 else 1525 tmpdirs = scr_tmpdirs; 1526 1527 /* 1528 * These are things with tmpfs mounted inside. 1529 */ 1530 for (cpp = tmpdirs; *cpp != NULL; cpp++) { 1531 (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 1532 if (mount_cmd == Z_MNT_SCRATCH && mkdir(tmp, 0755) != 0 && 1533 errno != EEXIST) { 1534 zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1535 return (B_FALSE); 1536 } 1537 1538 /* 1539 * We could set the mode for /tmp when we do the mkdir but 1540 * since that can be modified by the umask we will just set 1541 * the correct mode for /tmp now. 1542 */ 1543 if (strcmp(*cpp, "/tmp") == 0 && chmod(tmp, 01777) != 0) { 1544 zerror(zlogp, B_TRUE, "cannot chmod %s", tmp); 1545 return (B_FALSE); 1546 } 1547 1548 if (domount(zlogp, MNTTYPE_TMPFS, "", "swap", tmp) != 0) { 1549 zerror(zlogp, B_TRUE, "cannot mount swap on %s", *cpp); 1550 return (B_FALSE); 1551 } 1552 } 1553 return (B_TRUE); 1554 } 1555 1556 typedef struct plat_gmount_cb_data { 1557 zlog_t *pgcd_zlogp; 1558 struct zone_fstab **pgcd_fs_tab; 1559 int *pgcd_num_fs; 1560 } plat_gmount_cb_data_t; 1561 1562 /* 1563 * plat_gmount_cb() is a callback function invoked by libbrand to iterate 1564 * through all global brand platform mounts. 1565 */ 1566 int 1567 plat_gmount_cb(void *data, const char *spec, const char *dir, 1568 const char *fstype, const char *opt) 1569 { 1570 plat_gmount_cb_data_t *cp = data; 1571 zlog_t *zlogp = cp->pgcd_zlogp; 1572 struct zone_fstab *fs_ptr = *cp->pgcd_fs_tab; 1573 int num_fs = *cp->pgcd_num_fs; 1574 struct zone_fstab *fsp, *tmp_ptr; 1575 1576 num_fs++; 1577 if ((tmp_ptr = realloc(fs_ptr, num_fs * sizeof (*tmp_ptr))) == NULL) { 1578 zerror(zlogp, B_TRUE, "memory allocation failed"); 1579 return (-1); 1580 } 1581 1582 fs_ptr = tmp_ptr; 1583 fsp = &fs_ptr[num_fs - 1]; 1584 1585 /* update the callback struct passed in */ 1586 *cp->pgcd_fs_tab = fs_ptr; 1587 *cp->pgcd_num_fs = num_fs; 1588 1589 fsp->zone_fs_raw[0] = '\0'; 1590 (void) strlcpy(fsp->zone_fs_special, spec, 1591 sizeof (fsp->zone_fs_special)); 1592 (void) strlcpy(fsp->zone_fs_dir, dir, sizeof (fsp->zone_fs_dir)); 1593 (void) strlcpy(fsp->zone_fs_type, fstype, sizeof (fsp->zone_fs_type)); 1594 fsp->zone_fs_options = NULL; 1595 if ((opt != NULL) && 1596 (zonecfg_add_fs_option(fsp, (char *)opt) != Z_OK)) { 1597 zerror(zlogp, B_FALSE, "error adding property"); 1598 return (-1); 1599 } 1600 1601 return (0); 1602 } 1603 1604 static int 1605 mount_filesystems_fsent(zone_dochandle_t handle, zlog_t *zlogp, 1606 struct zone_fstab **fs_tabp, int *num_fsp, zone_mnt_t mount_cmd) 1607 { 1608 struct zone_fstab *tmp_ptr, *fs_ptr, *fsp, fstab; 1609 int num_fs; 1610 1611 num_fs = *num_fsp; 1612 fs_ptr = *fs_tabp; 1613 1614 if (zonecfg_setfsent(handle) != Z_OK) { 1615 zerror(zlogp, B_FALSE, "invalid configuration"); 1616 return (-1); 1617 } 1618 while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 1619 /* 1620 * ZFS filesystems will not be accessible under an alternate 1621 * root, since the pool will not be known. Ignore them in this 1622 * case. 1623 */ 1624 if (ALT_MOUNT(mount_cmd) && 1625 strcmp(fstab.zone_fs_type, MNTTYPE_ZFS) == 0) 1626 continue; 1627 1628 num_fs++; 1629 if ((tmp_ptr = realloc(fs_ptr, 1630 num_fs * sizeof (*tmp_ptr))) == NULL) { 1631 zerror(zlogp, B_TRUE, "memory allocation failed"); 1632 (void) zonecfg_endfsent(handle); 1633 return (-1); 1634 } 1635 /* update the pointers passed in */ 1636 *fs_tabp = tmp_ptr; 1637 *num_fsp = num_fs; 1638 1639 fs_ptr = tmp_ptr; 1640 fsp = &fs_ptr[num_fs - 1]; 1641 (void) strlcpy(fsp->zone_fs_dir, 1642 fstab.zone_fs_dir, sizeof (fsp->zone_fs_dir)); 1643 (void) strlcpy(fsp->zone_fs_raw, fstab.zone_fs_raw, 1644 sizeof (fsp->zone_fs_raw)); 1645 (void) strlcpy(fsp->zone_fs_type, fstab.zone_fs_type, 1646 sizeof (fsp->zone_fs_type)); 1647 fsp->zone_fs_options = fstab.zone_fs_options; 1648 1649 /* 1650 * For all lofs mounts, make sure that the 'special' 1651 * entry points inside the alternate root. The 1652 * source path for a lofs mount in a given zone needs 1653 * to be relative to the root of the boot environment 1654 * that contains the zone. Note that we don't do this 1655 * for non-lofs mounts since they will have a device 1656 * as a backing store and device paths must always be 1657 * specified relative to the current boot environment. 1658 */ 1659 fsp->zone_fs_special[0] = '\0'; 1660 if (strcmp(fsp->zone_fs_type, MNTTYPE_LOFS) == 0) { 1661 (void) strlcat(fsp->zone_fs_special, zonecfg_get_root(), 1662 sizeof (fsp->zone_fs_special)); 1663 } 1664 (void) strlcat(fsp->zone_fs_special, fstab.zone_fs_special, 1665 sizeof (fsp->zone_fs_special)); 1666 } 1667 (void) zonecfg_endfsent(handle); 1668 return (0); 1669 } 1670 1671 static int 1672 mount_filesystems(zlog_t *zlogp, zone_mnt_t mount_cmd) 1673 { 1674 char rootpath[MAXPATHLEN]; 1675 char zonepath[MAXPATHLEN]; 1676 char brand[MAXNAMELEN]; 1677 char luroot[MAXPATHLEN]; 1678 int i, num_fs = 0; 1679 struct zone_fstab *fs_ptr = NULL; 1680 zone_dochandle_t handle = NULL; 1681 zone_state_t zstate; 1682 brand_handle_t bh; 1683 plat_gmount_cb_data_t cb; 1684 1685 if (zone_get_state(zone_name, &zstate) != Z_OK || 1686 (zstate != ZONE_STATE_READY && zstate != ZONE_STATE_MOUNTED)) { 1687 zerror(zlogp, B_FALSE, 1688 "zone must be in '%s' or '%s' state to mount file-systems", 1689 zone_state_str(ZONE_STATE_READY), 1690 zone_state_str(ZONE_STATE_MOUNTED)); 1691 goto bad; 1692 } 1693 1694 if (zone_get_zonepath(zone_name, zonepath, sizeof (zonepath)) != Z_OK) { 1695 zerror(zlogp, B_TRUE, "unable to determine zone path"); 1696 goto bad; 1697 } 1698 1699 if (zone_get_rootpath(zone_name, rootpath, sizeof (rootpath)) != Z_OK) { 1700 zerror(zlogp, B_TRUE, "unable to determine zone root"); 1701 goto bad; 1702 } 1703 1704 if ((handle = zonecfg_init_handle()) == NULL) { 1705 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 1706 goto bad; 1707 } 1708 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK || 1709 zonecfg_setfsent(handle) != Z_OK) { 1710 zerror(zlogp, B_FALSE, "invalid configuration"); 1711 goto bad; 1712 } 1713 1714 /* 1715 * If we are mounting the zone, then we must always use the default 1716 * brand global mounts. 1717 */ 1718 if (ALT_MOUNT(mount_cmd)) { 1719 (void) strlcpy(brand, default_brand, sizeof (brand)); 1720 } else { 1721 (void) strlcpy(brand, brand_name, sizeof (brand)); 1722 } 1723 1724 /* Get a handle to the brand info for this zone */ 1725 if ((bh = brand_open(brand)) == NULL) { 1726 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 1727 zonecfg_fini_handle(handle); 1728 return (-1); 1729 } 1730 1731 /* 1732 * Get the list of global filesystems to mount from the brand 1733 * configuration. 1734 */ 1735 cb.pgcd_zlogp = zlogp; 1736 cb.pgcd_fs_tab = &fs_ptr; 1737 cb.pgcd_num_fs = &num_fs; 1738 if (brand_platform_iter_gmounts(bh, zone_name, zonepath, 1739 plat_gmount_cb, &cb) != 0) { 1740 zerror(zlogp, B_FALSE, "unable to mount filesystems"); 1741 brand_close(bh); 1742 zonecfg_fini_handle(handle); 1743 return (-1); 1744 } 1745 brand_close(bh); 1746 1747 /* 1748 * Iterate through the rest of the filesystems. Sort them all, 1749 * then mount them in sorted order. This is to make sure the 1750 * higher level directories (e.g., /usr) get mounted before 1751 * any beneath them (e.g., /usr/local). 1752 */ 1753 if (mount_filesystems_fsent(handle, zlogp, &fs_ptr, &num_fs, 1754 mount_cmd) != 0) 1755 goto bad; 1756 1757 zonecfg_fini_handle(handle); 1758 handle = NULL; 1759 1760 /* 1761 * Normally when we mount a zone all the zone filesystems 1762 * get mounted relative to rootpath, which is usually 1763 * <zonepath>/root. But when mounting a zone for administration 1764 * purposes via the zone "mount" state, build_mounted_pre_var() 1765 * updates rootpath to be <zonepath>/lu/a so we'll mount all 1766 * the zones filesystems there instead. 1767 * 1768 * build_mounted_pre_var() and build_mounted_post_var() will 1769 * also do some extra work to create directories and lofs mount 1770 * a bunch of global zone file system paths into <zonepath>/lu. 1771 * 1772 * This allows us to be able to enter the zone (now rooted at 1773 * <zonepath>/lu) and run the upgrade/patch tools that are in the 1774 * global zone and have them upgrade the to-be-modified zone's 1775 * files mounted on /a. (Which mirrors the existing standard 1776 * upgrade environment.) 1777 * 1778 * There is of course one catch. When doing the upgrade 1779 * we need <zoneroot>/lu/dev to be the /dev filesystem 1780 * for the zone and we don't want to have any /dev filesystem 1781 * mounted at <zoneroot>/lu/a/dev. Since /dev is specified 1782 * as a normal zone filesystem by default we'll try to mount 1783 * it at <zoneroot>/lu/a/dev, so we have to detect this 1784 * case and instead mount it at <zoneroot>/lu/dev. 1785 * 1786 * All this work is done in three phases: 1787 * 1) Create and populate lu directory (build_mounted_pre_var()). 1788 * 2) Mount the required filesystems as per the zone configuration. 1789 * 3) Set up the rest of the scratch zone environment 1790 * (build_mounted_post_var()). 1791 */ 1792 if (ALT_MOUNT(mount_cmd) && !build_mounted_pre_var(zlogp, 1793 rootpath, sizeof (rootpath), zonepath, luroot, sizeof (luroot))) 1794 goto bad; 1795 1796 qsort(fs_ptr, num_fs, sizeof (*fs_ptr), fs_compare); 1797 1798 for (i = 0; i < num_fs; i++) { 1799 if (ALT_MOUNT(mount_cmd) && 1800 strcmp(fs_ptr[i].zone_fs_dir, "/dev") == 0) { 1801 size_t slen = strlen(rootpath) - 2; 1802 1803 /* 1804 * By default we'll try to mount /dev as /a/dev 1805 * but /dev is special and always goes at the top 1806 * so strip the trailing '/a' from the rootpath. 1807 */ 1808 assert(strcmp(&rootpath[slen], "/a") == 0); 1809 rootpath[slen] = '\0'; 1810 if (mount_one(zlogp, &fs_ptr[i], rootpath, mount_cmd) 1811 != 0) 1812 goto bad; 1813 rootpath[slen] = '/'; 1814 continue; 1815 } 1816 if (mount_one(zlogp, &fs_ptr[i], rootpath, mount_cmd) != 0) 1817 goto bad; 1818 } 1819 if (ALT_MOUNT(mount_cmd) && 1820 !build_mounted_post_var(zlogp, mount_cmd, rootpath, luroot)) 1821 goto bad; 1822 1823 /* 1824 * For Trusted Extensions cross-mount each lower level /export/home 1825 */ 1826 if (mount_cmd == Z_MNT_BOOT && 1827 tsol_mounts(zlogp, zone_name, rootpath) != 0) 1828 goto bad; 1829 1830 free_fs_data(fs_ptr, num_fs); 1831 1832 /* 1833 * Everything looks fine. 1834 */ 1835 return (0); 1836 1837 bad: 1838 if (handle != NULL) 1839 zonecfg_fini_handle(handle); 1840 free_fs_data(fs_ptr, num_fs); 1841 return (-1); 1842 } 1843 1844 /* caller makes sure neither parameter is NULL */ 1845 static int 1846 addr2netmask(char *prefixstr, int maxprefixlen, uchar_t *maskstr) 1847 { 1848 int prefixlen; 1849 1850 prefixlen = atoi(prefixstr); 1851 if (prefixlen < 0 || prefixlen > maxprefixlen) 1852 return (1); 1853 while (prefixlen > 0) { 1854 if (prefixlen >= 8) { 1855 *maskstr++ = 0xFF; 1856 prefixlen -= 8; 1857 continue; 1858 } 1859 *maskstr |= 1 << (8 - prefixlen); 1860 prefixlen--; 1861 } 1862 return (0); 1863 } 1864 1865 /* 1866 * Tear down all interfaces belonging to the given zone. This should 1867 * be called with the zone in a state other than "running", so that 1868 * interfaces can't be assigned to the zone after this returns. 1869 * 1870 * If anything goes wrong, log an error message and return an error. 1871 */ 1872 static int 1873 unconfigure_shared_network_interfaces(zlog_t *zlogp, zoneid_t zone_id) 1874 { 1875 struct lifnum lifn; 1876 struct lifconf lifc; 1877 struct lifreq *lifrp, lifrl; 1878 int64_t lifc_flags = LIFC_NOXMIT | LIFC_ALLZONES; 1879 int num_ifs, s, i, ret_code = 0; 1880 uint_t bufsize; 1881 char *buf = NULL; 1882 1883 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { 1884 zerror(zlogp, B_TRUE, "could not get socket"); 1885 ret_code = -1; 1886 goto bad; 1887 } 1888 lifn.lifn_family = AF_UNSPEC; 1889 lifn.lifn_flags = (int)lifc_flags; 1890 if (ioctl(s, SIOCGLIFNUM, (char *)&lifn) < 0) { 1891 zerror(zlogp, B_TRUE, 1892 "could not determine number of network interfaces"); 1893 ret_code = -1; 1894 goto bad; 1895 } 1896 num_ifs = lifn.lifn_count; 1897 bufsize = num_ifs * sizeof (struct lifreq); 1898 if ((buf = malloc(bufsize)) == NULL) { 1899 zerror(zlogp, B_TRUE, "memory allocation failed"); 1900 ret_code = -1; 1901 goto bad; 1902 } 1903 lifc.lifc_family = AF_UNSPEC; 1904 lifc.lifc_flags = (int)lifc_flags; 1905 lifc.lifc_len = bufsize; 1906 lifc.lifc_buf = buf; 1907 if (ioctl(s, SIOCGLIFCONF, (char *)&lifc) < 0) { 1908 zerror(zlogp, B_TRUE, "could not get configured network " 1909 "interfaces"); 1910 ret_code = -1; 1911 goto bad; 1912 } 1913 lifrp = lifc.lifc_req; 1914 for (i = lifc.lifc_len / sizeof (struct lifreq); i > 0; i--, lifrp++) { 1915 (void) close(s); 1916 if ((s = socket(lifrp->lifr_addr.ss_family, SOCK_DGRAM, 0)) < 1917 0) { 1918 zerror(zlogp, B_TRUE, "%s: could not get socket", 1919 lifrl.lifr_name); 1920 ret_code = -1; 1921 continue; 1922 } 1923 (void) memset(&lifrl, 0, sizeof (lifrl)); 1924 (void) strncpy(lifrl.lifr_name, lifrp->lifr_name, 1925 sizeof (lifrl.lifr_name)); 1926 if (ioctl(s, SIOCGLIFZONE, (caddr_t)&lifrl) < 0) { 1927 if (errno == ENXIO) 1928 /* 1929 * Interface may have been removed by admin or 1930 * another zone halting. 1931 */ 1932 continue; 1933 zerror(zlogp, B_TRUE, 1934 "%s: could not determine the zone to which this " 1935 "network interface is bound", lifrl.lifr_name); 1936 ret_code = -1; 1937 continue; 1938 } 1939 if (lifrl.lifr_zoneid == zone_id) { 1940 if (ioctl(s, SIOCLIFREMOVEIF, (caddr_t)&lifrl) < 0) { 1941 zerror(zlogp, B_TRUE, 1942 "%s: could not remove network interface", 1943 lifrl.lifr_name); 1944 ret_code = -1; 1945 continue; 1946 } 1947 } 1948 } 1949 bad: 1950 if (s > 0) 1951 (void) close(s); 1952 if (buf) 1953 free(buf); 1954 return (ret_code); 1955 } 1956 1957 static union sockunion { 1958 struct sockaddr sa; 1959 struct sockaddr_in sin; 1960 struct sockaddr_dl sdl; 1961 struct sockaddr_in6 sin6; 1962 } so_dst, so_ifp; 1963 1964 static struct { 1965 struct rt_msghdr hdr; 1966 char space[512]; 1967 } rtmsg; 1968 1969 static int 1970 salen(struct sockaddr *sa) 1971 { 1972 switch (sa->sa_family) { 1973 case AF_INET: 1974 return (sizeof (struct sockaddr_in)); 1975 case AF_LINK: 1976 return (sizeof (struct sockaddr_dl)); 1977 case AF_INET6: 1978 return (sizeof (struct sockaddr_in6)); 1979 default: 1980 return (sizeof (struct sockaddr)); 1981 } 1982 } 1983 1984 #define ROUNDUP_LONG(a) \ 1985 ((a) > 0 ? (1 + (((a) - 1) | (sizeof (long) - 1))) : sizeof (long)) 1986 1987 /* 1988 * Look up which zone is using a given IP address. The address in question 1989 * is expected to have been stuffed into the structure to which lifr points 1990 * via a previous SIOCGLIFADDR ioctl(). 1991 * 1992 * This is done using black router socket magic. 1993 * 1994 * Return the name of the zone on success or NULL on failure. 1995 * 1996 * This is a lot of code for a simple task; a new ioctl request to take care 1997 * of this might be a useful RFE. 1998 */ 1999 2000 static char * 2001 who_is_using(zlog_t *zlogp, struct lifreq *lifr) 2002 { 2003 static char answer[ZONENAME_MAX]; 2004 pid_t pid; 2005 int s, rlen, l, i; 2006 char *cp = rtmsg.space; 2007 struct sockaddr_dl *ifp = NULL; 2008 struct sockaddr *sa; 2009 char save_if_name[LIFNAMSIZ]; 2010 2011 answer[0] = '\0'; 2012 2013 pid = getpid(); 2014 if ((s = socket(PF_ROUTE, SOCK_RAW, 0)) < 0) { 2015 zerror(zlogp, B_TRUE, "could not get routing socket"); 2016 return (NULL); 2017 } 2018 2019 if (lifr->lifr_addr.ss_family == AF_INET) { 2020 struct sockaddr_in *sin4; 2021 2022 so_dst.sa.sa_family = AF_INET; 2023 sin4 = (struct sockaddr_in *)&lifr->lifr_addr; 2024 so_dst.sin.sin_addr = sin4->sin_addr; 2025 } else { 2026 struct sockaddr_in6 *sin6; 2027 2028 so_dst.sa.sa_family = AF_INET6; 2029 sin6 = (struct sockaddr_in6 *)&lifr->lifr_addr; 2030 so_dst.sin6.sin6_addr = sin6->sin6_addr; 2031 } 2032 2033 so_ifp.sa.sa_family = AF_LINK; 2034 2035 (void) memset(&rtmsg, 0, sizeof (rtmsg)); 2036 rtmsg.hdr.rtm_type = RTM_GET; 2037 rtmsg.hdr.rtm_flags = RTF_UP | RTF_HOST; 2038 rtmsg.hdr.rtm_version = RTM_VERSION; 2039 rtmsg.hdr.rtm_seq = ++rts_seqno; 2040 rtmsg.hdr.rtm_addrs = RTA_IFP | RTA_DST; 2041 2042 l = ROUNDUP_LONG(salen(&so_dst.sa)); 2043 (void) memmove(cp, &(so_dst), l); 2044 cp += l; 2045 l = ROUNDUP_LONG(salen(&so_ifp.sa)); 2046 (void) memmove(cp, &(so_ifp), l); 2047 cp += l; 2048 2049 rtmsg.hdr.rtm_msglen = l = cp - (char *)&rtmsg; 2050 2051 if ((rlen = write(s, &rtmsg, l)) < 0) { 2052 zerror(zlogp, B_TRUE, "writing to routing socket"); 2053 return (NULL); 2054 } else if (rlen < (int)rtmsg.hdr.rtm_msglen) { 2055 zerror(zlogp, B_TRUE, 2056 "write to routing socket got only %d for len\n", rlen); 2057 return (NULL); 2058 } 2059 do { 2060 l = read(s, &rtmsg, sizeof (rtmsg)); 2061 } while (l > 0 && (rtmsg.hdr.rtm_seq != rts_seqno || 2062 rtmsg.hdr.rtm_pid != pid)); 2063 if (l < 0) { 2064 zerror(zlogp, B_TRUE, "reading from routing socket"); 2065 return (NULL); 2066 } 2067 2068 if (rtmsg.hdr.rtm_version != RTM_VERSION) { 2069 zerror(zlogp, B_FALSE, 2070 "routing message version %d not understood", 2071 rtmsg.hdr.rtm_version); 2072 return (NULL); 2073 } 2074 if (rtmsg.hdr.rtm_msglen != (ushort_t)l) { 2075 zerror(zlogp, B_FALSE, "message length mismatch, " 2076 "expected %d bytes, returned %d bytes", 2077 rtmsg.hdr.rtm_msglen, l); 2078 return (NULL); 2079 } 2080 if (rtmsg.hdr.rtm_errno != 0) { 2081 errno = rtmsg.hdr.rtm_errno; 2082 zerror(zlogp, B_TRUE, "RTM_GET routing socket message"); 2083 return (NULL); 2084 } 2085 if ((rtmsg.hdr.rtm_addrs & RTA_IFP) == 0) { 2086 zerror(zlogp, B_FALSE, "network interface not found"); 2087 return (NULL); 2088 } 2089 cp = ((char *)(&rtmsg.hdr + 1)); 2090 for (i = 1; i != 0; i <<= 1) { 2091 /* LINTED E_BAD_PTR_CAST_ALIGN */ 2092 sa = (struct sockaddr *)cp; 2093 if (i != RTA_IFP) { 2094 if ((i & rtmsg.hdr.rtm_addrs) != 0) 2095 cp += ROUNDUP_LONG(salen(sa)); 2096 continue; 2097 } 2098 if (sa->sa_family == AF_LINK && 2099 ((struct sockaddr_dl *)sa)->sdl_nlen != 0) 2100 ifp = (struct sockaddr_dl *)sa; 2101 break; 2102 } 2103 if (ifp == NULL) { 2104 zerror(zlogp, B_FALSE, "network interface could not be " 2105 "determined"); 2106 return (NULL); 2107 } 2108 2109 /* 2110 * We need to set the I/F name to what we got above, then do the 2111 * appropriate ioctl to get its zone name. But lifr->lifr_name is 2112 * used by the calling function to do a REMOVEIF, so if we leave the 2113 * "good" zone's I/F name in place, *that* I/F will be removed instead 2114 * of the bad one. So we save the old (bad) I/F name before over- 2115 * writing it and doing the ioctl, then restore it after the ioctl. 2116 */ 2117 (void) strlcpy(save_if_name, lifr->lifr_name, sizeof (save_if_name)); 2118 (void) strncpy(lifr->lifr_name, ifp->sdl_data, ifp->sdl_nlen); 2119 lifr->lifr_name[ifp->sdl_nlen] = '\0'; 2120 i = ioctl(s, SIOCGLIFZONE, lifr); 2121 (void) strlcpy(lifr->lifr_name, save_if_name, sizeof (save_if_name)); 2122 if (i < 0) { 2123 zerror(zlogp, B_TRUE, 2124 "%s: could not determine the zone network interface " 2125 "belongs to", lifr->lifr_name); 2126 return (NULL); 2127 } 2128 if (getzonenamebyid(lifr->lifr_zoneid, answer, sizeof (answer)) < 0) 2129 (void) snprintf(answer, sizeof (answer), "%d", 2130 lifr->lifr_zoneid); 2131 2132 if (strlen(answer) > 0) 2133 return (answer); 2134 return (NULL); 2135 } 2136 2137 /* 2138 * Configures a single interface: a new virtual interface is added, based on 2139 * the physical interface nwiftabptr->zone_nwif_physical, with the address 2140 * specified in nwiftabptr->zone_nwif_address, for zone zone_id. Note that 2141 * the "address" can be an IPv6 address (with a /prefixlength required), an 2142 * IPv4 address (with a /prefixlength optional), or a name; for the latter, 2143 * an IPv4 name-to-address resolution will be attempted. 2144 * 2145 * If anything goes wrong, we log an detailed error message, attempt to tear 2146 * down whatever we set up and return an error. 2147 */ 2148 static int 2149 configure_one_interface(zlog_t *zlogp, zoneid_t zone_id, 2150 struct zone_nwiftab *nwiftabptr) 2151 { 2152 struct lifreq lifr; 2153 struct sockaddr_in netmask4; 2154 struct sockaddr_in6 netmask6; 2155 struct sockaddr_storage laddr; 2156 struct in_addr in4; 2157 sa_family_t af; 2158 char *slashp = strchr(nwiftabptr->zone_nwif_address, '/'); 2159 int s; 2160 boolean_t got_netmask = B_FALSE; 2161 boolean_t is_loopback = B_FALSE; 2162 char addrstr4[INET_ADDRSTRLEN]; 2163 int res; 2164 2165 res = zonecfg_valid_net_address(nwiftabptr->zone_nwif_address, &lifr); 2166 if (res != Z_OK) { 2167 zerror(zlogp, B_FALSE, "%s: %s", zonecfg_strerror(res), 2168 nwiftabptr->zone_nwif_address); 2169 return (-1); 2170 } 2171 af = lifr.lifr_addr.ss_family; 2172 if (af == AF_INET) 2173 in4 = ((struct sockaddr_in *)(&lifr.lifr_addr))->sin_addr; 2174 if ((s = socket(af, SOCK_DGRAM, 0)) < 0) { 2175 zerror(zlogp, B_TRUE, "could not get socket"); 2176 return (-1); 2177 } 2178 2179 /* 2180 * This is a similar kind of "hack" like in addif() to get around 2181 * the problem of SIOCLIFADDIF. The problem is that this ioctl 2182 * does not include the netmask when adding a logical interface. 2183 * To get around this problem, we first add the logical interface 2184 * with a 0 address. After that, we set the netmask if provided. 2185 * Finally we set the interface address. 2186 */ 2187 laddr = lifr.lifr_addr; 2188 (void) strlcpy(lifr.lifr_name, nwiftabptr->zone_nwif_physical, 2189 sizeof (lifr.lifr_name)); 2190 (void) memset(&lifr.lifr_addr, 0, sizeof (lifr.lifr_addr)); 2191 2192 if (ioctl(s, SIOCLIFADDIF, (caddr_t)&lifr) < 0) { 2193 /* 2194 * Here, we know that the interface can't be brought up. 2195 * A similar warning message was already printed out to 2196 * the console by zoneadm(1M) so instead we log the 2197 * message to syslog and continue. 2198 */ 2199 zerror(&logsys, B_TRUE, "WARNING: skipping network interface " 2200 "'%s' which may not be present/plumbed in the " 2201 "global zone.", lifr.lifr_name); 2202 (void) close(s); 2203 return (Z_OK); 2204 } 2205 2206 /* Preserve literal IPv4 address for later potential printing. */ 2207 if (af == AF_INET) 2208 (void) inet_ntop(AF_INET, &in4, addrstr4, INET_ADDRSTRLEN); 2209 2210 lifr.lifr_zoneid = zone_id; 2211 if (ioctl(s, SIOCSLIFZONE, (caddr_t)&lifr) < 0) { 2212 zerror(zlogp, B_TRUE, "%s: could not place network interface " 2213 "into zone", lifr.lifr_name); 2214 goto bad; 2215 } 2216 2217 /* 2218 * Loopback interface will use the default netmask assigned, if no 2219 * netmask is found. 2220 */ 2221 if (strcmp(nwiftabptr->zone_nwif_physical, "lo0") == 0) { 2222 is_loopback = B_TRUE; 2223 } 2224 if (af == AF_INET) { 2225 /* 2226 * The IPv4 netmask can be determined either 2227 * directly if a prefix length was supplied with 2228 * the address or via the netmasks database. Not 2229 * being able to determine it is a common failure, 2230 * but it often is not fatal to operation of the 2231 * interface. In that case, a warning will be 2232 * printed after the rest of the interface's 2233 * parameters have been configured. 2234 */ 2235 (void) memset(&netmask4, 0, sizeof (netmask4)); 2236 if (slashp != NULL) { 2237 if (addr2netmask(slashp + 1, V4_ADDR_LEN, 2238 (uchar_t *)&netmask4.sin_addr) != 0) { 2239 *slashp = '/'; 2240 zerror(zlogp, B_FALSE, 2241 "%s: invalid prefix length in %s", 2242 lifr.lifr_name, 2243 nwiftabptr->zone_nwif_address); 2244 goto bad; 2245 } 2246 got_netmask = B_TRUE; 2247 } else if (getnetmaskbyaddr(in4, 2248 &netmask4.sin_addr) == 0) { 2249 got_netmask = B_TRUE; 2250 } 2251 if (got_netmask) { 2252 netmask4.sin_family = af; 2253 (void) memcpy(&lifr.lifr_addr, &netmask4, 2254 sizeof (netmask4)); 2255 } 2256 } else { 2257 (void) memset(&netmask6, 0, sizeof (netmask6)); 2258 if (addr2netmask(slashp + 1, V6_ADDR_LEN, 2259 (uchar_t *)&netmask6.sin6_addr) != 0) { 2260 *slashp = '/'; 2261 zerror(zlogp, B_FALSE, 2262 "%s: invalid prefix length in %s", 2263 lifr.lifr_name, 2264 nwiftabptr->zone_nwif_address); 2265 goto bad; 2266 } 2267 got_netmask = B_TRUE; 2268 netmask6.sin6_family = af; 2269 (void) memcpy(&lifr.lifr_addr, &netmask6, 2270 sizeof (netmask6)); 2271 } 2272 if (got_netmask && 2273 ioctl(s, SIOCSLIFNETMASK, (caddr_t)&lifr) < 0) { 2274 zerror(zlogp, B_TRUE, "%s: could not set netmask", 2275 lifr.lifr_name); 2276 goto bad; 2277 } 2278 2279 /* Set the interface address */ 2280 lifr.lifr_addr = laddr; 2281 if (ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr) < 0) { 2282 zerror(zlogp, B_TRUE, 2283 "%s: could not set IP address to %s", 2284 lifr.lifr_name, nwiftabptr->zone_nwif_address); 2285 goto bad; 2286 } 2287 2288 if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) { 2289 zerror(zlogp, B_TRUE, "%s: could not get flags", 2290 lifr.lifr_name); 2291 goto bad; 2292 } 2293 lifr.lifr_flags |= IFF_UP; 2294 if (ioctl(s, SIOCSLIFFLAGS, (caddr_t)&lifr) < 0) { 2295 int save_errno = errno; 2296 char *zone_using; 2297 2298 /* 2299 * If we failed with something other than EADDRNOTAVAIL, 2300 * then skip to the end. Otherwise, look up our address, 2301 * then call a function to determine which zone is already 2302 * using that address. 2303 */ 2304 if (errno != EADDRNOTAVAIL) { 2305 zerror(zlogp, B_TRUE, 2306 "%s: could not bring network interface up", 2307 lifr.lifr_name); 2308 goto bad; 2309 } 2310 if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) { 2311 zerror(zlogp, B_TRUE, "%s: could not get address", 2312 lifr.lifr_name); 2313 goto bad; 2314 } 2315 zone_using = who_is_using(zlogp, &lifr); 2316 errno = save_errno; 2317 if (zone_using == NULL) 2318 zerror(zlogp, B_TRUE, 2319 "%s: could not bring network interface up", 2320 lifr.lifr_name); 2321 else 2322 zerror(zlogp, B_TRUE, "%s: could not bring network " 2323 "interface up: address in use by zone '%s'", 2324 lifr.lifr_name, zone_using); 2325 goto bad; 2326 } 2327 2328 if (!got_netmask && !is_loopback) { 2329 /* 2330 * A common, but often non-fatal problem, is that the system 2331 * cannot find the netmask for an interface address. This is 2332 * often caused by it being only in /etc/inet/netmasks, but 2333 * /etc/nsswitch.conf says to use NIS or NIS+ and it's not 2334 * in that. This doesn't show up at boot because the netmask 2335 * is obtained from /etc/inet/netmasks when no network 2336 * interfaces are up, but isn't consulted when NIS/NIS+ is 2337 * available. We warn the user here that something like this 2338 * has happened and we're just running with a default and 2339 * possible incorrect netmask. 2340 */ 2341 char buffer[INET6_ADDRSTRLEN]; 2342 void *addr; 2343 const char *nomatch = "no matching subnet found in netmasks(4)"; 2344 2345 if (af == AF_INET) 2346 addr = &((struct sockaddr_in *) 2347 (&lifr.lifr_addr))->sin_addr; 2348 else 2349 addr = &((struct sockaddr_in6 *) 2350 (&lifr.lifr_addr))->sin6_addr; 2351 2352 /* 2353 * Find out what netmask the interface is going to be using. 2354 * If we just brought up an IPMP data address on an underlying 2355 * interface above, the address will have already migrated, so 2356 * the SIOCGLIFNETMASK won't be able to find it (but we need 2357 * to bring the address up to get the actual netmask). Just 2358 * omit printing the actual netmask in this corner-case. 2359 */ 2360 if (ioctl(s, SIOCGLIFNETMASK, (caddr_t)&lifr) < 0 || 2361 inet_ntop(af, addr, buffer, sizeof (buffer)) == NULL) { 2362 zerror(zlogp, B_FALSE, "WARNING: %s; using default.", 2363 nomatch); 2364 } else { 2365 zerror(zlogp, B_FALSE, 2366 "WARNING: %s: %s: %s; using default of %s.", 2367 lifr.lifr_name, nomatch, addrstr4, buffer); 2368 } 2369 } 2370 2371 /* 2372 * If a default router was specified for this interface 2373 * set the route now. Ignore if already set. 2374 */ 2375 if (strlen(nwiftabptr->zone_nwif_defrouter) > 0) { 2376 int status; 2377 char *argv[7]; 2378 2379 argv[0] = "route"; 2380 argv[1] = "add"; 2381 argv[2] = "-ifp"; 2382 argv[3] = nwiftabptr->zone_nwif_physical; 2383 argv[4] = "default"; 2384 argv[5] = nwiftabptr->zone_nwif_defrouter; 2385 argv[6] = NULL; 2386 2387 status = forkexec(zlogp, "/usr/sbin/route", argv); 2388 if (status != 0 && status != EEXIST) 2389 zerror(zlogp, B_FALSE, "Unable to set route for " 2390 "interface %s to %s\n", 2391 nwiftabptr->zone_nwif_physical, 2392 nwiftabptr->zone_nwif_defrouter); 2393 } 2394 2395 (void) close(s); 2396 return (Z_OK); 2397 bad: 2398 (void) ioctl(s, SIOCLIFREMOVEIF, (caddr_t)&lifr); 2399 (void) close(s); 2400 return (-1); 2401 } 2402 2403 /* 2404 * Sets up network interfaces based on information from the zone configuration. 2405 * IPv4 and IPv6 loopback interfaces are set up "for free", modeling the global 2406 * system. 2407 * 2408 * If anything goes wrong, we log a general error message, attempt to tear down 2409 * whatever we set up, and return an error. 2410 */ 2411 static int 2412 configure_shared_network_interfaces(zlog_t *zlogp) 2413 { 2414 zone_dochandle_t handle; 2415 struct zone_nwiftab nwiftab, loopback_iftab; 2416 zoneid_t zoneid; 2417 2418 if ((zoneid = getzoneidbyname(zone_name)) == ZONE_ID_UNDEFINED) { 2419 zerror(zlogp, B_TRUE, "unable to get zoneid"); 2420 return (-1); 2421 } 2422 2423 if ((handle = zonecfg_init_handle()) == NULL) { 2424 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 2425 return (-1); 2426 } 2427 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 2428 zerror(zlogp, B_FALSE, "invalid configuration"); 2429 zonecfg_fini_handle(handle); 2430 return (-1); 2431 } 2432 if (zonecfg_setnwifent(handle) == Z_OK) { 2433 for (;;) { 2434 if (zonecfg_getnwifent(handle, &nwiftab) != Z_OK) 2435 break; 2436 if (configure_one_interface(zlogp, zoneid, &nwiftab) != 2437 Z_OK) { 2438 (void) zonecfg_endnwifent(handle); 2439 zonecfg_fini_handle(handle); 2440 return (-1); 2441 } 2442 } 2443 (void) zonecfg_endnwifent(handle); 2444 } 2445 zonecfg_fini_handle(handle); 2446 if (is_system_labeled()) { 2447 /* 2448 * Labeled zones share the loopback interface 2449 * so it is not plumbed for shared stack instances. 2450 */ 2451 return (0); 2452 } 2453 (void) strlcpy(loopback_iftab.zone_nwif_physical, "lo0", 2454 sizeof (loopback_iftab.zone_nwif_physical)); 2455 (void) strlcpy(loopback_iftab.zone_nwif_address, "127.0.0.1", 2456 sizeof (loopback_iftab.zone_nwif_address)); 2457 loopback_iftab.zone_nwif_defrouter[0] = '\0'; 2458 if (configure_one_interface(zlogp, zoneid, &loopback_iftab) != Z_OK) 2459 return (-1); 2460 2461 /* Always plumb up the IPv6 loopback interface. */ 2462 (void) strlcpy(loopback_iftab.zone_nwif_address, "::1/128", 2463 sizeof (loopback_iftab.zone_nwif_address)); 2464 if (configure_one_interface(zlogp, zoneid, &loopback_iftab) != Z_OK) 2465 return (-1); 2466 return (0); 2467 } 2468 2469 static void 2470 zdlerror(zlog_t *zlogp, dladm_status_t err, const char *dlname, const char *str) 2471 { 2472 char errmsg[DLADM_STRSIZE]; 2473 2474 (void) dladm_status2str(err, errmsg); 2475 zerror(zlogp, B_FALSE, "%s '%s': %s", str, dlname, errmsg); 2476 } 2477 2478 static int 2479 add_datalink(zlog_t *zlogp, char *zone_name, datalink_id_t linkid, char *dlname) 2480 { 2481 dladm_status_t err; 2482 boolean_t cpuset, poolset; 2483 char *poolp; 2484 2485 /* First check if it's in use by global zone. */ 2486 if (zonecfg_ifname_exists(AF_INET, dlname) || 2487 zonecfg_ifname_exists(AF_INET6, dlname)) { 2488 zerror(zlogp, B_FALSE, "WARNING: skipping network interface " 2489 "'%s' which is used in the global zone", dlname); 2490 return (-1); 2491 } 2492 2493 /* Set zoneid of this link. */ 2494 err = dladm_set_linkprop(dld_handle, linkid, "zone", &zone_name, 1, 2495 DLADM_OPT_ACTIVE); 2496 if (err != DLADM_STATUS_OK) { 2497 zdlerror(zlogp, err, dlname, 2498 "WARNING: unable to add network interface"); 2499 return (-1); 2500 } 2501 2502 /* 2503 * Set the pool of this link if the zone has a pool and 2504 * neither the cpus nor the pool datalink property is 2505 * already set. 2506 */ 2507 err = dladm_linkprop_is_set(dld_handle, linkid, DLADM_PROP_VAL_CURRENT, 2508 "cpus", &cpuset); 2509 if (err != DLADM_STATUS_OK) { 2510 zdlerror(zlogp, err, dlname, 2511 "WARNING: unable to check if cpus link property is set"); 2512 } 2513 err = dladm_linkprop_is_set(dld_handle, linkid, DLADM_PROP_VAL_CURRENT, 2514 "pool", &poolset); 2515 if (err != DLADM_STATUS_OK) { 2516 zdlerror(zlogp, err, dlname, 2517 "WARNING: unable to check if pool link property is set"); 2518 } 2519 2520 if ((strlen(pool_name) != 0) && !cpuset && !poolset) { 2521 poolp = pool_name; 2522 err = dladm_set_linkprop(dld_handle, linkid, "pool", 2523 &poolp, 1, DLADM_OPT_ACTIVE); 2524 if (err != DLADM_STATUS_OK) { 2525 zerror(zlogp, B_FALSE, "WARNING: unable to set " 2526 "pool %s to datalink %s", pool_name, dlname); 2527 bzero(pool_name, sizeof (pool_name)); 2528 } 2529 } else { 2530 bzero(pool_name, sizeof (pool_name)); 2531 } 2532 return (0); 2533 } 2534 2535 static boolean_t 2536 sockaddr_to_str(sa_family_t af, const struct sockaddr *sockaddr, 2537 char *straddr, size_t len) 2538 { 2539 struct sockaddr_in *sin; 2540 struct sockaddr_in6 *sin6; 2541 const char *str = NULL; 2542 2543 if (af == AF_INET) { 2544 /* LINTED E_BAD_PTR_CAST_ALIGN */ 2545 sin = SIN(sockaddr); 2546 str = inet_ntop(AF_INET, (void *)&sin->sin_addr, straddr, len); 2547 } else if (af == AF_INET6) { 2548 /* LINTED E_BAD_PTR_CAST_ALIGN */ 2549 sin6 = SIN6(sockaddr); 2550 str = inet_ntop(AF_INET6, (void *)&sin6->sin6_addr, straddr, 2551 len); 2552 } 2553 2554 return (str != NULL); 2555 } 2556 2557 static int 2558 ipv4_prefixlen(struct sockaddr_in *sin) 2559 { 2560 struct sockaddr_in *m; 2561 struct sockaddr_storage mask; 2562 2563 m = SIN(&mask); 2564 m->sin_family = AF_INET; 2565 if (getnetmaskbyaddr(sin->sin_addr, &m->sin_addr) == 0) { 2566 return (mask2plen((struct sockaddr *)&mask)); 2567 } else if (IN_CLASSA(htonl(sin->sin_addr.s_addr))) { 2568 return (8); 2569 } else if (IN_CLASSB(ntohl(sin->sin_addr.s_addr))) { 2570 return (16); 2571 } else if (IN_CLASSC(ntohl(sin->sin_addr.s_addr))) { 2572 return (24); 2573 } 2574 return (0); 2575 } 2576 2577 static int 2578 zone_setattr_network(int type, zoneid_t zoneid, datalink_id_t linkid, 2579 void *buf, size_t bufsize) 2580 { 2581 zone_net_data_t *zndata; 2582 size_t znsize; 2583 int err; 2584 2585 znsize = sizeof (*zndata) + bufsize; 2586 zndata = calloc(1, znsize); 2587 if (zndata == NULL) 2588 return (ENOMEM); 2589 zndata->zn_type = type; 2590 zndata->zn_len = bufsize; 2591 zndata->zn_linkid = linkid; 2592 bcopy(buf, zndata->zn_val, zndata->zn_len); 2593 err = zone_setattr(zoneid, ZONE_ATTR_NETWORK, zndata, znsize); 2594 free(zndata); 2595 return (err); 2596 } 2597 2598 static int 2599 add_net_for_linkid(zlog_t *zlogp, zoneid_t zoneid, zone_addr_list_t *start) 2600 { 2601 struct lifreq lifr; 2602 char **astr, *address; 2603 dladm_status_t dlstatus; 2604 char *ip_nospoof = "ip-nospoof"; 2605 int nnet, naddr, err = 0, j; 2606 size_t zlen, cpleft; 2607 zone_addr_list_t *ptr, *end; 2608 char tmp[INET6_ADDRSTRLEN], *maskstr; 2609 char *zaddr, *cp; 2610 struct in6_addr *routes = NULL; 2611 boolean_t is_set; 2612 datalink_id_t linkid; 2613 2614 assert(start != NULL); 2615 naddr = 0; /* number of addresses */ 2616 nnet = 0; /* number of net resources */ 2617 linkid = start->za_linkid; 2618 for (ptr = start; ptr != NULL && ptr->za_linkid == linkid; 2619 ptr = ptr->za_next) { 2620 nnet++; 2621 } 2622 end = ptr; 2623 zlen = nnet * (INET6_ADDRSTRLEN + 1); 2624 astr = calloc(1, nnet * sizeof (uintptr_t)); 2625 zaddr = calloc(1, zlen); 2626 if (astr == NULL || zaddr == NULL) { 2627 err = ENOMEM; 2628 goto done; 2629 } 2630 cp = zaddr; 2631 cpleft = zlen; 2632 j = 0; 2633 for (ptr = start; ptr != end; ptr = ptr->za_next) { 2634 address = ptr->za_nwiftab.zone_nwif_allowed_address; 2635 if (address[0] == '\0') 2636 continue; 2637 (void) snprintf(tmp, sizeof (tmp), "%s", address); 2638 /* 2639 * Validate the data. zonecfg_valid_net_address() clobbers 2640 * the /<mask> in the address string. 2641 */ 2642 if (zonecfg_valid_net_address(address, &lifr) != Z_OK) { 2643 zerror(zlogp, B_FALSE, "invalid address [%s]\n", 2644 address); 2645 err = EINVAL; 2646 goto done; 2647 } 2648 /* 2649 * convert any hostnames to numeric address strings. 2650 */ 2651 if (!sockaddr_to_str(lifr.lifr_addr.ss_family, 2652 (const struct sockaddr *)&lifr.lifr_addr, cp, cpleft)) { 2653 err = EINVAL; 2654 goto done; 2655 } 2656 /* 2657 * make a copy of the numeric string for the data needed 2658 * by the "allowed-ips" datalink property. 2659 */ 2660 astr[j] = strdup(cp); 2661 if (astr[j] == NULL) { 2662 err = ENOMEM; 2663 goto done; 2664 } 2665 j++; 2666 /* 2667 * compute the default netmask from the address, if necessary 2668 */ 2669 if ((maskstr = strchr(tmp, '/')) == NULL) { 2670 int prefixlen; 2671 2672 if (lifr.lifr_addr.ss_family == AF_INET) { 2673 prefixlen = ipv4_prefixlen( 2674 SIN(&lifr.lifr_addr)); 2675 } else { 2676 struct sockaddr_in6 *sin6; 2677 2678 sin6 = SIN6(&lifr.lifr_addr); 2679 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) 2680 prefixlen = 10; 2681 else 2682 prefixlen = 64; 2683 } 2684 (void) snprintf(tmp, sizeof (tmp), "%d", prefixlen); 2685 maskstr = tmp; 2686 } else { 2687 maskstr++; 2688 } 2689 /* append the "/<netmask>" */ 2690 (void) strlcat(cp, "/", cpleft); 2691 (void) strlcat(cp, maskstr, cpleft); 2692 (void) strlcat(cp, ",", cpleft); 2693 cp += strnlen(cp, zlen); 2694 cpleft = &zaddr[INET6_ADDRSTRLEN] - cp; 2695 } 2696 naddr = j; /* the actual number of addresses in the net resource */ 2697 assert(naddr <= nnet); 2698 2699 /* 2700 * zonecfg has already verified that the defrouter property can only 2701 * be set if there is at least one address defined for the net resource. 2702 * If j is 0, there are no addresses defined, and therefore no routers 2703 * to configure, and we are done at that point. 2704 */ 2705 if (j == 0) 2706 goto done; 2707 2708 /* over-write last ',' with '\0' */ 2709 zaddr[strnlen(zaddr, zlen) + 1] = '\0'; 2710 2711 /* 2712 * First make sure L3 protection is not already set on the link. 2713 */ 2714 dlstatus = dladm_linkprop_is_set(dld_handle, linkid, DLADM_OPT_ACTIVE, 2715 "protection", &is_set); 2716 if (dlstatus != DLADM_STATUS_OK) { 2717 err = EINVAL; 2718 zerror(zlogp, B_FALSE, "unable to check if protection is set"); 2719 goto done; 2720 } 2721 if (is_set) { 2722 err = EINVAL; 2723 zerror(zlogp, B_FALSE, "Protection is already set"); 2724 goto done; 2725 } 2726 dlstatus = dladm_linkprop_is_set(dld_handle, linkid, DLADM_OPT_ACTIVE, 2727 "allowed-ips", &is_set); 2728 if (dlstatus != DLADM_STATUS_OK) { 2729 err = EINVAL; 2730 zerror(zlogp, B_FALSE, "unable to check if allowed-ips is set"); 2731 goto done; 2732 } 2733 if (is_set) { 2734 zerror(zlogp, B_FALSE, "allowed-ips is already set"); 2735 err = EINVAL; 2736 goto done; 2737 } 2738 2739 /* 2740 * Enable ip-nospoof for the link, and add address to the allowed-ips 2741 * list. 2742 */ 2743 dlstatus = dladm_set_linkprop(dld_handle, linkid, "protection", 2744 &ip_nospoof, 1, DLADM_OPT_ACTIVE); 2745 if (dlstatus != DLADM_STATUS_OK) { 2746 zerror(zlogp, B_FALSE, "could not set protection\n"); 2747 err = EINVAL; 2748 goto done; 2749 } 2750 dlstatus = dladm_set_linkprop(dld_handle, linkid, "allowed-ips", 2751 astr, naddr, DLADM_OPT_ACTIVE); 2752 if (dlstatus != DLADM_STATUS_OK) { 2753 zerror(zlogp, B_FALSE, "could not set allowed-ips\n"); 2754 err = EINVAL; 2755 goto done; 2756 } 2757 2758 /* now set the address in the data-store */ 2759 err = zone_setattr_network(ZONE_NETWORK_ADDRESS, zoneid, linkid, 2760 zaddr, strnlen(zaddr, zlen) + 1); 2761 if (err != 0) 2762 goto done; 2763 2764 /* 2765 * add the defaultrouters 2766 */ 2767 routes = calloc(1, nnet * sizeof (*routes)); 2768 j = 0; 2769 for (ptr = start; ptr != end; ptr = ptr->za_next) { 2770 address = ptr->za_nwiftab.zone_nwif_defrouter; 2771 if (address[0] == '\0') 2772 continue; 2773 if (strchr(address, '/') == NULL && strchr(address, ':') != 0) { 2774 /* 2775 * zonecfg_valid_net_address() expects numeric IPv6 2776 * addresses to have a CIDR format netmask. 2777 */ 2778 (void) snprintf(tmp, sizeof (tmp), "/%d", V6_ADDR_LEN); 2779 (void) strlcat(address, tmp, INET6_ADDRSTRLEN); 2780 } 2781 if (zonecfg_valid_net_address(address, &lifr) != Z_OK) { 2782 zerror(zlogp, B_FALSE, 2783 "invalid router [%s]\n", address); 2784 err = EINVAL; 2785 goto done; 2786 } 2787 if (lifr.lifr_addr.ss_family == AF_INET6) { 2788 routes[j] = SIN6(&lifr.lifr_addr)->sin6_addr; 2789 } else { 2790 IN6_INADDR_TO_V4MAPPED(&SIN(&lifr.lifr_addr)->sin_addr, 2791 &routes[j]); 2792 } 2793 j++; 2794 } 2795 assert(j <= nnet); 2796 if (j > 0) { 2797 err = zone_setattr_network(ZONE_NETWORK_DEFROUTER, zoneid, 2798 linkid, routes, j * sizeof (*routes)); 2799 } 2800 done: 2801 free(routes); 2802 for (j = 0; j < naddr; j++) 2803 free(astr[j]); 2804 free(astr); 2805 free(zaddr); 2806 return (err); 2807 2808 } 2809 2810 static int 2811 add_net(zlog_t *zlogp, zoneid_t zoneid, zone_addr_list_t *zalist) 2812 { 2813 zone_addr_list_t *ptr; 2814 datalink_id_t linkid; 2815 int err; 2816 2817 if (zalist == NULL) 2818 return (0); 2819 2820 linkid = zalist->za_linkid; 2821 2822 err = add_net_for_linkid(zlogp, zoneid, zalist); 2823 if (err != 0) 2824 return (err); 2825 2826 for (ptr = zalist; ptr != NULL; ptr = ptr->za_next) { 2827 if (ptr->za_linkid == linkid) 2828 continue; 2829 linkid = ptr->za_linkid; 2830 err = add_net_for_linkid(zlogp, zoneid, ptr); 2831 if (err != 0) 2832 return (err); 2833 } 2834 return (0); 2835 } 2836 2837 /* 2838 * Add "new" to the list of network interfaces to be configured by 2839 * add_net on zone boot in "old". The list of interfaces in "old" is 2840 * sorted by datalink_id_t, with interfaces sorted FIFO for a given 2841 * datalink_id_t. 2842 * 2843 * Returns the merged list of IP interfaces containing "old" and "new" 2844 */ 2845 static zone_addr_list_t * 2846 add_ip_interface(zone_addr_list_t *old, zone_addr_list_t *new) 2847 { 2848 zone_addr_list_t *ptr, *next; 2849 datalink_id_t linkid = new->za_linkid; 2850 2851 assert(old != new); 2852 2853 if (old == NULL) 2854 return (new); 2855 for (ptr = old; ptr != NULL; ptr = ptr->za_next) { 2856 if (ptr->za_linkid == linkid) 2857 break; 2858 } 2859 if (ptr == NULL) { 2860 /* linkid does not already exist, add to the beginning */ 2861 new->za_next = old; 2862 return (new); 2863 } 2864 /* 2865 * adding to the middle of the list; ptr points at the first 2866 * occurrence of linkid. Find the last occurrence. 2867 */ 2868 while ((next = ptr->za_next) != NULL) { 2869 if (next->za_linkid != linkid) 2870 break; 2871 ptr = next; 2872 } 2873 /* insert new after ptr */ 2874 new->za_next = next; 2875 ptr->za_next = new; 2876 return (old); 2877 } 2878 2879 void 2880 free_ip_interface(zone_addr_list_t *zalist) 2881 { 2882 zone_addr_list_t *ptr, *new; 2883 2884 for (ptr = zalist; ptr != NULL; ) { 2885 new = ptr; 2886 ptr = ptr->za_next; 2887 free(new); 2888 } 2889 } 2890 2891 /* 2892 * Add the kernel access control information for the interface names. 2893 * If anything goes wrong, we log a general error message, attempt to tear down 2894 * whatever we set up, and return an error. 2895 */ 2896 static int 2897 configure_exclusive_network_interfaces(zlog_t *zlogp, zoneid_t zoneid) 2898 { 2899 zone_dochandle_t handle; 2900 struct zone_nwiftab nwiftab; 2901 char rootpath[MAXPATHLEN]; 2902 char path[MAXPATHLEN]; 2903 datalink_id_t linkid; 2904 di_prof_t prof = NULL; 2905 boolean_t added = B_FALSE; 2906 zone_addr_list_t *zalist = NULL, *new; 2907 2908 if ((handle = zonecfg_init_handle()) == NULL) { 2909 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 2910 return (-1); 2911 } 2912 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 2913 zerror(zlogp, B_FALSE, "invalid configuration"); 2914 zonecfg_fini_handle(handle); 2915 return (-1); 2916 } 2917 2918 if (zonecfg_setnwifent(handle) != Z_OK) { 2919 zonecfg_fini_handle(handle); 2920 return (0); 2921 } 2922 2923 for (;;) { 2924 if (zonecfg_getnwifent(handle, &nwiftab) != Z_OK) 2925 break; 2926 2927 if (prof == NULL) { 2928 if (zone_get_devroot(zone_name, rootpath, 2929 sizeof (rootpath)) != Z_OK) { 2930 (void) zonecfg_endnwifent(handle); 2931 zonecfg_fini_handle(handle); 2932 zerror(zlogp, B_TRUE, 2933 "unable to determine dev root"); 2934 return (-1); 2935 } 2936 (void) snprintf(path, sizeof (path), "%s%s", rootpath, 2937 "/dev"); 2938 if (di_prof_init(path, &prof) != 0) { 2939 (void) zonecfg_endnwifent(handle); 2940 zonecfg_fini_handle(handle); 2941 zerror(zlogp, B_TRUE, 2942 "failed to initialize profile"); 2943 return (-1); 2944 } 2945 } 2946 2947 /* 2948 * Create the /dev entry for backward compatibility. 2949 * Only create the /dev entry if it's not in use. 2950 * Note that the zone still boots when the assigned 2951 * interface is inaccessible, used by others, etc. 2952 * Also, when vanity naming is used, some interface do 2953 * do not have corresponding /dev node names (for example, 2954 * vanity named aggregations). The /dev entry is not 2955 * created in that case. The /dev/net entry is always 2956 * accessible. 2957 */ 2958 if (dladm_name2info(dld_handle, nwiftab.zone_nwif_physical, 2959 &linkid, NULL, NULL, NULL) == DLADM_STATUS_OK && 2960 add_datalink(zlogp, zone_name, linkid, 2961 nwiftab.zone_nwif_physical) == 0) { 2962 added = B_TRUE; 2963 } else { 2964 (void) zonecfg_endnwifent(handle); 2965 zonecfg_fini_handle(handle); 2966 zerror(zlogp, B_TRUE, "failed to add network device"); 2967 return (-1); 2968 } 2969 /* set up the new IP interface, and add them all later */ 2970 new = malloc(sizeof (*new)); 2971 if (new == NULL) { 2972 zerror(zlogp, B_TRUE, "no memory for %s", 2973 nwiftab.zone_nwif_physical); 2974 zonecfg_fini_handle(handle); 2975 free_ip_interface(zalist); 2976 } 2977 bzero(new, sizeof (*new)); 2978 new->za_nwiftab = nwiftab; 2979 new->za_linkid = linkid; 2980 zalist = add_ip_interface(zalist, new); 2981 } 2982 if (zalist != NULL) { 2983 if ((errno = add_net(zlogp, zoneid, zalist)) != 0) { 2984 (void) zonecfg_endnwifent(handle); 2985 zonecfg_fini_handle(handle); 2986 zerror(zlogp, B_TRUE, "failed to add address"); 2987 free_ip_interface(zalist); 2988 return (-1); 2989 } 2990 free_ip_interface(zalist); 2991 } 2992 (void) zonecfg_endnwifent(handle); 2993 zonecfg_fini_handle(handle); 2994 2995 if (prof != NULL && added) { 2996 if (di_prof_commit(prof) != 0) { 2997 zerror(zlogp, B_TRUE, "failed to commit profile"); 2998 return (-1); 2999 } 3000 } 3001 if (prof != NULL) 3002 di_prof_fini(prof); 3003 3004 return (0); 3005 } 3006 3007 static int 3008 remove_datalink_pool(zlog_t *zlogp, zoneid_t zoneid) 3009 { 3010 ushort_t flags; 3011 zone_iptype_t iptype; 3012 int i, dlnum = 0; 3013 datalink_id_t *dllink, *dllinks = NULL; 3014 dladm_status_t err; 3015 3016 if (strlen(pool_name) == 0) 3017 return (0); 3018 3019 if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &flags, 3020 sizeof (flags)) < 0) { 3021 if (vplat_get_iptype(zlogp, &iptype) < 0) { 3022 zerror(zlogp, B_FALSE, "unable to determine ip-type"); 3023 return (-1); 3024 } 3025 } else { 3026 if (flags & ZF_NET_EXCL) 3027 iptype = ZS_EXCLUSIVE; 3028 else 3029 iptype = ZS_SHARED; 3030 } 3031 3032 if (iptype == ZS_EXCLUSIVE) { 3033 /* 3034 * Get the datalink count and for each datalink, 3035 * attempt to clear the pool property and clear 3036 * the pool_name. 3037 */ 3038 if (zone_list_datalink(zoneid, &dlnum, NULL) != 0) { 3039 zerror(zlogp, B_TRUE, "unable to count network " 3040 "interfaces"); 3041 return (-1); 3042 } 3043 3044 if (dlnum == 0) 3045 return (0); 3046 3047 if ((dllinks = malloc(dlnum * sizeof (datalink_id_t))) 3048 == NULL) { 3049 zerror(zlogp, B_TRUE, "memory allocation failed"); 3050 return (-1); 3051 } 3052 if (zone_list_datalink(zoneid, &dlnum, dllinks) != 0) { 3053 zerror(zlogp, B_TRUE, "unable to list network " 3054 "interfaces"); 3055 return (-1); 3056 } 3057 3058 bzero(pool_name, sizeof (pool_name)); 3059 for (i = 0, dllink = dllinks; i < dlnum; i++, dllink++) { 3060 err = dladm_set_linkprop(dld_handle, *dllink, "pool", 3061 NULL, 0, DLADM_OPT_ACTIVE); 3062 if (err != DLADM_STATUS_OK) { 3063 zerror(zlogp, B_TRUE, 3064 "WARNING: unable to clear pool"); 3065 } 3066 } 3067 free(dllinks); 3068 } 3069 return (0); 3070 } 3071 3072 static int 3073 remove_datalink_protect(zlog_t *zlogp, zoneid_t zoneid) 3074 { 3075 ushort_t flags; 3076 zone_iptype_t iptype; 3077 int i, dlnum = 0; 3078 dladm_status_t dlstatus; 3079 datalink_id_t *dllink, *dllinks = NULL; 3080 3081 if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &flags, 3082 sizeof (flags)) < 0) { 3083 if (vplat_get_iptype(zlogp, &iptype) < 0) { 3084 zerror(zlogp, B_FALSE, "unable to determine ip-type"); 3085 return (-1); 3086 } 3087 } else { 3088 if (flags & ZF_NET_EXCL) 3089 iptype = ZS_EXCLUSIVE; 3090 else 3091 iptype = ZS_SHARED; 3092 } 3093 3094 if (iptype != ZS_EXCLUSIVE) 3095 return (0); 3096 3097 /* 3098 * Get the datalink count and for each datalink, 3099 * attempt to clear the pool property and clear 3100 * the pool_name. 3101 */ 3102 if (zone_list_datalink(zoneid, &dlnum, NULL) != 0) { 3103 zerror(zlogp, B_TRUE, "unable to count network interfaces"); 3104 return (-1); 3105 } 3106 3107 if (dlnum == 0) 3108 return (0); 3109 3110 if ((dllinks = malloc(dlnum * sizeof (datalink_id_t))) == NULL) { 3111 zerror(zlogp, B_TRUE, "memory allocation failed"); 3112 return (-1); 3113 } 3114 if (zone_list_datalink(zoneid, &dlnum, dllinks) != 0) { 3115 zerror(zlogp, B_TRUE, "unable to list network interfaces"); 3116 free(dllinks); 3117 return (-1); 3118 } 3119 3120 for (i = 0, dllink = dllinks; i < dlnum; i++, dllink++) { 3121 char dlerr[DLADM_STRSIZE]; 3122 3123 dlstatus = dladm_set_linkprop(dld_handle, *dllink, 3124 "protection", NULL, 0, DLADM_OPT_ACTIVE); 3125 if (dlstatus == DLADM_STATUS_NOTFOUND) { 3126 /* datalink does not belong to the GZ */ 3127 continue; 3128 } 3129 if (dlstatus != DLADM_STATUS_OK) { 3130 zerror(zlogp, B_FALSE, 3131 dladm_status2str(dlstatus, dlerr)); 3132 free(dllinks); 3133 return (-1); 3134 } 3135 dlstatus = dladm_set_linkprop(dld_handle, *dllink, 3136 "allowed-ips", NULL, 0, DLADM_OPT_ACTIVE); 3137 if (dlstatus != DLADM_STATUS_OK) { 3138 zerror(zlogp, B_FALSE, 3139 dladm_status2str(dlstatus, dlerr)); 3140 free(dllinks); 3141 return (-1); 3142 } 3143 } 3144 free(dllinks); 3145 return (0); 3146 } 3147 3148 static int 3149 unconfigure_exclusive_network_interfaces(zlog_t *zlogp, zoneid_t zoneid) 3150 { 3151 int dlnum = 0; 3152 3153 /* 3154 * The kernel shutdown callback for the dls module should have removed 3155 * all datalinks from this zone. If any remain, then there's a 3156 * problem. 3157 */ 3158 if (zone_list_datalink(zoneid, &dlnum, NULL) != 0) { 3159 zerror(zlogp, B_TRUE, "unable to list network interfaces"); 3160 return (-1); 3161 } 3162 if (dlnum != 0) { 3163 zerror(zlogp, B_FALSE, 3164 "datalinks remain in zone after shutdown"); 3165 return (-1); 3166 } 3167 return (0); 3168 } 3169 3170 static int 3171 tcp_abort_conn(zlog_t *zlogp, zoneid_t zoneid, 3172 const struct sockaddr_storage *local, const struct sockaddr_storage *remote) 3173 { 3174 int fd; 3175 struct strioctl ioc; 3176 tcp_ioc_abort_conn_t conn; 3177 int error; 3178 3179 conn.ac_local = *local; 3180 conn.ac_remote = *remote; 3181 conn.ac_start = TCPS_SYN_SENT; 3182 conn.ac_end = TCPS_TIME_WAIT; 3183 conn.ac_zoneid = zoneid; 3184 3185 ioc.ic_cmd = TCP_IOC_ABORT_CONN; 3186 ioc.ic_timout = -1; /* infinite timeout */ 3187 ioc.ic_len = sizeof (conn); 3188 ioc.ic_dp = (char *)&conn; 3189 3190 if ((fd = open("/dev/tcp", O_RDONLY)) < 0) { 3191 zerror(zlogp, B_TRUE, "unable to open %s", "/dev/tcp"); 3192 return (-1); 3193 } 3194 3195 error = ioctl(fd, I_STR, &ioc); 3196 (void) close(fd); 3197 if (error == 0 || errno == ENOENT) /* ENOENT is not an error */ 3198 return (0); 3199 return (-1); 3200 } 3201 3202 static int 3203 tcp_abort_connections(zlog_t *zlogp, zoneid_t zoneid) 3204 { 3205 struct sockaddr_storage l, r; 3206 struct sockaddr_in *local, *remote; 3207 struct sockaddr_in6 *local6, *remote6; 3208 int error; 3209 3210 /* 3211 * Abort IPv4 connections. 3212 */ 3213 bzero(&l, sizeof (*local)); 3214 local = (struct sockaddr_in *)&l; 3215 local->sin_family = AF_INET; 3216 local->sin_addr.s_addr = INADDR_ANY; 3217 local->sin_port = 0; 3218 3219 bzero(&r, sizeof (*remote)); 3220 remote = (struct sockaddr_in *)&r; 3221 remote->sin_family = AF_INET; 3222 remote->sin_addr.s_addr = INADDR_ANY; 3223 remote->sin_port = 0; 3224 3225 if ((error = tcp_abort_conn(zlogp, zoneid, &l, &r)) != 0) 3226 return (error); 3227 3228 /* 3229 * Abort IPv6 connections. 3230 */ 3231 bzero(&l, sizeof (*local6)); 3232 local6 = (struct sockaddr_in6 *)&l; 3233 local6->sin6_family = AF_INET6; 3234 local6->sin6_port = 0; 3235 local6->sin6_addr = in6addr_any; 3236 3237 bzero(&r, sizeof (*remote6)); 3238 remote6 = (struct sockaddr_in6 *)&r; 3239 remote6->sin6_family = AF_INET6; 3240 remote6->sin6_port = 0; 3241 remote6->sin6_addr = in6addr_any; 3242 3243 if ((error = tcp_abort_conn(zlogp, zoneid, &l, &r)) != 0) 3244 return (error); 3245 return (0); 3246 } 3247 3248 static int 3249 get_privset(zlog_t *zlogp, priv_set_t *privs, zone_mnt_t mount_cmd) 3250 { 3251 int error = -1; 3252 zone_dochandle_t handle; 3253 char *privname = NULL; 3254 3255 if ((handle = zonecfg_init_handle()) == NULL) { 3256 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 3257 return (-1); 3258 } 3259 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 3260 zerror(zlogp, B_FALSE, "invalid configuration"); 3261 zonecfg_fini_handle(handle); 3262 return (-1); 3263 } 3264 3265 if (ALT_MOUNT(mount_cmd)) { 3266 zone_iptype_t iptype; 3267 const char *curr_iptype; 3268 3269 if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 3270 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 3271 zonecfg_fini_handle(handle); 3272 return (-1); 3273 } 3274 3275 switch (iptype) { 3276 case ZS_SHARED: 3277 curr_iptype = "shared"; 3278 break; 3279 case ZS_EXCLUSIVE: 3280 curr_iptype = "exclusive"; 3281 break; 3282 } 3283 3284 if (zonecfg_default_privset(privs, curr_iptype) == Z_OK) { 3285 zonecfg_fini_handle(handle); 3286 return (0); 3287 } 3288 zerror(zlogp, B_FALSE, 3289 "failed to determine the zone's default privilege set"); 3290 zonecfg_fini_handle(handle); 3291 return (-1); 3292 } 3293 3294 switch (zonecfg_get_privset(handle, privs, &privname)) { 3295 case Z_OK: 3296 error = 0; 3297 break; 3298 case Z_PRIV_PROHIBITED: 3299 zerror(zlogp, B_FALSE, "privilege \"%s\" is not permitted " 3300 "within the zone's privilege set", privname); 3301 break; 3302 case Z_PRIV_REQUIRED: 3303 zerror(zlogp, B_FALSE, "required privilege \"%s\" is missing " 3304 "from the zone's privilege set", privname); 3305 break; 3306 case Z_PRIV_UNKNOWN: 3307 zerror(zlogp, B_FALSE, "unknown privilege \"%s\" specified " 3308 "in the zone's privilege set", privname); 3309 break; 3310 default: 3311 zerror(zlogp, B_FALSE, "failed to determine the zone's " 3312 "privilege set"); 3313 break; 3314 } 3315 3316 free(privname); 3317 zonecfg_fini_handle(handle); 3318 return (error); 3319 } 3320 3321 static int 3322 get_rctls(zlog_t *zlogp, char **bufp, size_t *bufsizep) 3323 { 3324 nvlist_t *nvl = NULL; 3325 char *nvl_packed = NULL; 3326 size_t nvl_size = 0; 3327 nvlist_t **nvlv = NULL; 3328 int rctlcount = 0; 3329 int error = -1; 3330 zone_dochandle_t handle; 3331 struct zone_rctltab rctltab; 3332 rctlblk_t *rctlblk = NULL; 3333 uint64_t maxlwps; 3334 uint64_t maxprocs; 3335 3336 *bufp = NULL; 3337 *bufsizep = 0; 3338 3339 if ((handle = zonecfg_init_handle()) == NULL) { 3340 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 3341 return (-1); 3342 } 3343 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 3344 zerror(zlogp, B_FALSE, "invalid configuration"); 3345 zonecfg_fini_handle(handle); 3346 return (-1); 3347 } 3348 3349 rctltab.zone_rctl_valptr = NULL; 3350 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) { 3351 zerror(zlogp, B_TRUE, "%s failed", "nvlist_alloc"); 3352 goto out; 3353 } 3354 3355 /* 3356 * Allow the administrator to control both the maximum number of 3357 * process table slots and the maximum number of lwps with just the 3358 * max-processes property. If only the max-processes property is set, 3359 * we add a max-lwps property with a limit derived from max-processes. 3360 */ 3361 if (zonecfg_get_aliased_rctl(handle, ALIAS_MAXPROCS, &maxprocs) 3362 == Z_OK && 3363 zonecfg_get_aliased_rctl(handle, ALIAS_MAXLWPS, &maxlwps) 3364 == Z_NO_ENTRY) { 3365 if (zonecfg_set_aliased_rctl(handle, ALIAS_MAXLWPS, 3366 maxprocs * LWPS_PER_PROCESS) != Z_OK) { 3367 zerror(zlogp, B_FALSE, "unable to set max-lwps alias"); 3368 goto out; 3369 } 3370 } 3371 3372 if (zonecfg_setrctlent(handle) != Z_OK) { 3373 zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setrctlent"); 3374 goto out; 3375 } 3376 3377 if ((rctlblk = malloc(rctlblk_size())) == NULL) { 3378 zerror(zlogp, B_TRUE, "memory allocation failed"); 3379 goto out; 3380 } 3381 while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 3382 struct zone_rctlvaltab *rctlval; 3383 uint_t i, count; 3384 const char *name = rctltab.zone_rctl_name; 3385 3386 /* zoneadm should have already warned about unknown rctls. */ 3387 if (!zonecfg_is_rctl(name)) { 3388 zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 3389 rctltab.zone_rctl_valptr = NULL; 3390 continue; 3391 } 3392 count = 0; 3393 for (rctlval = rctltab.zone_rctl_valptr; rctlval != NULL; 3394 rctlval = rctlval->zone_rctlval_next) { 3395 count++; 3396 } 3397 if (count == 0) { /* ignore */ 3398 continue; /* Nothing to free */ 3399 } 3400 if ((nvlv = malloc(sizeof (*nvlv) * count)) == NULL) 3401 goto out; 3402 i = 0; 3403 for (rctlval = rctltab.zone_rctl_valptr; rctlval != NULL; 3404 rctlval = rctlval->zone_rctlval_next, i++) { 3405 if (nvlist_alloc(&nvlv[i], NV_UNIQUE_NAME, 0) != 0) { 3406 zerror(zlogp, B_TRUE, "%s failed", 3407 "nvlist_alloc"); 3408 goto out; 3409 } 3410 if (zonecfg_construct_rctlblk(rctlval, rctlblk) 3411 != Z_OK) { 3412 zerror(zlogp, B_FALSE, "invalid rctl value: " 3413 "(priv=%s,limit=%s,action=%s)", 3414 rctlval->zone_rctlval_priv, 3415 rctlval->zone_rctlval_limit, 3416 rctlval->zone_rctlval_action); 3417 goto out; 3418 } 3419 if (!zonecfg_valid_rctl(name, rctlblk)) { 3420 zerror(zlogp, B_FALSE, 3421 "(priv=%s,limit=%s,action=%s) is not a " 3422 "valid value for rctl '%s'", 3423 rctlval->zone_rctlval_priv, 3424 rctlval->zone_rctlval_limit, 3425 rctlval->zone_rctlval_action, 3426 name); 3427 goto out; 3428 } 3429 if (nvlist_add_uint64(nvlv[i], "privilege", 3430 rctlblk_get_privilege(rctlblk)) != 0) { 3431 zerror(zlogp, B_FALSE, "%s failed", 3432 "nvlist_add_uint64"); 3433 goto out; 3434 } 3435 if (nvlist_add_uint64(nvlv[i], "limit", 3436 rctlblk_get_value(rctlblk)) != 0) { 3437 zerror(zlogp, B_FALSE, "%s failed", 3438 "nvlist_add_uint64"); 3439 goto out; 3440 } 3441 if (nvlist_add_uint64(nvlv[i], "action", 3442 (uint_t)rctlblk_get_local_action(rctlblk, NULL)) 3443 != 0) { 3444 zerror(zlogp, B_FALSE, "%s failed", 3445 "nvlist_add_uint64"); 3446 goto out; 3447 } 3448 } 3449 zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 3450 rctltab.zone_rctl_valptr = NULL; 3451 if (nvlist_add_nvlist_array(nvl, (char *)name, nvlv, count) 3452 != 0) { 3453 zerror(zlogp, B_FALSE, "%s failed", 3454 "nvlist_add_nvlist_array"); 3455 goto out; 3456 } 3457 for (i = 0; i < count; i++) 3458 nvlist_free(nvlv[i]); 3459 free(nvlv); 3460 nvlv = NULL; 3461 rctlcount++; 3462 } 3463 (void) zonecfg_endrctlent(handle); 3464 3465 if (rctlcount == 0) { 3466 error = 0; 3467 goto out; 3468 } 3469 if (nvlist_pack(nvl, &nvl_packed, &nvl_size, NV_ENCODE_NATIVE, 0) 3470 != 0) { 3471 zerror(zlogp, B_FALSE, "%s failed", "nvlist_pack"); 3472 goto out; 3473 } 3474 3475 error = 0; 3476 *bufp = nvl_packed; 3477 *bufsizep = nvl_size; 3478 3479 out: 3480 free(rctlblk); 3481 zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 3482 if (error && nvl_packed != NULL) 3483 free(nvl_packed); 3484 nvlist_free(nvl); 3485 if (nvlv != NULL) 3486 free(nvlv); 3487 if (handle != NULL) 3488 zonecfg_fini_handle(handle); 3489 return (error); 3490 } 3491 3492 static int 3493 get_implicit_datasets(zlog_t *zlogp, char **retstr) 3494 { 3495 char cmdbuf[2 * MAXPATHLEN]; 3496 3497 if (query_hook[0] == '\0') 3498 return (0); 3499 3500 if (snprintf(cmdbuf, sizeof (cmdbuf), "%s datasets", query_hook) 3501 > sizeof (cmdbuf)) 3502 return (-1); 3503 3504 if (do_subproc(zlogp, cmdbuf, retstr) != 0) 3505 return (-1); 3506 3507 return (0); 3508 } 3509 3510 static int 3511 get_datasets(zlog_t *zlogp, char **bufp, size_t *bufsizep) 3512 { 3513 zone_dochandle_t handle; 3514 struct zone_dstab dstab; 3515 size_t total, offset, len; 3516 int error = -1; 3517 char *str = NULL; 3518 char *implicit_datasets = NULL; 3519 int implicit_len = 0; 3520 3521 *bufp = NULL; 3522 *bufsizep = 0; 3523 3524 if ((handle = zonecfg_init_handle()) == NULL) { 3525 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 3526 return (-1); 3527 } 3528 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 3529 zerror(zlogp, B_FALSE, "invalid configuration"); 3530 zonecfg_fini_handle(handle); 3531 return (-1); 3532 } 3533 3534 if (get_implicit_datasets(zlogp, &implicit_datasets) != 0) { 3535 zerror(zlogp, B_FALSE, "getting implicit datasets failed"); 3536 goto out; 3537 } 3538 3539 if (zonecfg_setdsent(handle) != Z_OK) { 3540 zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setdsent"); 3541 goto out; 3542 } 3543 3544 total = 0; 3545 while (zonecfg_getdsent(handle, &dstab) == Z_OK) 3546 total += strlen(dstab.zone_dataset_name) + 1; 3547 (void) zonecfg_enddsent(handle); 3548 3549 if (implicit_datasets != NULL) 3550 implicit_len = strlen(implicit_datasets); 3551 if (implicit_len > 0) 3552 total += implicit_len + 1; 3553 3554 if (total == 0) { 3555 error = 0; 3556 goto out; 3557 } 3558 3559 if ((str = malloc(total)) == NULL) { 3560 zerror(zlogp, B_TRUE, "memory allocation failed"); 3561 goto out; 3562 } 3563 3564 if (zonecfg_setdsent(handle) != Z_OK) { 3565 zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setdsent"); 3566 goto out; 3567 } 3568 offset = 0; 3569 while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 3570 len = strlen(dstab.zone_dataset_name); 3571 (void) strlcpy(str + offset, dstab.zone_dataset_name, 3572 total - offset); 3573 offset += len; 3574 if (offset < total - 1) 3575 str[offset++] = ','; 3576 } 3577 (void) zonecfg_enddsent(handle); 3578 3579 if (implicit_len > 0) 3580 (void) strlcpy(str + offset, implicit_datasets, total - offset); 3581 3582 error = 0; 3583 *bufp = str; 3584 *bufsizep = total; 3585 3586 out: 3587 if (error != 0 && str != NULL) 3588 free(str); 3589 if (handle != NULL) 3590 zonecfg_fini_handle(handle); 3591 if (implicit_datasets != NULL) 3592 free(implicit_datasets); 3593 3594 return (error); 3595 } 3596 3597 static int 3598 validate_datasets(zlog_t *zlogp) 3599 { 3600 zone_dochandle_t handle; 3601 struct zone_dstab dstab; 3602 zfs_handle_t *zhp; 3603 libzfs_handle_t *hdl; 3604 3605 if ((handle = zonecfg_init_handle()) == NULL) { 3606 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 3607 return (-1); 3608 } 3609 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 3610 zerror(zlogp, B_FALSE, "invalid configuration"); 3611 zonecfg_fini_handle(handle); 3612 return (-1); 3613 } 3614 3615 if (zonecfg_setdsent(handle) != Z_OK) { 3616 zerror(zlogp, B_FALSE, "invalid configuration"); 3617 zonecfg_fini_handle(handle); 3618 return (-1); 3619 } 3620 3621 if ((hdl = libzfs_init()) == NULL) { 3622 zerror(zlogp, B_FALSE, "opening ZFS library"); 3623 zonecfg_fini_handle(handle); 3624 return (-1); 3625 } 3626 3627 while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 3628 3629 if ((zhp = zfs_open(hdl, dstab.zone_dataset_name, 3630 ZFS_TYPE_FILESYSTEM)) == NULL) { 3631 zerror(zlogp, B_FALSE, "cannot open ZFS dataset '%s'", 3632 dstab.zone_dataset_name); 3633 zonecfg_fini_handle(handle); 3634 libzfs_fini(hdl); 3635 return (-1); 3636 } 3637 3638 /* 3639 * Automatically set the 'zoned' property. We check the value 3640 * first because we'll get EPERM if it is already set. 3641 */ 3642 if (!zfs_prop_get_int(zhp, ZFS_PROP_ZONED) && 3643 zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_ZONED), 3644 "on") != 0) { 3645 zerror(zlogp, B_FALSE, "cannot set 'zoned' " 3646 "property for ZFS dataset '%s'\n", 3647 dstab.zone_dataset_name); 3648 zonecfg_fini_handle(handle); 3649 zfs_close(zhp); 3650 libzfs_fini(hdl); 3651 return (-1); 3652 } 3653 3654 zfs_close(zhp); 3655 } 3656 (void) zonecfg_enddsent(handle); 3657 3658 zonecfg_fini_handle(handle); 3659 libzfs_fini(hdl); 3660 3661 return (0); 3662 } 3663 3664 /* 3665 * Return true if the path is its own zfs file system. We determine this 3666 * by stat-ing the path to see if it is zfs and stat-ing the parent to see 3667 * if it is a different fs. 3668 */ 3669 boolean_t 3670 is_zonepath_zfs(char *zonepath) 3671 { 3672 int res; 3673 char *path; 3674 char *parent; 3675 struct statvfs64 buf1, buf2; 3676 3677 if (statvfs64(zonepath, &buf1) != 0) 3678 return (B_FALSE); 3679 3680 if (strcmp(buf1.f_basetype, "zfs") != 0) 3681 return (B_FALSE); 3682 3683 if ((path = strdup(zonepath)) == NULL) 3684 return (B_FALSE); 3685 3686 parent = dirname(path); 3687 res = statvfs64(parent, &buf2); 3688 free(path); 3689 3690 if (res != 0) 3691 return (B_FALSE); 3692 3693 if (buf1.f_fsid == buf2.f_fsid) 3694 return (B_FALSE); 3695 3696 return (B_TRUE); 3697 } 3698 3699 /* 3700 * Verify the MAC label in the root dataset for the zone. 3701 * If the label exists, it must match the label configured for the zone. 3702 * Otherwise if there's no label on the dataset, create one here. 3703 */ 3704 3705 static int 3706 validate_rootds_label(zlog_t *zlogp, char *rootpath, m_label_t *zone_sl) 3707 { 3708 int error = -1; 3709 zfs_handle_t *zhp; 3710 libzfs_handle_t *hdl; 3711 m_label_t ds_sl; 3712 char zonepath[MAXPATHLEN]; 3713 char ds_hexsl[MAXNAMELEN]; 3714 3715 if (!is_system_labeled()) 3716 return (0); 3717 3718 if (zone_get_zonepath(zone_name, zonepath, sizeof (zonepath)) != Z_OK) { 3719 zerror(zlogp, B_TRUE, "unable to determine zone path"); 3720 return (-1); 3721 } 3722 3723 if (!is_zonepath_zfs(zonepath)) 3724 return (0); 3725 3726 if ((hdl = libzfs_init()) == NULL) { 3727 zerror(zlogp, B_FALSE, "opening ZFS library"); 3728 return (-1); 3729 } 3730 3731 if ((zhp = zfs_path_to_zhandle(hdl, rootpath, 3732 ZFS_TYPE_FILESYSTEM)) == NULL) { 3733 zerror(zlogp, B_FALSE, "cannot open ZFS dataset for path '%s'", 3734 rootpath); 3735 libzfs_fini(hdl); 3736 return (-1); 3737 } 3738 3739 /* Get the mlslabel property if it exists. */ 3740 if ((zfs_prop_get(zhp, ZFS_PROP_MLSLABEL, ds_hexsl, MAXNAMELEN, 3741 NULL, NULL, 0, B_TRUE) != 0) || 3742 (strcmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) == 0)) { 3743 char *str2 = NULL; 3744 3745 /* 3746 * No label on the dataset (or default only); create one. 3747 * (Only do this automatic labeling for the labeled brand.) 3748 */ 3749 if (strcmp(brand_name, LABELED_BRAND_NAME) != 0) { 3750 error = 0; 3751 goto out; 3752 } 3753 3754 error = l_to_str_internal(zone_sl, &str2); 3755 if (error) 3756 goto out; 3757 if (str2 == NULL) { 3758 error = -1; 3759 goto out; 3760 } 3761 if ((error = zfs_prop_set(zhp, 3762 zfs_prop_to_name(ZFS_PROP_MLSLABEL), str2)) != 0) { 3763 zerror(zlogp, B_FALSE, "cannot set 'mlslabel' " 3764 "property for root dataset at '%s'\n", rootpath); 3765 } 3766 free(str2); 3767 goto out; 3768 } 3769 3770 /* Convert the retrieved dataset label to binary form. */ 3771 error = hexstr_to_label(ds_hexsl, &ds_sl); 3772 if (error) { 3773 zerror(zlogp, B_FALSE, "invalid 'mlslabel' " 3774 "property on root dataset at '%s'\n", rootpath); 3775 goto out; /* exit with error */ 3776 } 3777 3778 /* 3779 * Perform a MAC check by comparing the zone label with the 3780 * dataset label. 3781 */ 3782 error = (!blequal(zone_sl, &ds_sl)); 3783 if (error) 3784 zerror(zlogp, B_FALSE, "Rootpath dataset has mismatched label"); 3785 out: 3786 zfs_close(zhp); 3787 libzfs_fini(hdl); 3788 3789 return (error); 3790 } 3791 3792 /* 3793 * Mount lower level home directories into/from current zone 3794 * Share exported directories specified in dfstab for zone 3795 */ 3796 static int 3797 tsol_mounts(zlog_t *zlogp, char *zone_name, char *rootpath) 3798 { 3799 zoneid_t *zids = NULL; 3800 priv_set_t *zid_privs; 3801 const priv_impl_info_t *ip = NULL; 3802 uint_t nzents_saved; 3803 uint_t nzents; 3804 int i; 3805 char readonly[] = "ro"; 3806 struct zone_fstab lower_fstab; 3807 char *argv[4]; 3808 3809 if (!is_system_labeled()) 3810 return (0); 3811 3812 if (zid_label == NULL) { 3813 zid_label = m_label_alloc(MAC_LABEL); 3814 if (zid_label == NULL) 3815 return (-1); 3816 } 3817 3818 /* Make sure our zone has an /export/home dir */ 3819 (void) make_one_dir(zlogp, rootpath, "/export/home", 3820 DEFAULT_DIR_MODE, DEFAULT_DIR_USER, DEFAULT_DIR_GROUP); 3821 3822 lower_fstab.zone_fs_raw[0] = '\0'; 3823 (void) strlcpy(lower_fstab.zone_fs_type, MNTTYPE_LOFS, 3824 sizeof (lower_fstab.zone_fs_type)); 3825 lower_fstab.zone_fs_options = NULL; 3826 (void) zonecfg_add_fs_option(&lower_fstab, readonly); 3827 3828 /* 3829 * Get the list of zones from the kernel 3830 */ 3831 if (zone_list(NULL, &nzents) != 0) { 3832 zerror(zlogp, B_TRUE, "unable to list zones"); 3833 zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 3834 return (-1); 3835 } 3836 again: 3837 if (nzents == 0) { 3838 zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 3839 return (-1); 3840 } 3841 3842 zids = malloc(nzents * sizeof (zoneid_t)); 3843 if (zids == NULL) { 3844 zerror(zlogp, B_TRUE, "memory allocation failed"); 3845 return (-1); 3846 } 3847 nzents_saved = nzents; 3848 3849 if (zone_list(zids, &nzents) != 0) { 3850 zerror(zlogp, B_TRUE, "unable to list zones"); 3851 zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 3852 free(zids); 3853 return (-1); 3854 } 3855 if (nzents != nzents_saved) { 3856 /* list changed, try again */ 3857 free(zids); 3858 goto again; 3859 } 3860 3861 ip = getprivimplinfo(); 3862 if ((zid_privs = priv_allocset()) == NULL) { 3863 zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 3864 zonecfg_free_fs_option_list( 3865 lower_fstab.zone_fs_options); 3866 free(zids); 3867 return (-1); 3868 } 3869 3870 for (i = 0; i < nzents; i++) { 3871 char zid_name[ZONENAME_MAX]; 3872 zone_state_t zid_state; 3873 char zid_rpath[MAXPATHLEN]; 3874 struct stat stat_buf; 3875 3876 if (zids[i] == GLOBAL_ZONEID) 3877 continue; 3878 3879 if (getzonenamebyid(zids[i], zid_name, ZONENAME_MAX) == -1) 3880 continue; 3881 3882 /* 3883 * Do special setup for the zone we are booting 3884 */ 3885 if (strcmp(zid_name, zone_name) == 0) { 3886 struct zone_fstab autofs_fstab; 3887 char map_path[MAXPATHLEN]; 3888 int fd; 3889 3890 /* 3891 * Create auto_home_<zone> map for this zone 3892 * in the global zone. The non-global zone entry 3893 * will be created by automount when the zone 3894 * is booted. 3895 */ 3896 3897 (void) snprintf(autofs_fstab.zone_fs_special, 3898 MAXPATHLEN, "auto_home_%s", zid_name); 3899 3900 (void) snprintf(autofs_fstab.zone_fs_dir, MAXPATHLEN, 3901 "/zone/%s/home", zid_name); 3902 3903 (void) snprintf(map_path, sizeof (map_path), 3904 "/etc/%s", autofs_fstab.zone_fs_special); 3905 /* 3906 * If the map file doesn't exist create a template 3907 */ 3908 if ((fd = open(map_path, O_RDWR | O_CREAT | O_EXCL, 3909 S_IRUSR | S_IWUSR | S_IRGRP| S_IROTH)) != -1) { 3910 int len; 3911 char map_rec[MAXPATHLEN]; 3912 3913 len = snprintf(map_rec, sizeof (map_rec), 3914 "+%s\n*\t-fstype=lofs\t:%s/export/home/&\n", 3915 autofs_fstab.zone_fs_special, rootpath); 3916 (void) write(fd, map_rec, len); 3917 (void) close(fd); 3918 } 3919 3920 /* 3921 * Mount auto_home_<zone> in the global zone if absent. 3922 * If it's already of type autofs, then 3923 * don't mount it again. 3924 */ 3925 if ((stat(autofs_fstab.zone_fs_dir, &stat_buf) == -1) || 3926 strcmp(stat_buf.st_fstype, MNTTYPE_AUTOFS) != 0) { 3927 char optstr[] = "indirect,ignore,nobrowse"; 3928 3929 (void) make_one_dir(zlogp, "", 3930 autofs_fstab.zone_fs_dir, DEFAULT_DIR_MODE, 3931 DEFAULT_DIR_USER, DEFAULT_DIR_GROUP); 3932 3933 /* 3934 * Mount will fail if automounter has already 3935 * processed the auto_home_<zonename> map 3936 */ 3937 (void) domount(zlogp, MNTTYPE_AUTOFS, optstr, 3938 autofs_fstab.zone_fs_special, 3939 autofs_fstab.zone_fs_dir); 3940 } 3941 continue; 3942 } 3943 3944 3945 if (zone_get_state(zid_name, &zid_state) != Z_OK || 3946 (zid_state != ZONE_STATE_READY && 3947 zid_state != ZONE_STATE_RUNNING)) 3948 /* Skip over zones without mounted filesystems */ 3949 continue; 3950 3951 if (zone_getattr(zids[i], ZONE_ATTR_SLBL, zid_label, 3952 sizeof (m_label_t)) < 0) 3953 /* Skip over zones with unspecified label */ 3954 continue; 3955 3956 if (zone_getattr(zids[i], ZONE_ATTR_ROOT, zid_rpath, 3957 sizeof (zid_rpath)) == -1) 3958 /* Skip over zones with bad path */ 3959 continue; 3960 3961 if (zone_getattr(zids[i], ZONE_ATTR_PRIVSET, zid_privs, 3962 sizeof (priv_chunk_t) * ip->priv_setsize) == -1) 3963 /* Skip over zones with bad privs */ 3964 continue; 3965 3966 /* 3967 * Reading down is valid according to our label model 3968 * but some customers want to disable it because it 3969 * allows execute down and other possible attacks. 3970 * Therefore, we restrict this feature to zones that 3971 * have the NET_MAC_AWARE privilege which is required 3972 * for NFS read-down semantics. 3973 */ 3974 if ((bldominates(zlabel, zid_label)) && 3975 (priv_ismember(zprivs, PRIV_NET_MAC_AWARE))) { 3976 /* 3977 * Our zone dominates this one. 3978 * Create a lofs mount from lower zone's /export/home 3979 */ 3980 (void) snprintf(lower_fstab.zone_fs_dir, MAXPATHLEN, 3981 "%s/zone/%s/export/home", rootpath, zid_name); 3982 3983 /* 3984 * If the target is already an LOFS mount 3985 * then don't do it again. 3986 */ 3987 if ((stat(lower_fstab.zone_fs_dir, &stat_buf) == -1) || 3988 strcmp(stat_buf.st_fstype, MNTTYPE_LOFS) != 0) { 3989 3990 if (snprintf(lower_fstab.zone_fs_special, 3991 MAXPATHLEN, "%s/export", 3992 zid_rpath) > MAXPATHLEN) 3993 continue; 3994 3995 /* 3996 * Make sure the lower-level home exists 3997 */ 3998 if (make_one_dir(zlogp, 3999 lower_fstab.zone_fs_special, "/home", 4000 DEFAULT_DIR_MODE, DEFAULT_DIR_USER, 4001 DEFAULT_DIR_GROUP) != 0) 4002 continue; 4003 4004 (void) strlcat(lower_fstab.zone_fs_special, 4005 "/home", MAXPATHLEN); 4006 4007 /* 4008 * Mount can fail because the lower-level 4009 * zone may have already done a mount up. 4010 */ 4011 (void) mount_one(zlogp, &lower_fstab, "", 4012 Z_MNT_BOOT); 4013 } 4014 } else if ((bldominates(zid_label, zlabel)) && 4015 (priv_ismember(zid_privs, PRIV_NET_MAC_AWARE))) { 4016 /* 4017 * This zone dominates our zone. 4018 * Create a lofs mount from our zone's /export/home 4019 */ 4020 if (snprintf(lower_fstab.zone_fs_dir, MAXPATHLEN, 4021 "%s/zone/%s/export/home", zid_rpath, 4022 zone_name) > MAXPATHLEN) 4023 continue; 4024 4025 /* 4026 * If the target is already an LOFS mount 4027 * then don't do it again. 4028 */ 4029 if ((stat(lower_fstab.zone_fs_dir, &stat_buf) == -1) || 4030 strcmp(stat_buf.st_fstype, MNTTYPE_LOFS) != 0) { 4031 4032 (void) snprintf(lower_fstab.zone_fs_special, 4033 MAXPATHLEN, "%s/export/home", rootpath); 4034 4035 /* 4036 * Mount can fail because the higher-level 4037 * zone may have already done a mount down. 4038 */ 4039 (void) mount_one(zlogp, &lower_fstab, "", 4040 Z_MNT_BOOT); 4041 } 4042 } 4043 } 4044 zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 4045 priv_freeset(zid_privs); 4046 free(zids); 4047 4048 /* 4049 * Now share any exported directories from this zone. 4050 * Each zone can have its own dfstab. 4051 */ 4052 4053 argv[0] = "zoneshare"; 4054 argv[1] = "-z"; 4055 argv[2] = zone_name; 4056 argv[3] = NULL; 4057 4058 (void) forkexec(zlogp, "/usr/lib/zones/zoneshare", argv); 4059 /* Don't check for errors since they don't affect the zone */ 4060 4061 return (0); 4062 } 4063 4064 /* 4065 * Unmount lofs mounts from higher level zones 4066 * Unshare nfs exported directories 4067 */ 4068 static void 4069 tsol_unmounts(zlog_t *zlogp, char *zone_name) 4070 { 4071 zoneid_t *zids = NULL; 4072 uint_t nzents_saved; 4073 uint_t nzents; 4074 int i; 4075 char *argv[4]; 4076 char path[MAXPATHLEN]; 4077 4078 if (!is_system_labeled()) 4079 return; 4080 4081 /* 4082 * Get the list of zones from the kernel 4083 */ 4084 if (zone_list(NULL, &nzents) != 0) { 4085 return; 4086 } 4087 4088 if (zid_label == NULL) { 4089 zid_label = m_label_alloc(MAC_LABEL); 4090 if (zid_label == NULL) 4091 return; 4092 } 4093 4094 again: 4095 if (nzents == 0) 4096 return; 4097 4098 zids = malloc(nzents * sizeof (zoneid_t)); 4099 if (zids == NULL) { 4100 zerror(zlogp, B_TRUE, "memory allocation failed"); 4101 return; 4102 } 4103 nzents_saved = nzents; 4104 4105 if (zone_list(zids, &nzents) != 0) { 4106 free(zids); 4107 return; 4108 } 4109 if (nzents != nzents_saved) { 4110 /* list changed, try again */ 4111 free(zids); 4112 goto again; 4113 } 4114 4115 for (i = 0; i < nzents; i++) { 4116 char zid_name[ZONENAME_MAX]; 4117 zone_state_t zid_state; 4118 char zid_rpath[MAXPATHLEN]; 4119 4120 if (zids[i] == GLOBAL_ZONEID) 4121 continue; 4122 4123 if (getzonenamebyid(zids[i], zid_name, ZONENAME_MAX) == -1) 4124 continue; 4125 4126 /* 4127 * Skip the zone we are halting 4128 */ 4129 if (strcmp(zid_name, zone_name) == 0) 4130 continue; 4131 4132 if ((zone_getattr(zids[i], ZONE_ATTR_STATUS, &zid_state, 4133 sizeof (zid_state)) < 0) || 4134 (zid_state < ZONE_IS_READY)) 4135 /* Skip over zones without mounted filesystems */ 4136 continue; 4137 4138 if (zone_getattr(zids[i], ZONE_ATTR_SLBL, zid_label, 4139 sizeof (m_label_t)) < 0) 4140 /* Skip over zones with unspecified label */ 4141 continue; 4142 4143 if (zone_getattr(zids[i], ZONE_ATTR_ROOT, zid_rpath, 4144 sizeof (zid_rpath)) == -1) 4145 /* Skip over zones with bad path */ 4146 continue; 4147 4148 if (zlabel != NULL && bldominates(zid_label, zlabel)) { 4149 /* 4150 * This zone dominates our zone. 4151 * Unmount the lofs mount of our zone's /export/home 4152 */ 4153 4154 if (snprintf(path, MAXPATHLEN, 4155 "%s/zone/%s/export/home", zid_rpath, 4156 zone_name) > MAXPATHLEN) 4157 continue; 4158 4159 /* Skip over mount failures */ 4160 (void) umount(path); 4161 } 4162 } 4163 free(zids); 4164 4165 /* 4166 * Unmount global zone autofs trigger for this zone 4167 */ 4168 (void) snprintf(path, MAXPATHLEN, "/zone/%s/home", zone_name); 4169 /* Skip over mount failures */ 4170 (void) umount(path); 4171 4172 /* 4173 * Next unshare any exported directories from this zone. 4174 */ 4175 4176 argv[0] = "zoneunshare"; 4177 argv[1] = "-z"; 4178 argv[2] = zone_name; 4179 argv[3] = NULL; 4180 4181 (void) forkexec(zlogp, "/usr/lib/zones/zoneunshare", argv); 4182 /* Don't check for errors since they don't affect the zone */ 4183 4184 /* 4185 * Finally, deallocate any devices in the zone. 4186 */ 4187 4188 argv[0] = "deallocate"; 4189 argv[1] = "-Isz"; 4190 argv[2] = zone_name; 4191 argv[3] = NULL; 4192 4193 (void) forkexec(zlogp, "/usr/sbin/deallocate", argv); 4194 /* Don't check for errors since they don't affect the zone */ 4195 } 4196 4197 /* 4198 * Fetch the Trusted Extensions label and multi-level ports (MLPs) for 4199 * this zone. 4200 */ 4201 static tsol_zcent_t * 4202 get_zone_label(zlog_t *zlogp, priv_set_t *privs) 4203 { 4204 FILE *fp; 4205 tsol_zcent_t *zcent = NULL; 4206 char line[MAXTNZLEN]; 4207 4208 if ((fp = fopen(TNZONECFG_PATH, "r")) == NULL) { 4209 zerror(zlogp, B_TRUE, "%s", TNZONECFG_PATH); 4210 return (NULL); 4211 } 4212 4213 while (fgets(line, sizeof (line), fp) != NULL) { 4214 /* 4215 * Check for malformed database 4216 */ 4217 if (strlen(line) == MAXTNZLEN - 1) 4218 break; 4219 if ((zcent = tsol_sgetzcent(line, NULL, NULL)) == NULL) 4220 continue; 4221 if (strcmp(zcent->zc_name, zone_name) == 0) 4222 break; 4223 tsol_freezcent(zcent); 4224 zcent = NULL; 4225 } 4226 (void) fclose(fp); 4227 4228 if (zcent == NULL) { 4229 zerror(zlogp, B_FALSE, "zone requires a label assignment. " 4230 "See tnzonecfg(4)"); 4231 } else { 4232 if (zlabel == NULL) 4233 zlabel = m_label_alloc(MAC_LABEL); 4234 /* 4235 * Save this zone's privileges for later read-down processing 4236 */ 4237 if ((zprivs = priv_allocset()) == NULL) { 4238 zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 4239 return (NULL); 4240 } else { 4241 priv_copyset(privs, zprivs); 4242 } 4243 } 4244 return (zcent); 4245 } 4246 4247 /* 4248 * Add the Trusted Extensions multi-level ports for this zone. 4249 */ 4250 static void 4251 set_mlps(zlog_t *zlogp, zoneid_t zoneid, tsol_zcent_t *zcent) 4252 { 4253 tsol_mlp_t *mlp; 4254 tsol_mlpent_t tsme; 4255 4256 if (!is_system_labeled()) 4257 return; 4258 4259 tsme.tsme_zoneid = zoneid; 4260 tsme.tsme_flags = 0; 4261 for (mlp = zcent->zc_private_mlp; !TSOL_MLP_END(mlp); mlp++) { 4262 tsme.tsme_mlp = *mlp; 4263 if (tnmlp(TNDB_LOAD, &tsme) != 0) { 4264 zerror(zlogp, B_TRUE, "cannot set zone-specific MLP " 4265 "on %d-%d/%d", mlp->mlp_port, 4266 mlp->mlp_port_upper, mlp->mlp_ipp); 4267 } 4268 } 4269 4270 tsme.tsme_flags = TSOL_MEF_SHARED; 4271 for (mlp = zcent->zc_shared_mlp; !TSOL_MLP_END(mlp); mlp++) { 4272 tsme.tsme_mlp = *mlp; 4273 if (tnmlp(TNDB_LOAD, &tsme) != 0) { 4274 zerror(zlogp, B_TRUE, "cannot set shared MLP " 4275 "on %d-%d/%d", mlp->mlp_port, 4276 mlp->mlp_port_upper, mlp->mlp_ipp); 4277 } 4278 } 4279 } 4280 4281 static void 4282 remove_mlps(zlog_t *zlogp, zoneid_t zoneid) 4283 { 4284 tsol_mlpent_t tsme; 4285 4286 if (!is_system_labeled()) 4287 return; 4288 4289 (void) memset(&tsme, 0, sizeof (tsme)); 4290 tsme.tsme_zoneid = zoneid; 4291 if (tnmlp(TNDB_FLUSH, &tsme) != 0) 4292 zerror(zlogp, B_TRUE, "cannot flush MLPs"); 4293 } 4294 4295 int 4296 prtmount(const struct mnttab *fs, void *x) 4297 { 4298 zerror((zlog_t *)x, B_FALSE, " %s", fs->mnt_mountp); 4299 return (0); 4300 } 4301 4302 /* 4303 * Look for zones running on the main system that are using this root (or any 4304 * subdirectory of it). Return B_TRUE and print an error if a conflicting zone 4305 * is found or if we can't tell. 4306 */ 4307 static boolean_t 4308 duplicate_zone_root(zlog_t *zlogp, const char *rootpath) 4309 { 4310 zoneid_t *zids = NULL; 4311 uint_t nzids = 0; 4312 boolean_t retv; 4313 int rlen, zlen; 4314 char zroot[MAXPATHLEN]; 4315 char zonename[ZONENAME_MAX]; 4316 4317 for (;;) { 4318 nzids += 10; 4319 zids = malloc(nzids * sizeof (*zids)); 4320 if (zids == NULL) { 4321 zerror(zlogp, B_TRUE, "memory allocation failed"); 4322 return (B_TRUE); 4323 } 4324 if (zone_list(zids, &nzids) == 0) 4325 break; 4326 free(zids); 4327 } 4328 retv = B_FALSE; 4329 rlen = strlen(rootpath); 4330 while (nzids > 0) { 4331 /* 4332 * Ignore errors; they just mean that the zone has disappeared 4333 * while we were busy. 4334 */ 4335 if (zone_getattr(zids[--nzids], ZONE_ATTR_ROOT, zroot, 4336 sizeof (zroot)) == -1) 4337 continue; 4338 zlen = strlen(zroot); 4339 if (zlen > rlen) 4340 zlen = rlen; 4341 if (strncmp(rootpath, zroot, zlen) == 0 && 4342 (zroot[zlen] == '\0' || zroot[zlen] == '/') && 4343 (rootpath[zlen] == '\0' || rootpath[zlen] == '/')) { 4344 if (getzonenamebyid(zids[nzids], zonename, 4345 sizeof (zonename)) == -1) 4346 (void) snprintf(zonename, sizeof (zonename), 4347 "id %d", (int)zids[nzids]); 4348 zerror(zlogp, B_FALSE, 4349 "zone root %s already in use by zone %s", 4350 rootpath, zonename); 4351 retv = B_TRUE; 4352 break; 4353 } 4354 } 4355 free(zids); 4356 return (retv); 4357 } 4358 4359 /* 4360 * Search for loopback mounts that use this same source node (same device and 4361 * inode). Return B_TRUE if there is one or if we can't tell. 4362 */ 4363 static boolean_t 4364 duplicate_reachable_path(zlog_t *zlogp, const char *rootpath) 4365 { 4366 struct stat64 rst, zst; 4367 struct mnttab *mnp; 4368 4369 if (stat64(rootpath, &rst) == -1) { 4370 zerror(zlogp, B_TRUE, "can't stat %s", rootpath); 4371 return (B_TRUE); 4372 } 4373 if (resolve_lofs_mnts == NULL && lofs_read_mnttab(zlogp) == -1) 4374 return (B_TRUE); 4375 for (mnp = resolve_lofs_mnts; mnp < resolve_lofs_mnt_max; mnp++) { 4376 if (mnp->mnt_fstype == NULL || 4377 strcmp(MNTTYPE_LOFS, mnp->mnt_fstype) != 0) 4378 continue; 4379 /* We're looking at a loopback mount. Stat it. */ 4380 if (mnp->mnt_special != NULL && 4381 stat64(mnp->mnt_special, &zst) != -1 && 4382 rst.st_dev == zst.st_dev && rst.st_ino == zst.st_ino) { 4383 zerror(zlogp, B_FALSE, 4384 "zone root %s is reachable through %s", 4385 rootpath, mnp->mnt_mountp); 4386 return (B_TRUE); 4387 } 4388 } 4389 return (B_FALSE); 4390 } 4391 4392 /* 4393 * Set memory cap and pool info for the zone's resource management 4394 * configuration. 4395 */ 4396 static int 4397 setup_zone_rm(zlog_t *zlogp, char *zone_name, zoneid_t zoneid) 4398 { 4399 int res; 4400 uint64_t tmp; 4401 struct zone_mcaptab mcap; 4402 char sched[MAXNAMELEN]; 4403 zone_dochandle_t handle = NULL; 4404 char pool_err[128]; 4405 4406 if ((handle = zonecfg_init_handle()) == NULL) { 4407 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 4408 return (Z_BAD_HANDLE); 4409 } 4410 4411 if ((res = zonecfg_get_snapshot_handle(zone_name, handle)) != Z_OK) { 4412 zerror(zlogp, B_FALSE, "invalid configuration"); 4413 zonecfg_fini_handle(handle); 4414 return (res); 4415 } 4416 4417 /* 4418 * If a memory cap is configured, set the cap in the kernel using 4419 * zone_setattr() and make sure the rcapd SMF service is enabled. 4420 */ 4421 if (zonecfg_getmcapent(handle, &mcap) == Z_OK) { 4422 uint64_t num; 4423 char smf_err[128]; 4424 4425 num = (uint64_t)strtoull(mcap.zone_physmem_cap, NULL, 10); 4426 if (zone_setattr(zoneid, ZONE_ATTR_PHYS_MCAP, &num, 0) == -1) { 4427 zerror(zlogp, B_TRUE, "could not set zone memory cap"); 4428 zonecfg_fini_handle(handle); 4429 return (Z_INVAL); 4430 } 4431 4432 if (zonecfg_enable_rcapd(smf_err, sizeof (smf_err)) != Z_OK) { 4433 zerror(zlogp, B_FALSE, "enabling system/rcap service " 4434 "failed: %s", smf_err); 4435 zonecfg_fini_handle(handle); 4436 return (Z_INVAL); 4437 } 4438 } 4439 4440 /* Get the scheduling class set in the zone configuration. */ 4441 if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 4442 strlen(sched) > 0) { 4443 if (zone_setattr(zoneid, ZONE_ATTR_SCHED_CLASS, sched, 4444 strlen(sched)) == -1) 4445 zerror(zlogp, B_TRUE, "WARNING: unable to set the " 4446 "default scheduling class"); 4447 4448 } else if (zonecfg_get_aliased_rctl(handle, ALIAS_SHARES, &tmp) 4449 == Z_OK) { 4450 /* 4451 * If the zone has the zone.cpu-shares rctl set then we want to 4452 * use the Fair Share Scheduler (FSS) for processes in the 4453 * zone. Check what scheduling class the zone would be running 4454 * in by default so we can print a warning and modify the class 4455 * if we wouldn't be using FSS. 4456 */ 4457 char class_name[PC_CLNMSZ]; 4458 4459 if (zonecfg_get_dflt_sched_class(handle, class_name, 4460 sizeof (class_name)) != Z_OK) { 4461 zerror(zlogp, B_FALSE, "WARNING: unable to determine " 4462 "the zone's scheduling class"); 4463 4464 } else if (strcmp("FSS", class_name) != 0) { 4465 zerror(zlogp, B_FALSE, "WARNING: The zone.cpu-shares " 4466 "rctl is set but\nFSS is not the default " 4467 "scheduling class for\nthis zone. FSS will be " 4468 "used for processes\nin the zone but to get the " 4469 "full benefit of FSS,\nit should be the default " 4470 "scheduling class.\nSee dispadmin(1M) for more " 4471 "details."); 4472 4473 if (zone_setattr(zoneid, ZONE_ATTR_SCHED_CLASS, "FSS", 4474 strlen("FSS")) == -1) 4475 zerror(zlogp, B_TRUE, "WARNING: unable to set " 4476 "zone scheduling class to FSS"); 4477 } 4478 } 4479 4480 /* 4481 * The next few blocks of code attempt to set up temporary pools as 4482 * well as persistent pools. In all cases we call the functions 4483 * unconditionally. Within each funtion the code will check if the 4484 * zone is actually configured for a temporary pool or persistent pool 4485 * and just return if there is nothing to do. 4486 * 4487 * If we are rebooting we want to attempt to reuse any temporary pool 4488 * that was previously set up. zonecfg_bind_tmp_pool() will do the 4489 * right thing in all cases (reuse or create) based on the current 4490 * zonecfg. 4491 */ 4492 if ((res = zonecfg_bind_tmp_pool(handle, zoneid, pool_err, 4493 sizeof (pool_err))) != Z_OK) { 4494 if (res == Z_POOL || res == Z_POOL_CREATE || res == Z_POOL_BIND) 4495 zerror(zlogp, B_FALSE, "%s: %s\ndedicated-cpu setting " 4496 "cannot be instantiated", zonecfg_strerror(res), 4497 pool_err); 4498 else 4499 zerror(zlogp, B_FALSE, "could not bind zone to " 4500 "temporary pool: %s", zonecfg_strerror(res)); 4501 zonecfg_fini_handle(handle); 4502 return (Z_POOL_BIND); 4503 } 4504 4505 /* 4506 * Check if we need to warn about poold not being enabled. 4507 */ 4508 if (zonecfg_warn_poold(handle)) { 4509 zerror(zlogp, B_FALSE, "WARNING: A range of dedicated-cpus has " 4510 "been specified\nbut the dynamic pool service is not " 4511 "enabled.\nThe system will not dynamically adjust the\n" 4512 "processor allocation within the specified range\n" 4513 "until svc:/system/pools/dynamic is enabled.\n" 4514 "See poold(1M)."); 4515 } 4516 4517 /* The following is a warning, not an error. */ 4518 if ((res = zonecfg_bind_pool(handle, zoneid, pool_err, 4519 sizeof (pool_err))) != Z_OK) { 4520 if (res == Z_POOL_BIND) 4521 zerror(zlogp, B_FALSE, "WARNING: unable to bind to " 4522 "pool '%s'; using default pool.", pool_err); 4523 else if (res == Z_POOL) 4524 zerror(zlogp, B_FALSE, "WARNING: %s: %s", 4525 zonecfg_strerror(res), pool_err); 4526 else 4527 zerror(zlogp, B_FALSE, "WARNING: %s", 4528 zonecfg_strerror(res)); 4529 } 4530 4531 /* Update saved pool name in case it has changed */ 4532 (void) zonecfg_get_poolname(handle, zone_name, pool_name, 4533 sizeof (pool_name)); 4534 4535 zonecfg_fini_handle(handle); 4536 return (Z_OK); 4537 } 4538 4539 static void 4540 report_prop_err(zlog_t *zlogp, const char *name, const char *value, int res) 4541 { 4542 switch (res) { 4543 case Z_TOO_BIG: 4544 zerror(zlogp, B_FALSE, "%s property value is too large.", name); 4545 break; 4546 4547 case Z_INVALID_PROPERTY: 4548 zerror(zlogp, B_FALSE, "%s property value \"%s\" is not valid", 4549 name, value); 4550 break; 4551 4552 default: 4553 zerror(zlogp, B_TRUE, "fetching property %s: %d", name, res); 4554 break; 4555 } 4556 } 4557 4558 /* 4559 * Sets the hostid of the new zone based on its configured value. The zone's 4560 * zone_t structure must already exist in kernel memory. 'zlogp' refers to the 4561 * log used to report errors and warnings and must be non-NULL. 'zone_namep' 4562 * is the name of the new zone and must be non-NULL. 'zoneid' is the numeric 4563 * ID of the new zone. 4564 * 4565 * This function returns zero on success and a nonzero error code on failure. 4566 */ 4567 static int 4568 setup_zone_hostid(zone_dochandle_t handle, zlog_t *zlogp, zoneid_t zoneid) 4569 { 4570 int res; 4571 char hostidp[HW_HOSTID_LEN]; 4572 unsigned int hostid; 4573 4574 res = zonecfg_get_hostid(handle, hostidp, sizeof (hostidp)); 4575 4576 if (res == Z_BAD_PROPERTY) { 4577 return (Z_OK); 4578 } else if (res != Z_OK) { 4579 report_prop_err(zlogp, "hostid", hostidp, res); 4580 return (res); 4581 } 4582 4583 hostid = (unsigned int)strtoul(hostidp, NULL, 16); 4584 if ((res = zone_setattr(zoneid, ZONE_ATTR_HOSTID, &hostid, 4585 sizeof (hostid))) != 0) { 4586 zerror(zlogp, B_TRUE, 4587 "zone hostid is not valid: %s: %d", hostidp, res); 4588 return (Z_SYSTEM); 4589 } 4590 4591 return (res); 4592 } 4593 4594 static int 4595 setup_zone_secflags(zone_dochandle_t handle, zlog_t *zlogp, zoneid_t zoneid) 4596 { 4597 psecflags_t secflags; 4598 struct zone_secflagstab tab = {0}; 4599 secflagdelta_t delt; 4600 int res; 4601 4602 res = zonecfg_lookup_secflags(handle, &tab); 4603 4604 if ((res != Z_OK) && 4605 /* The general defaulting code will handle this */ 4606 (res != Z_NO_ENTRY) && (res != Z_BAD_PROPERTY)) { 4607 zerror(zlogp, B_FALSE, "security-flags property is " 4608 "invalid: %d", res); 4609 return (res); 4610 } 4611 4612 if (strlen(tab.zone_secflags_lower) == 0) 4613 (void) strlcpy(tab.zone_secflags_lower, "none", 4614 sizeof (tab.zone_secflags_lower)); 4615 if (strlen(tab.zone_secflags_default) == 0) 4616 (void) strlcpy(tab.zone_secflags_default, 4617 tab.zone_secflags_lower, 4618 sizeof (tab.zone_secflags_default)); 4619 if (strlen(tab.zone_secflags_upper) == 0) 4620 (void) strlcpy(tab.zone_secflags_upper, "all", 4621 sizeof (tab.zone_secflags_upper)); 4622 4623 if (secflags_parse(NULL, tab.zone_secflags_default, 4624 &delt) == -1) { 4625 zerror(zlogp, B_FALSE, "default security-flags: '%s'" 4626 "are invalid", tab.zone_secflags_default); 4627 return (Z_BAD_PROPERTY); 4628 } else if (delt.psd_ass_active != B_TRUE) { 4629 zerror(zlogp, B_FALSE, "relative security-flags are not " 4630 "allowed in zone configuration (default " 4631 "security-flags: '%s')", 4632 tab.zone_secflags_default); 4633 return (Z_BAD_PROPERTY); 4634 } else { 4635 secflags_copy(&secflags.psf_inherit, &delt.psd_assign); 4636 secflags_copy(&secflags.psf_effective, &delt.psd_assign); 4637 } 4638 4639 if (secflags_parse(NULL, tab.zone_secflags_lower, 4640 &delt) == -1) { 4641 zerror(zlogp, B_FALSE, "lower security-flags: '%s'" 4642 "are invalid", tab.zone_secflags_lower); 4643 return (Z_BAD_PROPERTY); 4644 } else if (delt.psd_ass_active != B_TRUE) { 4645 zerror(zlogp, B_FALSE, "relative security-flags are not " 4646 "allowed in zone configuration (lower " 4647 "security-flags: '%s')", 4648 tab.zone_secflags_lower); 4649 return (Z_BAD_PROPERTY); 4650 } else { 4651 secflags_copy(&secflags.psf_lower, &delt.psd_assign); 4652 } 4653 4654 if (secflags_parse(NULL, tab.zone_secflags_upper, 4655 &delt) == -1) { 4656 zerror(zlogp, B_FALSE, "upper security-flags: '%s'" 4657 "are invalid", tab.zone_secflags_upper); 4658 return (Z_BAD_PROPERTY); 4659 } else if (delt.psd_ass_active != B_TRUE) { 4660 zerror(zlogp, B_FALSE, "relative security-flags are not " 4661 "allowed in zone configuration (upper " 4662 "security-flags: '%s')", 4663 tab.zone_secflags_upper); 4664 return (Z_BAD_PROPERTY); 4665 } else { 4666 secflags_copy(&secflags.psf_upper, &delt.psd_assign); 4667 } 4668 4669 if (!psecflags_validate(&secflags)) { 4670 zerror(zlogp, B_TRUE, "security-flags violate invariants"); 4671 return (Z_BAD_PROPERTY); 4672 } 4673 4674 if ((res = zone_setattr(zoneid, ZONE_ATTR_SECFLAGS, &secflags, 4675 sizeof (secflags))) != 0) { 4676 zerror(zlogp, B_TRUE, 4677 "security-flags couldn't be set: %d", res); 4678 return (Z_SYSTEM); 4679 } 4680 4681 return (Z_OK); 4682 } 4683 4684 static int 4685 setup_zone_fs_allowed(zone_dochandle_t handle, zlog_t *zlogp, zoneid_t zoneid) 4686 { 4687 char fsallowed[ZONE_FS_ALLOWED_MAX]; 4688 char *fsallowedp = fsallowed; 4689 int len = sizeof (fsallowed); 4690 int res; 4691 4692 res = zonecfg_get_fs_allowed(handle, fsallowed, len); 4693 4694 if (res == Z_BAD_PROPERTY) { 4695 /* No value, set the defaults */ 4696 (void) strlcpy(fsallowed, DFLT_FS_ALLOWED, len); 4697 } else if (res != Z_OK) { 4698 report_prop_err(zlogp, "fs-allowed", fsallowed, res); 4699 return (res); 4700 } else if (fsallowed[0] == '-') { 4701 /* dropping default filesystems - use remaining list */ 4702 if (fsallowed[1] != ',') 4703 return (Z_OK); 4704 fsallowedp += 2; 4705 len -= 2; 4706 } else { 4707 /* Has a value, append the defaults */ 4708 if (strlcat(fsallowed, ",", len) >= len || 4709 strlcat(fsallowed, DFLT_FS_ALLOWED, len) >= len) { 4710 report_prop_err(zlogp, "fs-allowed", fsallowed, 4711 Z_TOO_BIG); 4712 return (Z_TOO_BIG); 4713 } 4714 } 4715 4716 if (zone_setattr(zoneid, ZONE_ATTR_FS_ALLOWED, fsallowedp, len) != 0) { 4717 zerror(zlogp, B_TRUE, 4718 "fs-allowed couldn't be set: %s: %d", fsallowedp, res); 4719 return (Z_SYSTEM); 4720 } 4721 4722 return (Z_OK); 4723 } 4724 4725 static int 4726 setup_zone_attrs(zlog_t *zlogp, char *zone_namep, zoneid_t zoneid) 4727 { 4728 zone_dochandle_t handle; 4729 int res = Z_OK; 4730 4731 if ((handle = zonecfg_init_handle()) == NULL) { 4732 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 4733 return (Z_BAD_HANDLE); 4734 } 4735 if ((res = zonecfg_get_snapshot_handle(zone_namep, handle)) != Z_OK) { 4736 zerror(zlogp, B_FALSE, "invalid configuration"); 4737 goto out; 4738 } 4739 4740 if ((res = setup_zone_hostid(handle, zlogp, zoneid)) != Z_OK) 4741 goto out; 4742 4743 if ((res = setup_zone_fs_allowed(handle, zlogp, zoneid)) != Z_OK) 4744 goto out; 4745 4746 if ((res = setup_zone_secflags(handle, zlogp, zoneid)) != Z_OK) 4747 goto out; 4748 4749 out: 4750 zonecfg_fini_handle(handle); 4751 return (res); 4752 } 4753 4754 zoneid_t 4755 vplat_create(zlog_t *zlogp, zone_mnt_t mount_cmd) 4756 { 4757 zoneid_t rval = -1; 4758 priv_set_t *privs; 4759 char rootpath[MAXPATHLEN]; 4760 char *rctlbuf = NULL; 4761 size_t rctlbufsz = 0; 4762 char *zfsbuf = NULL; 4763 size_t zfsbufsz = 0; 4764 zoneid_t zoneid = -1; 4765 int xerr; 4766 char *kzone; 4767 FILE *fp = NULL; 4768 tsol_zcent_t *zcent = NULL; 4769 int match = 0; 4770 int doi = 0; 4771 int flags; 4772 zone_iptype_t iptype; 4773 4774 if (zone_get_rootpath(zone_name, rootpath, sizeof (rootpath)) != Z_OK) { 4775 zerror(zlogp, B_TRUE, "unable to determine zone root"); 4776 return (-1); 4777 } 4778 if (zonecfg_in_alt_root()) 4779 resolve_lofs(zlogp, rootpath, sizeof (rootpath)); 4780 4781 if (vplat_get_iptype(zlogp, &iptype) < 0) { 4782 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 4783 return (-1); 4784 } 4785 switch (iptype) { 4786 case ZS_SHARED: 4787 flags = 0; 4788 break; 4789 case ZS_EXCLUSIVE: 4790 flags = ZCF_NET_EXCL; 4791 break; 4792 } 4793 4794 if ((privs = priv_allocset()) == NULL) { 4795 zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 4796 return (-1); 4797 } 4798 priv_emptyset(privs); 4799 if (get_privset(zlogp, privs, mount_cmd) != 0) 4800 goto error; 4801 4802 if (mount_cmd == Z_MNT_BOOT && 4803 get_rctls(zlogp, &rctlbuf, &rctlbufsz) != 0) { 4804 zerror(zlogp, B_FALSE, "Unable to get list of rctls"); 4805 goto error; 4806 } 4807 4808 if (get_datasets(zlogp, &zfsbuf, &zfsbufsz) != 0) { 4809 zerror(zlogp, B_FALSE, "Unable to get list of ZFS datasets"); 4810 goto error; 4811 } 4812 4813 if (mount_cmd == Z_MNT_BOOT && is_system_labeled()) { 4814 zcent = get_zone_label(zlogp, privs); 4815 if (zcent != NULL) { 4816 match = zcent->zc_match; 4817 doi = zcent->zc_doi; 4818 *zlabel = zcent->zc_label; 4819 } else { 4820 goto error; 4821 } 4822 if (validate_rootds_label(zlogp, rootpath, zlabel) != 0) 4823 goto error; 4824 } 4825 4826 kzone = zone_name; 4827 4828 /* 4829 * We must do this scan twice. First, we look for zones running on the 4830 * main system that are using this root (or any subdirectory of it). 4831 * Next, we reduce to the shortest path and search for loopback mounts 4832 * that use this same source node (same device and inode). 4833 */ 4834 if (duplicate_zone_root(zlogp, rootpath)) 4835 goto error; 4836 if (duplicate_reachable_path(zlogp, rootpath)) 4837 goto error; 4838 4839 if (ALT_MOUNT(mount_cmd)) { 4840 root_to_lu(zlogp, rootpath, sizeof (rootpath), B_TRUE); 4841 4842 /* 4843 * Forge up a special root for this zone. When a zone is 4844 * mounted, we can't let the zone have its own root because the 4845 * tools that will be used in this "scratch zone" need access 4846 * to both the zone's resources and the running machine's 4847 * executables. 4848 * 4849 * Note that the mkdir here also catches read-only filesystems. 4850 */ 4851 if (mkdir(rootpath, 0755) != 0 && errno != EEXIST) { 4852 zerror(zlogp, B_TRUE, "cannot create %s", rootpath); 4853 goto error; 4854 } 4855 if (domount(zlogp, "tmpfs", "", "swap", rootpath) != 0) 4856 goto error; 4857 } 4858 4859 if (zonecfg_in_alt_root()) { 4860 /* 4861 * If we are mounting up a zone in an alternate root partition, 4862 * then we have some additional work to do before starting the 4863 * zone. First, resolve the root path down so that we're not 4864 * fooled by duplicates. Then forge up an internal name for 4865 * the zone. 4866 */ 4867 if ((fp = zonecfg_open_scratch("", B_TRUE)) == NULL) { 4868 zerror(zlogp, B_TRUE, "cannot open mapfile"); 4869 goto error; 4870 } 4871 if (zonecfg_lock_scratch(fp) != 0) { 4872 zerror(zlogp, B_TRUE, "cannot lock mapfile"); 4873 goto error; 4874 } 4875 if (zonecfg_find_scratch(fp, zone_name, zonecfg_get_root(), 4876 NULL, 0) == 0) { 4877 zerror(zlogp, B_FALSE, "scratch zone already running"); 4878 goto error; 4879 } 4880 /* This is the preferred name */ 4881 (void) snprintf(kernzone, sizeof (kernzone), "SUNWlu-%s", 4882 zone_name); 4883 srandom(getpid()); 4884 while (zonecfg_reverse_scratch(fp, kernzone, NULL, 0, NULL, 4885 0) == 0) { 4886 /* This is just an arbitrary name; note "." usage */ 4887 (void) snprintf(kernzone, sizeof (kernzone), 4888 "SUNWlu.%08lX%08lX", random(), random()); 4889 } 4890 kzone = kernzone; 4891 } 4892 4893 xerr = 0; 4894 if ((zoneid = zone_create(kzone, rootpath, privs, rctlbuf, 4895 rctlbufsz, zfsbuf, zfsbufsz, &xerr, match, doi, zlabel, 4896 flags)) == -1) { 4897 if (xerr == ZE_AREMOUNTS) { 4898 if (zonecfg_find_mounts(rootpath, NULL, NULL) < 1) { 4899 zerror(zlogp, B_FALSE, 4900 "An unknown file-system is mounted on " 4901 "a subdirectory of %s", rootpath); 4902 } else { 4903 4904 zerror(zlogp, B_FALSE, 4905 "These file-systems are mounted on " 4906 "subdirectories of %s:", rootpath); 4907 (void) zonecfg_find_mounts(rootpath, 4908 prtmount, zlogp); 4909 } 4910 } else if (xerr == ZE_CHROOTED) { 4911 zerror(zlogp, B_FALSE, "%s: " 4912 "cannot create a zone from a chrooted " 4913 "environment", "zone_create"); 4914 } else if (xerr == ZE_LABELINUSE) { 4915 char zonename[ZONENAME_MAX]; 4916 (void) getzonenamebyid(getzoneidbylabel(zlabel), 4917 zonename, ZONENAME_MAX); 4918 zerror(zlogp, B_FALSE, "The zone label is already " 4919 "used by the zone '%s'.", zonename); 4920 } else { 4921 zerror(zlogp, B_TRUE, "%s failed", "zone_create"); 4922 } 4923 goto error; 4924 } 4925 4926 if (zonecfg_in_alt_root() && 4927 zonecfg_add_scratch(fp, zone_name, kernzone, 4928 zonecfg_get_root()) == -1) { 4929 zerror(zlogp, B_TRUE, "cannot add mapfile entry"); 4930 goto error; 4931 } 4932 4933 /* 4934 * The following actions are not performed when merely mounting a zone 4935 * for administrative use. 4936 */ 4937 if (mount_cmd == Z_MNT_BOOT) { 4938 brand_handle_t bh; 4939 struct brand_attr attr; 4940 char modname[MAXPATHLEN]; 4941 4942 if (setup_zone_attrs(zlogp, zone_name, zoneid) != Z_OK) 4943 goto error; 4944 4945 if ((bh = brand_open(brand_name)) == NULL) { 4946 zerror(zlogp, B_FALSE, 4947 "unable to determine brand name"); 4948 goto error; 4949 } 4950 4951 if (!is_system_labeled() && 4952 (strcmp(brand_name, LABELED_BRAND_NAME) == 0)) { 4953 brand_close(bh); 4954 zerror(zlogp, B_FALSE, 4955 "cannot boot labeled zone on unlabeled system"); 4956 goto error; 4957 } 4958 4959 /* 4960 * If this brand requires any kernel support, now is the time to 4961 * get it loaded and initialized. 4962 */ 4963 if (brand_get_modname(bh, modname, MAXPATHLEN) < 0) { 4964 brand_close(bh); 4965 zerror(zlogp, B_FALSE, 4966 "unable to determine brand kernel module"); 4967 goto error; 4968 } 4969 brand_close(bh); 4970 4971 if (strlen(modname) > 0) { 4972 (void) strlcpy(attr.ba_brandname, brand_name, 4973 sizeof (attr.ba_brandname)); 4974 (void) strlcpy(attr.ba_modname, modname, 4975 sizeof (attr.ba_modname)); 4976 if (zone_setattr(zoneid, ZONE_ATTR_BRAND, &attr, 4977 sizeof (attr) != 0)) { 4978 zerror(zlogp, B_TRUE, 4979 "could not set zone brand attribute."); 4980 goto error; 4981 } 4982 } 4983 4984 if (setup_zone_rm(zlogp, zone_name, zoneid) != Z_OK) 4985 goto error; 4986 4987 set_mlps(zlogp, zoneid, zcent); 4988 } 4989 4990 rval = zoneid; 4991 zoneid = -1; 4992 4993 error: 4994 if (zoneid != -1) { 4995 (void) zone_shutdown(zoneid); 4996 (void) zone_destroy(zoneid); 4997 } 4998 if (rctlbuf != NULL) 4999 free(rctlbuf); 5000 priv_freeset(privs); 5001 if (fp != NULL) 5002 zonecfg_close_scratch(fp); 5003 lofs_discard_mnttab(); 5004 if (zcent != NULL) 5005 tsol_freezcent(zcent); 5006 return (rval); 5007 } 5008 5009 /* 5010 * Enter the zone and write a /etc/zones/index file there. This allows 5011 * libzonecfg (and thus zoneadm) to report the UUID and potentially other zone 5012 * details from inside the zone. 5013 */ 5014 static void 5015 write_index_file(zoneid_t zoneid) 5016 { 5017 FILE *zef; 5018 FILE *zet; 5019 struct zoneent *zep; 5020 pid_t child; 5021 int tmpl_fd; 5022 ctid_t ct; 5023 int fd; 5024 char uuidstr[UUID_PRINTABLE_STRING_LENGTH]; 5025 5026 /* Locate the zone entry in the global zone's index file */ 5027 if ((zef = setzoneent()) == NULL) 5028 return; 5029 while ((zep = getzoneent_private(zef)) != NULL) { 5030 if (strcmp(zep->zone_name, zone_name) == 0) 5031 break; 5032 free(zep); 5033 } 5034 endzoneent(zef); 5035 if (zep == NULL) 5036 return; 5037 5038 if ((tmpl_fd = init_template()) == -1) { 5039 free(zep); 5040 return; 5041 } 5042 5043 if ((child = fork()) == -1) { 5044 (void) ct_tmpl_clear(tmpl_fd); 5045 (void) close(tmpl_fd); 5046 free(zep); 5047 return; 5048 } 5049 5050 /* parent waits for child to finish */ 5051 if (child != 0) { 5052 free(zep); 5053 if (contract_latest(&ct) == -1) 5054 ct = -1; 5055 (void) ct_tmpl_clear(tmpl_fd); 5056 (void) close(tmpl_fd); 5057 (void) waitpid(child, NULL, 0); 5058 (void) contract_abandon_id(ct); 5059 return; 5060 } 5061 5062 /* child enters zone and sets up index file */ 5063 (void) ct_tmpl_clear(tmpl_fd); 5064 if (zone_enter(zoneid) != -1) { 5065 (void) mkdir(ZONE_CONFIG_ROOT, ZONE_CONFIG_MODE); 5066 (void) chown(ZONE_CONFIG_ROOT, ZONE_CONFIG_UID, 5067 ZONE_CONFIG_GID); 5068 fd = open(ZONE_INDEX_FILE, O_WRONLY|O_CREAT|O_TRUNC, 5069 ZONE_INDEX_MODE); 5070 if (fd != -1 && (zet = fdopen(fd, "w")) != NULL) { 5071 (void) fchown(fd, ZONE_INDEX_UID, ZONE_INDEX_GID); 5072 if (uuid_is_null(zep->zone_uuid)) 5073 uuidstr[0] = '\0'; 5074 else 5075 uuid_unparse(zep->zone_uuid, uuidstr); 5076 (void) fprintf(zet, "%s:%s:/:%s\n", zep->zone_name, 5077 zone_state_str(zep->zone_state), 5078 uuidstr); 5079 (void) fclose(zet); 5080 } 5081 } 5082 _exit(0); 5083 } 5084 5085 int 5086 vplat_bringup(zlog_t *zlogp, zone_mnt_t mount_cmd, zoneid_t zoneid) 5087 { 5088 char zonepath[MAXPATHLEN]; 5089 5090 if (mount_cmd == Z_MNT_BOOT && validate_datasets(zlogp) != 0) { 5091 lofs_discard_mnttab(); 5092 return (-1); 5093 } 5094 5095 /* 5096 * Before we try to mount filesystems we need to create the 5097 * attribute backing store for /dev 5098 */ 5099 if (zone_get_zonepath(zone_name, zonepath, sizeof (zonepath)) != Z_OK) { 5100 lofs_discard_mnttab(); 5101 return (-1); 5102 } 5103 resolve_lofs(zlogp, zonepath, sizeof (zonepath)); 5104 5105 /* Make /dev directory owned by root, grouped sys */ 5106 if (make_one_dir(zlogp, zonepath, "/dev", DEFAULT_DIR_MODE, 5107 0, 3) != 0) { 5108 lofs_discard_mnttab(); 5109 return (-1); 5110 } 5111 5112 if (mount_filesystems(zlogp, mount_cmd) != 0) { 5113 lofs_discard_mnttab(); 5114 return (-1); 5115 } 5116 5117 if (mount_cmd == Z_MNT_BOOT) { 5118 zone_iptype_t iptype; 5119 5120 if (vplat_get_iptype(zlogp, &iptype) < 0) { 5121 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 5122 lofs_discard_mnttab(); 5123 return (-1); 5124 } 5125 5126 switch (iptype) { 5127 case ZS_SHARED: 5128 /* Always do this to make lo0 get configured */ 5129 if (configure_shared_network_interfaces(zlogp) != 0) { 5130 lofs_discard_mnttab(); 5131 return (-1); 5132 } 5133 break; 5134 case ZS_EXCLUSIVE: 5135 if (configure_exclusive_network_interfaces(zlogp, 5136 zoneid) != 5137 0) { 5138 lofs_discard_mnttab(); 5139 return (-1); 5140 } 5141 break; 5142 } 5143 } 5144 5145 write_index_file(zoneid); 5146 5147 lofs_discard_mnttab(); 5148 return (0); 5149 } 5150 5151 static int 5152 lu_root_teardown(zlog_t *zlogp) 5153 { 5154 char zroot[MAXPATHLEN]; 5155 5156 if (zone_get_rootpath(zone_name, zroot, sizeof (zroot)) != Z_OK) { 5157 zerror(zlogp, B_FALSE, "unable to determine zone root"); 5158 return (-1); 5159 } 5160 root_to_lu(zlogp, zroot, sizeof (zroot), B_FALSE); 5161 5162 /* 5163 * At this point, the processes are gone, the filesystems (save the 5164 * root) are unmounted, and the zone is on death row. But there may 5165 * still be creds floating about in the system that reference the 5166 * zone_t, and which pin down zone_rootvp causing this call to fail 5167 * with EBUSY. Thus, we try for a little while before just giving up. 5168 * (How I wish this were not true, and umount2 just did the right 5169 * thing, or tmpfs supported MS_FORCE This is a gross hack.) 5170 */ 5171 if (umount2(zroot, MS_FORCE) != 0) { 5172 if (errno == ENOTSUP && umount2(zroot, 0) == 0) 5173 goto unmounted; 5174 if (errno == EBUSY) { 5175 int tries = 10; 5176 5177 while (--tries >= 0) { 5178 (void) sleep(1); 5179 if (umount2(zroot, 0) == 0) 5180 goto unmounted; 5181 if (errno != EBUSY) 5182 break; 5183 } 5184 } 5185 zerror(zlogp, B_TRUE, "unable to unmount '%s'", zroot); 5186 return (-1); 5187 } 5188 unmounted: 5189 5190 /* 5191 * Only zones in an alternate root environment have scratch zone 5192 * entries. 5193 */ 5194 if (zonecfg_in_alt_root()) { 5195 FILE *fp; 5196 int retv; 5197 5198 if ((fp = zonecfg_open_scratch("", B_FALSE)) == NULL) { 5199 zerror(zlogp, B_TRUE, "cannot open mapfile"); 5200 return (-1); 5201 } 5202 retv = -1; 5203 if (zonecfg_lock_scratch(fp) != 0) 5204 zerror(zlogp, B_TRUE, "cannot lock mapfile"); 5205 else if (zonecfg_delete_scratch(fp, kernzone) != 0) 5206 zerror(zlogp, B_TRUE, "cannot delete map entry"); 5207 else 5208 retv = 0; 5209 zonecfg_close_scratch(fp); 5210 return (retv); 5211 } else { 5212 return (0); 5213 } 5214 } 5215 5216 int 5217 vplat_teardown(zlog_t *zlogp, boolean_t unmount_cmd, boolean_t rebooting) 5218 { 5219 char *kzone; 5220 zoneid_t zoneid; 5221 int res; 5222 char pool_err[128]; 5223 char zpath[MAXPATHLEN]; 5224 char cmdbuf[MAXPATHLEN]; 5225 brand_handle_t bh = NULL; 5226 dladm_status_t status; 5227 char errmsg[DLADM_STRSIZE]; 5228 ushort_t flags; 5229 5230 kzone = zone_name; 5231 if (zonecfg_in_alt_root()) { 5232 FILE *fp; 5233 5234 if ((fp = zonecfg_open_scratch("", B_FALSE)) == NULL) { 5235 zerror(zlogp, B_TRUE, "unable to open map file"); 5236 goto error; 5237 } 5238 if (zonecfg_find_scratch(fp, zone_name, zonecfg_get_root(), 5239 kernzone, sizeof (kernzone)) != 0) { 5240 zerror(zlogp, B_FALSE, "unable to find scratch zone"); 5241 zonecfg_close_scratch(fp); 5242 goto error; 5243 } 5244 zonecfg_close_scratch(fp); 5245 kzone = kernzone; 5246 } 5247 5248 if ((zoneid = getzoneidbyname(kzone)) == ZONE_ID_UNDEFINED) { 5249 if (!bringup_failure_recovery) 5250 zerror(zlogp, B_TRUE, "unable to get zoneid"); 5251 if (unmount_cmd) 5252 (void) lu_root_teardown(zlogp); 5253 goto error; 5254 } 5255 5256 if (remove_datalink_pool(zlogp, zoneid) != 0) { 5257 zerror(zlogp, B_FALSE, "unable clear datalink pool property"); 5258 goto error; 5259 } 5260 5261 if (remove_datalink_protect(zlogp, zoneid) != 0) { 5262 zerror(zlogp, B_FALSE, 5263 "unable clear datalink protect property"); 5264 goto error; 5265 } 5266 5267 /* 5268 * The datalinks assigned to the zone will be removed from the NGZ as 5269 * part of zone_shutdown() so that we need to remove protect/pool etc. 5270 * before zone_shutdown(). Even if the shutdown itself fails, the zone 5271 * will not be able to violate any constraints applied because the 5272 * datalinks are no longer available to the zone. 5273 */ 5274 if (zone_shutdown(zoneid) != 0) { 5275 zerror(zlogp, B_TRUE, "unable to shutdown zone"); 5276 goto error; 5277 } 5278 5279 /* Get the zonepath of this zone */ 5280 if (zone_get_zonepath(zone_name, zpath, sizeof (zpath)) != Z_OK) { 5281 zerror(zlogp, B_FALSE, "unable to determine zone path"); 5282 goto error; 5283 } 5284 5285 /* Get a handle to the brand info for this zone */ 5286 if ((bh = brand_open(brand_name)) == NULL) { 5287 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 5288 return (-1); 5289 } 5290 /* 5291 * If there is a brand 'halt' callback, execute it now to give the 5292 * brand a chance to cleanup any custom configuration. 5293 */ 5294 (void) strcpy(cmdbuf, EXEC_PREFIX); 5295 if (brand_get_halt(bh, zone_name, zpath, cmdbuf + EXEC_LEN, 5296 sizeof (cmdbuf) - EXEC_LEN) < 0) { 5297 brand_close(bh); 5298 zerror(zlogp, B_FALSE, "unable to determine branded zone's " 5299 "halt callback."); 5300 goto error; 5301 } 5302 brand_close(bh); 5303 5304 if ((strlen(cmdbuf) > EXEC_LEN) && 5305 (do_subproc(zlogp, cmdbuf, NULL) != Z_OK)) { 5306 zerror(zlogp, B_FALSE, "%s failed", cmdbuf); 5307 goto error; 5308 } 5309 5310 if (!unmount_cmd) { 5311 zone_iptype_t iptype; 5312 5313 if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &flags, 5314 sizeof (flags)) < 0) { 5315 if (vplat_get_iptype(zlogp, &iptype) < 0) { 5316 zerror(zlogp, B_TRUE, "unable to determine " 5317 "ip-type"); 5318 goto error; 5319 } 5320 } else { 5321 if (flags & ZF_NET_EXCL) 5322 iptype = ZS_EXCLUSIVE; 5323 else 5324 iptype = ZS_SHARED; 5325 } 5326 5327 switch (iptype) { 5328 case ZS_SHARED: 5329 if (unconfigure_shared_network_interfaces(zlogp, 5330 zoneid) != 0) { 5331 zerror(zlogp, B_FALSE, "unable to unconfigure " 5332 "network interfaces in zone"); 5333 goto error; 5334 } 5335 break; 5336 case ZS_EXCLUSIVE: 5337 if (unconfigure_exclusive_network_interfaces(zlogp, 5338 zoneid) != 0) { 5339 zerror(zlogp, B_FALSE, "unable to unconfigure " 5340 "network interfaces in zone"); 5341 goto error; 5342 } 5343 status = dladm_zone_halt(dld_handle, zoneid); 5344 if (status != DLADM_STATUS_OK) { 5345 zerror(zlogp, B_FALSE, "unable to notify " 5346 "dlmgmtd of zone halt: %s", 5347 dladm_status2str(status, errmsg)); 5348 } 5349 break; 5350 } 5351 } 5352 5353 if (!unmount_cmd && tcp_abort_connections(zlogp, zoneid) != 0) { 5354 zerror(zlogp, B_TRUE, "unable to abort TCP connections"); 5355 goto error; 5356 } 5357 5358 if (unmount_filesystems(zlogp, zoneid, unmount_cmd) != 0) { 5359 zerror(zlogp, B_FALSE, 5360 "unable to unmount file systems in zone"); 5361 goto error; 5362 } 5363 5364 /* 5365 * If we are rebooting then we normally don't want to destroy an 5366 * existing temporary pool at this point so that we can just reuse it 5367 * when the zone boots back up. However, it is also possible we were 5368 * running with a temporary pool and the zone configuration has been 5369 * modified to no longer use a temporary pool. In that case we need 5370 * to destroy the temporary pool now. This case looks like the case 5371 * where we never had a temporary pool configured but 5372 * zonecfg_destroy_tmp_pool will do the right thing either way. 5373 */ 5374 if (!unmount_cmd) { 5375 boolean_t destroy_tmp_pool = B_TRUE; 5376 5377 if (rebooting) { 5378 struct zone_psettab pset_tab; 5379 zone_dochandle_t handle; 5380 5381 if ((handle = zonecfg_init_handle()) != NULL && 5382 zonecfg_get_handle(zone_name, handle) == Z_OK && 5383 zonecfg_lookup_pset(handle, &pset_tab) == Z_OK) 5384 destroy_tmp_pool = B_FALSE; 5385 5386 zonecfg_fini_handle(handle); 5387 } 5388 5389 if (destroy_tmp_pool) { 5390 if ((res = zonecfg_destroy_tmp_pool(zone_name, pool_err, 5391 sizeof (pool_err))) != Z_OK) { 5392 if (res == Z_POOL) 5393 zerror(zlogp, B_FALSE, pool_err); 5394 } 5395 } 5396 } 5397 5398 remove_mlps(zlogp, zoneid); 5399 5400 if (zone_destroy(zoneid) != 0) { 5401 zerror(zlogp, B_TRUE, "unable to destroy zone"); 5402 goto error; 5403 } 5404 5405 /* 5406 * Special teardown for alternate boot environments: remove the tmpfs 5407 * root for the zone and then remove it from the map file. 5408 */ 5409 if (unmount_cmd && lu_root_teardown(zlogp) != 0) 5410 goto error; 5411 5412 lofs_discard_mnttab(); 5413 return (0); 5414 5415 error: 5416 lofs_discard_mnttab(); 5417 return (-1); 5418 } --- EOF ---