17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21ffbafc53Scomay 227c478bd9Sstevel@tonic-gate /* 23e11c3f44Smeem * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* 287c478bd9Sstevel@tonic-gate * This module contains functions used to bring up and tear down the 297c478bd9Sstevel@tonic-gate * Virtual Platform: [un]mounting file-systems, [un]plumbing network 307c478bd9Sstevel@tonic-gate * interfaces, [un]configuring devices, establishing resource controls, 317c478bd9Sstevel@tonic-gate * and creating/destroying the zone in the kernel. These actions, on 327c478bd9Sstevel@tonic-gate * the way up, ready the zone; on the way down, they halt the zone. 337c478bd9Sstevel@tonic-gate * See the much longer block comment at the beginning of zoneadmd.c 347c478bd9Sstevel@tonic-gate * for a bigger picture of how the whole program functions. 35108322fbScarlsonj * 36108322fbScarlsonj * This module also has primary responsibility for the layout of "scratch 37108322fbScarlsonj * zones." These are mounted, but inactive, zones that are used during 38108322fbScarlsonj * operating system upgrade and potentially other administrative action. The 39108322fbScarlsonj * scratch zone environment is similar to the miniroot environment. The zone's 40108322fbScarlsonj * actual root is mounted read-write on /a, and the standard paths (/usr, 41108322fbScarlsonj * /sbin, /lib) all lead to read-only copies of the running system's binaries. 42108322fbScarlsonj * This allows the administrative tools to manipulate the zone using "-R /a" 43108322fbScarlsonj * without relying on any binaries in the zone itself. 44108322fbScarlsonj * 45108322fbScarlsonj * If the scratch zone is on an alternate root (Live Upgrade [LU] boot 46108322fbScarlsonj * environment), then we must resolve the lofs mounts used there to uncover 47108322fbScarlsonj * writable (unshared) resources. Shared resources, though, are always 48108322fbScarlsonj * read-only. In addition, if the "same" zone with a different root path is 49108322fbScarlsonj * currently running, then "/b" inside the zone points to the running zone's 50108322fbScarlsonj * root. This allows LU to synchronize configuration files during the upgrade 51108322fbScarlsonj * process. 52108322fbScarlsonj * 53108322fbScarlsonj * To construct this environment, this module creates a tmpfs mount on 54108322fbScarlsonj * $ZONEPATH/lu. Inside this scratch area, the miniroot-like environment as 55108322fbScarlsonj * described above is constructed on the fly. The zone is then created using 56108322fbScarlsonj * $ZONEPATH/lu as the root. 57108322fbScarlsonj * 58108322fbScarlsonj * Note that scratch zones are inactive. The zone's bits are not running and 59108322fbScarlsonj * likely cannot be run correctly until upgrade is done. Init is not running 60108322fbScarlsonj * there, nor is SMF. Because of this, the "mounted" state of a scratch zone 61108322fbScarlsonj * is not a part of the usual halt/ready/boot state machine. 627c478bd9Sstevel@tonic-gate */ 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate #include <sys/param.h> 657c478bd9Sstevel@tonic-gate #include <sys/mount.h> 667c478bd9Sstevel@tonic-gate #include <sys/mntent.h> 677c478bd9Sstevel@tonic-gate #include <sys/socket.h> 687c478bd9Sstevel@tonic-gate #include <sys/utsname.h> 697c478bd9Sstevel@tonic-gate #include <sys/types.h> 707c478bd9Sstevel@tonic-gate #include <sys/stat.h> 717c478bd9Sstevel@tonic-gate #include <sys/sockio.h> 727c478bd9Sstevel@tonic-gate #include <sys/stropts.h> 737c478bd9Sstevel@tonic-gate #include <sys/conf.h> 745679c89fSjv227347 #include <sys/systeminfo.h> 757c478bd9Sstevel@tonic-gate 76f4b3ec61Sdh155122 #include <libdlpi.h> 77f595a68aSyz147064 #include <libdllink.h> 78d62bc4baSyz147064 #include <libdlvlan.h> 79f4b3ec61Sdh155122 807c478bd9Sstevel@tonic-gate #include <inet/tcp.h> 817c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 827c478bd9Sstevel@tonic-gate #include <netinet/in.h> 837c478bd9Sstevel@tonic-gate #include <net/route.h> 847c478bd9Sstevel@tonic-gate 857c478bd9Sstevel@tonic-gate #include <stdio.h> 867c478bd9Sstevel@tonic-gate #include <errno.h> 877c478bd9Sstevel@tonic-gate #include <fcntl.h> 887c478bd9Sstevel@tonic-gate #include <unistd.h> 897c478bd9Sstevel@tonic-gate #include <rctl.h> 907c478bd9Sstevel@tonic-gate #include <stdlib.h> 917c478bd9Sstevel@tonic-gate #include <string.h> 927c478bd9Sstevel@tonic-gate #include <strings.h> 937c478bd9Sstevel@tonic-gate #include <wait.h> 947c478bd9Sstevel@tonic-gate #include <limits.h> 957c478bd9Sstevel@tonic-gate #include <libgen.h> 96fa9e4066Sahrens #include <libzfs.h> 97facf4a8dSllai1 #include <libdevinfo.h> 987c478bd9Sstevel@tonic-gate #include <zone.h> 997c478bd9Sstevel@tonic-gate #include <assert.h> 100555afedfScarlsonj #include <libcontract.h> 101555afedfScarlsonj #include <libcontract_priv.h> 102555afedfScarlsonj #include <uuid/uuid.h> 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate #include <sys/mntio.h> 1057c478bd9Sstevel@tonic-gate #include <sys/mnttab.h> 1067c478bd9Sstevel@tonic-gate #include <sys/fs/autofs.h> /* for _autofssys() */ 1077c478bd9Sstevel@tonic-gate #include <sys/fs/lofs_info.h> 108fa9e4066Sahrens #include <sys/fs/zfs.h> 1097c478bd9Sstevel@tonic-gate 1107c478bd9Sstevel@tonic-gate #include <pool.h> 1117c478bd9Sstevel@tonic-gate #include <sys/pool.h> 1120209230bSgjelinek #include <sys/priocntl.h> 1137c478bd9Sstevel@tonic-gate 1149acbbeafSnn35248 #include <libbrand.h> 1159acbbeafSnn35248 #include <sys/brand.h> 1167c478bd9Sstevel@tonic-gate #include <libzonecfg.h> 11739d3e169Sevanl #include <synch.h> 11822321485Svp157776 1197c478bd9Sstevel@tonic-gate #include "zoneadmd.h" 12045916cd2Sjpk #include <tsol/label.h> 12145916cd2Sjpk #include <libtsnet.h> 12245916cd2Sjpk #include <sys/priv.h> 1237c478bd9Sstevel@tonic-gate 1247c478bd9Sstevel@tonic-gate #define V4_ADDR_LEN 32 1257c478bd9Sstevel@tonic-gate #define V6_ADDR_LEN 128 1267c478bd9Sstevel@tonic-gate 1277c478bd9Sstevel@tonic-gate #define IPD_DEFAULT_OPTS \ 1287c478bd9Sstevel@tonic-gate MNTOPT_RO "," MNTOPT_LOFS_NOSUB "," MNTOPT_NODEVICES 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate #define DFSTYPES "/etc/dfs/fstypes" 13145916cd2Sjpk #define MAXTNZLEN 2048 1327c478bd9Sstevel@tonic-gate 1336cfd72c6Sgjelinek #define ALT_MOUNT(mount_cmd) ((mount_cmd) != Z_MNT_BOOT) 1346cfd72c6Sgjelinek 1357c478bd9Sstevel@tonic-gate /* for routing socket */ 1367c478bd9Sstevel@tonic-gate static int rts_seqno = 0; 1377c478bd9Sstevel@tonic-gate 138108322fbScarlsonj /* mangled zone name when mounting in an alternate root environment */ 139108322fbScarlsonj static char kernzone[ZONENAME_MAX]; 140108322fbScarlsonj 141108322fbScarlsonj /* array of cached mount entries for resolve_lofs */ 142108322fbScarlsonj static struct mnttab *resolve_lofs_mnts, *resolve_lofs_mnt_max; 143108322fbScarlsonj 14445916cd2Sjpk /* for Trusted Extensions */ 14545916cd2Sjpk static tsol_zcent_t *get_zone_label(zlog_t *, priv_set_t *); 14645916cd2Sjpk static int tsol_mounts(zlog_t *, char *, char *); 14745916cd2Sjpk static void tsol_unmounts(zlog_t *, char *); 1489d48116cSdh155122 14945916cd2Sjpk static m_label_t *zlabel = NULL; 15045916cd2Sjpk static m_label_t *zid_label = NULL; 15145916cd2Sjpk static priv_set_t *zprivs = NULL; 15245916cd2Sjpk 1537c478bd9Sstevel@tonic-gate /* from libsocket, not in any header file */ 1547c478bd9Sstevel@tonic-gate extern int getnetmaskbyaddr(struct in_addr, struct in_addr *); 1557c478bd9Sstevel@tonic-gate 156c5cd6260S /* from zoneadmd */ 157c5cd6260S extern char query_hook[]; 158c5cd6260S 1597c478bd9Sstevel@tonic-gate /* 160108322fbScarlsonj * An optimization for build_mnttable: reallocate (and potentially copy the 161108322fbScarlsonj * data) only once every N times through the loop. 162108322fbScarlsonj */ 163108322fbScarlsonj #define MNTTAB_HUNK 32 164108322fbScarlsonj 165108322fbScarlsonj /* 1667c478bd9Sstevel@tonic-gate * Private autofs system call 1677c478bd9Sstevel@tonic-gate */ 1687c478bd9Sstevel@tonic-gate extern int _autofssys(int, void *); 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate static int 1717c478bd9Sstevel@tonic-gate autofs_cleanup(zoneid_t zoneid) 1727c478bd9Sstevel@tonic-gate { 1737c478bd9Sstevel@tonic-gate /* 1747c478bd9Sstevel@tonic-gate * Ask autofs to unmount all trigger nodes in the given zone. 1757c478bd9Sstevel@tonic-gate */ 1767c478bd9Sstevel@tonic-gate return (_autofssys(AUTOFS_UNMOUNTALL, (void *)zoneid)); 1777c478bd9Sstevel@tonic-gate } 1787c478bd9Sstevel@tonic-gate 179108322fbScarlsonj static void 180108322fbScarlsonj free_mnttable(struct mnttab *mnt_array, uint_t nelem) 181108322fbScarlsonj { 182108322fbScarlsonj uint_t i; 183108322fbScarlsonj 184108322fbScarlsonj if (mnt_array == NULL) 185108322fbScarlsonj return; 186108322fbScarlsonj for (i = 0; i < nelem; i++) { 187108322fbScarlsonj free(mnt_array[i].mnt_mountp); 188108322fbScarlsonj free(mnt_array[i].mnt_fstype); 189108322fbScarlsonj free(mnt_array[i].mnt_special); 190108322fbScarlsonj free(mnt_array[i].mnt_mntopts); 191108322fbScarlsonj assert(mnt_array[i].mnt_time == NULL); 192108322fbScarlsonj } 193108322fbScarlsonj free(mnt_array); 194108322fbScarlsonj } 195108322fbScarlsonj 196108322fbScarlsonj /* 197108322fbScarlsonj * Build the mount table for the zone rooted at "zroot", storing the resulting 198108322fbScarlsonj * array of struct mnttabs in "mnt_arrayp" and the number of elements in the 199108322fbScarlsonj * array in "nelemp". 200108322fbScarlsonj */ 201108322fbScarlsonj static int 202108322fbScarlsonj build_mnttable(zlog_t *zlogp, const char *zroot, size_t zrootlen, FILE *mnttab, 203108322fbScarlsonj struct mnttab **mnt_arrayp, uint_t *nelemp) 204108322fbScarlsonj { 205108322fbScarlsonj struct mnttab mnt; 206108322fbScarlsonj struct mnttab *mnts; 207108322fbScarlsonj struct mnttab *mnp; 208108322fbScarlsonj uint_t nmnt; 209108322fbScarlsonj 210108322fbScarlsonj rewind(mnttab); 211108322fbScarlsonj resetmnttab(mnttab); 212108322fbScarlsonj nmnt = 0; 213108322fbScarlsonj mnts = NULL; 214108322fbScarlsonj while (getmntent(mnttab, &mnt) == 0) { 215108322fbScarlsonj struct mnttab *tmp_array; 216108322fbScarlsonj 217108322fbScarlsonj if (strncmp(mnt.mnt_mountp, zroot, zrootlen) != 0) 218108322fbScarlsonj continue; 219108322fbScarlsonj if (nmnt % MNTTAB_HUNK == 0) { 220108322fbScarlsonj tmp_array = realloc(mnts, 221108322fbScarlsonj (nmnt + MNTTAB_HUNK) * sizeof (*mnts)); 222108322fbScarlsonj if (tmp_array == NULL) { 223108322fbScarlsonj free_mnttable(mnts, nmnt); 224108322fbScarlsonj return (-1); 225108322fbScarlsonj } 226108322fbScarlsonj mnts = tmp_array; 227108322fbScarlsonj } 228108322fbScarlsonj mnp = &mnts[nmnt++]; 229108322fbScarlsonj 230108322fbScarlsonj /* 231108322fbScarlsonj * Zero out any fields we're not using. 232108322fbScarlsonj */ 233108322fbScarlsonj (void) memset(mnp, 0, sizeof (*mnp)); 234108322fbScarlsonj 235108322fbScarlsonj if (mnt.mnt_special != NULL) 236108322fbScarlsonj mnp->mnt_special = strdup(mnt.mnt_special); 237108322fbScarlsonj if (mnt.mnt_mntopts != NULL) 238108322fbScarlsonj mnp->mnt_mntopts = strdup(mnt.mnt_mntopts); 239108322fbScarlsonj mnp->mnt_mountp = strdup(mnt.mnt_mountp); 240108322fbScarlsonj mnp->mnt_fstype = strdup(mnt.mnt_fstype); 241108322fbScarlsonj if ((mnt.mnt_special != NULL && mnp->mnt_special == NULL) || 242108322fbScarlsonj (mnt.mnt_mntopts != NULL && mnp->mnt_mntopts == NULL) || 243108322fbScarlsonj mnp->mnt_mountp == NULL || mnp->mnt_fstype == NULL) { 244108322fbScarlsonj zerror(zlogp, B_TRUE, "memory allocation failed"); 245108322fbScarlsonj free_mnttable(mnts, nmnt); 246108322fbScarlsonj return (-1); 247108322fbScarlsonj } 248108322fbScarlsonj } 249108322fbScarlsonj *mnt_arrayp = mnts; 250108322fbScarlsonj *nelemp = nmnt; 251108322fbScarlsonj return (0); 252108322fbScarlsonj } 253108322fbScarlsonj 254108322fbScarlsonj /* 255108322fbScarlsonj * This is an optimization. The resolve_lofs function is used quite frequently 256108322fbScarlsonj * to manipulate file paths, and on a machine with a large number of zones, 257108322fbScarlsonj * there will be a huge number of mounted file systems. Thus, we trigger a 258108322fbScarlsonj * reread of the list of mount points 259108322fbScarlsonj */ 260108322fbScarlsonj static void 261108322fbScarlsonj lofs_discard_mnttab(void) 262108322fbScarlsonj { 263108322fbScarlsonj free_mnttable(resolve_lofs_mnts, 264108322fbScarlsonj resolve_lofs_mnt_max - resolve_lofs_mnts); 265108322fbScarlsonj resolve_lofs_mnts = resolve_lofs_mnt_max = NULL; 266108322fbScarlsonj } 267108322fbScarlsonj 268108322fbScarlsonj static int 269108322fbScarlsonj lofs_read_mnttab(zlog_t *zlogp) 270108322fbScarlsonj { 271108322fbScarlsonj FILE *mnttab; 272108322fbScarlsonj uint_t nmnts; 273108322fbScarlsonj 274108322fbScarlsonj if ((mnttab = fopen(MNTTAB, "r")) == NULL) 275108322fbScarlsonj return (-1); 276108322fbScarlsonj if (build_mnttable(zlogp, "", 0, mnttab, &resolve_lofs_mnts, 277108322fbScarlsonj &nmnts) == -1) { 278108322fbScarlsonj (void) fclose(mnttab); 279108322fbScarlsonj return (-1); 280108322fbScarlsonj } 281108322fbScarlsonj (void) fclose(mnttab); 282108322fbScarlsonj resolve_lofs_mnt_max = resolve_lofs_mnts + nmnts; 283108322fbScarlsonj return (0); 284108322fbScarlsonj } 285108322fbScarlsonj 286108322fbScarlsonj /* 287108322fbScarlsonj * This function loops over potential loopback mounts and symlinks in a given 288108322fbScarlsonj * path and resolves them all down to an absolute path. 289108322fbScarlsonj */ 290910f48daSedp void 291108322fbScarlsonj resolve_lofs(zlog_t *zlogp, char *path, size_t pathlen) 292108322fbScarlsonj { 293108322fbScarlsonj int len, arlen; 294108322fbScarlsonj const char *altroot; 295108322fbScarlsonj char tmppath[MAXPATHLEN]; 296108322fbScarlsonj boolean_t outside_altroot; 297108322fbScarlsonj 298108322fbScarlsonj if ((len = resolvepath(path, tmppath, sizeof (tmppath))) == -1) 299108322fbScarlsonj return; 300108322fbScarlsonj tmppath[len] = '\0'; 301108322fbScarlsonj (void) strlcpy(path, tmppath, sizeof (tmppath)); 302108322fbScarlsonj 303108322fbScarlsonj /* This happens once per zoneadmd operation. */ 304108322fbScarlsonj if (resolve_lofs_mnts == NULL && lofs_read_mnttab(zlogp) == -1) 305108322fbScarlsonj return; 306108322fbScarlsonj 307108322fbScarlsonj altroot = zonecfg_get_root(); 308108322fbScarlsonj arlen = strlen(altroot); 309108322fbScarlsonj outside_altroot = B_FALSE; 310108322fbScarlsonj for (;;) { 311108322fbScarlsonj struct mnttab *mnp; 312108322fbScarlsonj 3131e9d8f9fSdminer /* Search in reverse order to find longest match */ 3141e9d8f9fSdminer for (mnp = resolve_lofs_mnt_max - 1; mnp >= resolve_lofs_mnts; 3151e9d8f9fSdminer mnp--) { 316108322fbScarlsonj if (mnp->mnt_fstype == NULL || 317108322fbScarlsonj mnp->mnt_mountp == NULL || 3181e9d8f9fSdminer mnp->mnt_special == NULL) 319108322fbScarlsonj continue; 320108322fbScarlsonj len = strlen(mnp->mnt_mountp); 321108322fbScarlsonj if (strncmp(mnp->mnt_mountp, path, len) == 0 && 322108322fbScarlsonj (path[len] == '/' || path[len] == '\0')) 323108322fbScarlsonj break; 324108322fbScarlsonj } 3251e9d8f9fSdminer if (mnp < resolve_lofs_mnts) 3261e9d8f9fSdminer break; 3271e9d8f9fSdminer /* If it's not a lofs then we're done */ 3281e9d8f9fSdminer if (strcmp(mnp->mnt_fstype, MNTTYPE_LOFS) != 0) 329108322fbScarlsonj break; 330108322fbScarlsonj if (outside_altroot) { 331108322fbScarlsonj char *cp; 332108322fbScarlsonj int olen = sizeof (MNTOPT_RO) - 1; 333108322fbScarlsonj 334108322fbScarlsonj /* 335108322fbScarlsonj * If we run into a read-only mount outside of the 336108322fbScarlsonj * alternate root environment, then the user doesn't 337108322fbScarlsonj * want this path to be made read-write. 338108322fbScarlsonj */ 339108322fbScarlsonj if (mnp->mnt_mntopts != NULL && 340108322fbScarlsonj (cp = strstr(mnp->mnt_mntopts, MNTOPT_RO)) != 341108322fbScarlsonj NULL && 342108322fbScarlsonj (cp == mnp->mnt_mntopts || cp[-1] == ',') && 343108322fbScarlsonj (cp[olen] == '\0' || cp[olen] == ',')) { 344108322fbScarlsonj break; 345108322fbScarlsonj } 346108322fbScarlsonj } else if (arlen > 0 && 347108322fbScarlsonj (strncmp(mnp->mnt_special, altroot, arlen) != 0 || 348108322fbScarlsonj (mnp->mnt_special[arlen] != '\0' && 349108322fbScarlsonj mnp->mnt_special[arlen] != '/'))) { 350108322fbScarlsonj outside_altroot = B_TRUE; 351108322fbScarlsonj } 352108322fbScarlsonj /* use temporary buffer because new path might be longer */ 353108322fbScarlsonj (void) snprintf(tmppath, sizeof (tmppath), "%s%s", 354108322fbScarlsonj mnp->mnt_special, path + len); 355108322fbScarlsonj if ((len = resolvepath(tmppath, path, pathlen)) == -1) 356108322fbScarlsonj break; 357108322fbScarlsonj path[len] = '\0'; 358108322fbScarlsonj } 359108322fbScarlsonj } 360108322fbScarlsonj 361108322fbScarlsonj /* 362108322fbScarlsonj * For a regular mount, check if a replacement lofs mount is needed because the 363108322fbScarlsonj * referenced device is already mounted somewhere. 364108322fbScarlsonj */ 365108322fbScarlsonj static int 366108322fbScarlsonj check_lofs_needed(zlog_t *zlogp, struct zone_fstab *fsptr) 367108322fbScarlsonj { 368108322fbScarlsonj struct mnttab *mnp; 369108322fbScarlsonj zone_fsopt_t *optptr, *onext; 370108322fbScarlsonj 371108322fbScarlsonj /* This happens once per zoneadmd operation. */ 372108322fbScarlsonj if (resolve_lofs_mnts == NULL && lofs_read_mnttab(zlogp) == -1) 373108322fbScarlsonj return (-1); 374108322fbScarlsonj 375108322fbScarlsonj /* 376108322fbScarlsonj * If this special node isn't already in use, then it's ours alone; 377108322fbScarlsonj * no need to worry about conflicting mounts. 378108322fbScarlsonj */ 379108322fbScarlsonj for (mnp = resolve_lofs_mnts; mnp < resolve_lofs_mnt_max; 380108322fbScarlsonj mnp++) { 381108322fbScarlsonj if (strcmp(mnp->mnt_special, fsptr->zone_fs_special) == 0) 382108322fbScarlsonj break; 383108322fbScarlsonj } 384108322fbScarlsonj if (mnp >= resolve_lofs_mnt_max) 385108322fbScarlsonj return (0); 386108322fbScarlsonj 387108322fbScarlsonj /* 388108322fbScarlsonj * Convert this duplicate mount into a lofs mount. 389108322fbScarlsonj */ 390108322fbScarlsonj (void) strlcpy(fsptr->zone_fs_special, mnp->mnt_mountp, 391108322fbScarlsonj sizeof (fsptr->zone_fs_special)); 392108322fbScarlsonj (void) strlcpy(fsptr->zone_fs_type, MNTTYPE_LOFS, 393108322fbScarlsonj sizeof (fsptr->zone_fs_type)); 394108322fbScarlsonj fsptr->zone_fs_raw[0] = '\0'; 395108322fbScarlsonj 396108322fbScarlsonj /* 397108322fbScarlsonj * Discard all but one of the original options and set that to be the 398108322fbScarlsonj * same set of options used for inherit package directory resources. 399108322fbScarlsonj */ 400108322fbScarlsonj optptr = fsptr->zone_fs_options; 401108322fbScarlsonj if (optptr == NULL) { 402108322fbScarlsonj optptr = malloc(sizeof (*optptr)); 403108322fbScarlsonj if (optptr == NULL) { 404108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot mount %s", 405108322fbScarlsonj fsptr->zone_fs_dir); 406108322fbScarlsonj return (-1); 407108322fbScarlsonj } 408108322fbScarlsonj } else { 409108322fbScarlsonj while ((onext = optptr->zone_fsopt_next) != NULL) { 410108322fbScarlsonj optptr->zone_fsopt_next = onext->zone_fsopt_next; 411108322fbScarlsonj free(onext); 412108322fbScarlsonj } 413108322fbScarlsonj } 414108322fbScarlsonj (void) strcpy(optptr->zone_fsopt_opt, IPD_DEFAULT_OPTS); 415108322fbScarlsonj optptr->zone_fsopt_next = NULL; 416108322fbScarlsonj fsptr->zone_fs_options = optptr; 417108322fbScarlsonj return (0); 418108322fbScarlsonj } 419108322fbScarlsonj 420d314f035Sedp int 42127e6fb21Sdp make_one_dir(zlog_t *zlogp, const char *prefix, const char *subdir, mode_t mode, 42227e6fb21Sdp uid_t userid, gid_t groupid) 4237c478bd9Sstevel@tonic-gate { 4247c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 4257c478bd9Sstevel@tonic-gate struct stat st; 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate if (snprintf(path, sizeof (path), "%s%s", prefix, subdir) > 4287c478bd9Sstevel@tonic-gate sizeof (path)) { 4297c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "pathname %s%s is too long", prefix, 4307c478bd9Sstevel@tonic-gate subdir); 4317c478bd9Sstevel@tonic-gate return (-1); 4327c478bd9Sstevel@tonic-gate } 4337c478bd9Sstevel@tonic-gate 4347c478bd9Sstevel@tonic-gate if (lstat(path, &st) == 0) { 4357c478bd9Sstevel@tonic-gate /* 4367c478bd9Sstevel@tonic-gate * We don't check the file mode since presumably the zone 4377c478bd9Sstevel@tonic-gate * administrator may have had good reason to change the mode, 4387c478bd9Sstevel@tonic-gate * and we don't need to second guess him. 4397c478bd9Sstevel@tonic-gate */ 4407c478bd9Sstevel@tonic-gate if (!S_ISDIR(st.st_mode)) { 441756cf395SRic Aleshire if (S_ISREG(st.st_mode)) { 44245916cd2Sjpk /* 443756cf395SRic Aleshire * Allow readonly mounts of /etc/ files; this 444756cf395SRic Aleshire * is needed most by Trusted Extensions. 44545916cd2Sjpk */ 44645916cd2Sjpk if (strncmp(subdir, "/etc/", 44745916cd2Sjpk strlen("/etc/")) != 0) { 44845916cd2Sjpk zerror(zlogp, B_FALSE, 44945916cd2Sjpk "%s is not in /etc", path); 4507c478bd9Sstevel@tonic-gate return (-1); 4517c478bd9Sstevel@tonic-gate } 45245916cd2Sjpk } else { 45345916cd2Sjpk zerror(zlogp, B_FALSE, 45445916cd2Sjpk "%s is not a directory", path); 45545916cd2Sjpk return (-1); 45645916cd2Sjpk } 45745916cd2Sjpk } 45827e6fb21Sdp return (0); 45927e6fb21Sdp } 46027e6fb21Sdp 46127e6fb21Sdp if (mkdirp(path, mode) != 0) { 4627c478bd9Sstevel@tonic-gate if (errno == EROFS) 4637c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "Could not mkdir %s.\nIt is on " 4647c478bd9Sstevel@tonic-gate "a read-only file system in this local zone.\nMake " 4657c478bd9Sstevel@tonic-gate "sure %s exists in the global zone.", path, subdir); 4667c478bd9Sstevel@tonic-gate else 4677c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "mkdirp of %s failed", path); 4687c478bd9Sstevel@tonic-gate return (-1); 4697c478bd9Sstevel@tonic-gate } 47027e6fb21Sdp 47127e6fb21Sdp (void) chown(path, userid, groupid); 4727c478bd9Sstevel@tonic-gate return (0); 4737c478bd9Sstevel@tonic-gate } 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate static void 4767c478bd9Sstevel@tonic-gate free_remote_fstypes(char **types) 4777c478bd9Sstevel@tonic-gate { 4787c478bd9Sstevel@tonic-gate uint_t i; 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate if (types == NULL) 4817c478bd9Sstevel@tonic-gate return; 4827c478bd9Sstevel@tonic-gate for (i = 0; types[i] != NULL; i++) 4837c478bd9Sstevel@tonic-gate free(types[i]); 4847c478bd9Sstevel@tonic-gate free(types); 4857c478bd9Sstevel@tonic-gate } 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate static char ** 4887c478bd9Sstevel@tonic-gate get_remote_fstypes(zlog_t *zlogp) 4897c478bd9Sstevel@tonic-gate { 4907c478bd9Sstevel@tonic-gate char **types = NULL; 4917c478bd9Sstevel@tonic-gate FILE *fp; 4927c478bd9Sstevel@tonic-gate char buf[MAXPATHLEN]; 4937c478bd9Sstevel@tonic-gate char fstype[MAXPATHLEN]; 4947c478bd9Sstevel@tonic-gate uint_t lines = 0; 4957c478bd9Sstevel@tonic-gate uint_t i; 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate if ((fp = fopen(DFSTYPES, "r")) == NULL) { 4987c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to open %s", DFSTYPES); 4997c478bd9Sstevel@tonic-gate return (NULL); 5007c478bd9Sstevel@tonic-gate } 5017c478bd9Sstevel@tonic-gate /* 5027c478bd9Sstevel@tonic-gate * Count the number of lines 5037c478bd9Sstevel@tonic-gate */ 5047c478bd9Sstevel@tonic-gate while (fgets(buf, sizeof (buf), fp) != NULL) 5057c478bd9Sstevel@tonic-gate lines++; 5067c478bd9Sstevel@tonic-gate if (lines == 0) /* didn't read anything; empty file */ 5077c478bd9Sstevel@tonic-gate goto out; 5087c478bd9Sstevel@tonic-gate rewind(fp); 5097c478bd9Sstevel@tonic-gate /* 5107c478bd9Sstevel@tonic-gate * Allocate enough space for a NULL-terminated array. 5117c478bd9Sstevel@tonic-gate */ 5127c478bd9Sstevel@tonic-gate types = calloc(lines + 1, sizeof (char *)); 5137c478bd9Sstevel@tonic-gate if (types == NULL) { 5147c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "memory allocation failed"); 5157c478bd9Sstevel@tonic-gate goto out; 5167c478bd9Sstevel@tonic-gate } 5177c478bd9Sstevel@tonic-gate i = 0; 5187c478bd9Sstevel@tonic-gate while (fgets(buf, sizeof (buf), fp) != NULL) { 5197c478bd9Sstevel@tonic-gate /* LINTED - fstype is big enough to hold buf */ 5207c478bd9Sstevel@tonic-gate if (sscanf(buf, "%s", fstype) == 0) { 5217c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "unable to parse %s", DFSTYPES); 5227c478bd9Sstevel@tonic-gate free_remote_fstypes(types); 5237c478bd9Sstevel@tonic-gate types = NULL; 5247c478bd9Sstevel@tonic-gate goto out; 5257c478bd9Sstevel@tonic-gate } 5267c478bd9Sstevel@tonic-gate types[i] = strdup(fstype); 5277c478bd9Sstevel@tonic-gate if (types[i] == NULL) { 5287c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "memory allocation failed"); 5297c478bd9Sstevel@tonic-gate free_remote_fstypes(types); 5307c478bd9Sstevel@tonic-gate types = NULL; 5317c478bd9Sstevel@tonic-gate goto out; 5327c478bd9Sstevel@tonic-gate } 5337c478bd9Sstevel@tonic-gate i++; 5347c478bd9Sstevel@tonic-gate } 5357c478bd9Sstevel@tonic-gate out: 5367c478bd9Sstevel@tonic-gate (void) fclose(fp); 5377c478bd9Sstevel@tonic-gate return (types); 5387c478bd9Sstevel@tonic-gate } 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate static boolean_t 5417c478bd9Sstevel@tonic-gate is_remote_fstype(const char *fstype, char *const *remote_fstypes) 5427c478bd9Sstevel@tonic-gate { 5437c478bd9Sstevel@tonic-gate uint_t i; 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate if (remote_fstypes == NULL) 5467c478bd9Sstevel@tonic-gate return (B_FALSE); 5477c478bd9Sstevel@tonic-gate for (i = 0; remote_fstypes[i] != NULL; i++) { 5487c478bd9Sstevel@tonic-gate if (strcmp(remote_fstypes[i], fstype) == 0) 5497c478bd9Sstevel@tonic-gate return (B_TRUE); 5507c478bd9Sstevel@tonic-gate } 5517c478bd9Sstevel@tonic-gate return (B_FALSE); 5527c478bd9Sstevel@tonic-gate } 5537c478bd9Sstevel@tonic-gate 554108322fbScarlsonj /* 555108322fbScarlsonj * This converts a zone root path (normally of the form .../root) to a Live 556108322fbScarlsonj * Upgrade scratch zone root (of the form .../lu). 557108322fbScarlsonj */ 5587c478bd9Sstevel@tonic-gate static void 559108322fbScarlsonj root_to_lu(zlog_t *zlogp, char *zroot, size_t zrootlen, boolean_t isresolved) 5607c478bd9Sstevel@tonic-gate { 561108322fbScarlsonj if (!isresolved && zonecfg_in_alt_root()) 562108322fbScarlsonj resolve_lofs(zlogp, zroot, zrootlen); 563108322fbScarlsonj (void) strcpy(strrchr(zroot, '/') + 1, "lu"); 5647c478bd9Sstevel@tonic-gate } 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate /* 5677c478bd9Sstevel@tonic-gate * The general strategy for unmounting filesystems is as follows: 5687c478bd9Sstevel@tonic-gate * 5697c478bd9Sstevel@tonic-gate * - Remote filesystems may be dead, and attempting to contact them as 5707c478bd9Sstevel@tonic-gate * part of a regular unmount may hang forever; we want to always try to 5717c478bd9Sstevel@tonic-gate * forcibly unmount such filesystems and only fall back to regular 5727c478bd9Sstevel@tonic-gate * unmounts if the filesystem doesn't support forced unmounts. 5737c478bd9Sstevel@tonic-gate * 5747c478bd9Sstevel@tonic-gate * - We don't want to unnecessarily corrupt metadata on local 5757c478bd9Sstevel@tonic-gate * filesystems (ie UFS), so we want to start off with graceful unmounts, 5767c478bd9Sstevel@tonic-gate * and only escalate to doing forced unmounts if we get stuck. 5777c478bd9Sstevel@tonic-gate * 5787c478bd9Sstevel@tonic-gate * We start off walking backwards through the mount table. This doesn't 5797c478bd9Sstevel@tonic-gate * give us strict ordering but ensures that we try to unmount submounts 5807c478bd9Sstevel@tonic-gate * first. We thus limit the number of failed umount2(2) calls. 5817c478bd9Sstevel@tonic-gate * 5827c478bd9Sstevel@tonic-gate * The mechanism for determining if we're stuck is to count the number 5837c478bd9Sstevel@tonic-gate * of failed unmounts each iteration through the mount table. This 5847c478bd9Sstevel@tonic-gate * gives us an upper bound on the number of filesystems which remain 5857c478bd9Sstevel@tonic-gate * mounted (autofs trigger nodes are dealt with separately). If at the 5867c478bd9Sstevel@tonic-gate * end of one unmount+autofs_cleanup cycle we still have the same number 5877c478bd9Sstevel@tonic-gate * of mounts that we started out with, we're stuck and try a forced 5887c478bd9Sstevel@tonic-gate * unmount. If that fails (filesystem doesn't support forced unmounts) 5897c478bd9Sstevel@tonic-gate * then we bail and are unable to teardown the zone. If it succeeds, 5907c478bd9Sstevel@tonic-gate * we're no longer stuck so we continue with our policy of trying 5917c478bd9Sstevel@tonic-gate * graceful mounts first. 5927c478bd9Sstevel@tonic-gate * 5937c478bd9Sstevel@tonic-gate * Zone must be down (ie, no processes or threads active). 5947c478bd9Sstevel@tonic-gate */ 5957c478bd9Sstevel@tonic-gate static int 596108322fbScarlsonj unmount_filesystems(zlog_t *zlogp, zoneid_t zoneid, boolean_t unmount_cmd) 5977c478bd9Sstevel@tonic-gate { 5987c478bd9Sstevel@tonic-gate int error = 0; 5997c478bd9Sstevel@tonic-gate FILE *mnttab; 6007c478bd9Sstevel@tonic-gate struct mnttab *mnts; 6017c478bd9Sstevel@tonic-gate uint_t nmnt; 6027c478bd9Sstevel@tonic-gate char zroot[MAXPATHLEN + 1]; 6037c478bd9Sstevel@tonic-gate size_t zrootlen; 6047c478bd9Sstevel@tonic-gate uint_t oldcount = UINT_MAX; 6057c478bd9Sstevel@tonic-gate boolean_t stuck = B_FALSE; 6067c478bd9Sstevel@tonic-gate char **remote_fstypes = NULL; 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate if (zone_get_rootpath(zone_name, zroot, sizeof (zroot)) != Z_OK) { 6097c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "unable to determine zone root"); 6107c478bd9Sstevel@tonic-gate return (-1); 6117c478bd9Sstevel@tonic-gate } 612108322fbScarlsonj if (unmount_cmd) 613108322fbScarlsonj root_to_lu(zlogp, zroot, sizeof (zroot), B_FALSE); 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate (void) strcat(zroot, "/"); 6167c478bd9Sstevel@tonic-gate zrootlen = strlen(zroot); 6177c478bd9Sstevel@tonic-gate 61845916cd2Sjpk /* 61945916cd2Sjpk * For Trusted Extensions unmount each higher level zone's mount 62045916cd2Sjpk * of our zone's /export/home 62145916cd2Sjpk */ 62248451833Scarlsonj if (!unmount_cmd) 62345916cd2Sjpk tsol_unmounts(zlogp, zone_name); 62445916cd2Sjpk 6257c478bd9Sstevel@tonic-gate if ((mnttab = fopen(MNTTAB, "r")) == NULL) { 6267c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to open %s", MNTTAB); 6277c478bd9Sstevel@tonic-gate return (-1); 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate /* 6307c478bd9Sstevel@tonic-gate * Use our hacky mntfs ioctl so we see everything, even mounts with 6317c478bd9Sstevel@tonic-gate * MS_NOMNTTAB. 6327c478bd9Sstevel@tonic-gate */ 6337c478bd9Sstevel@tonic-gate if (ioctl(fileno(mnttab), MNTIOC_SHOWHIDDEN, NULL) < 0) { 6347c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to configure %s", MNTTAB); 6357c478bd9Sstevel@tonic-gate error++; 6367c478bd9Sstevel@tonic-gate goto out; 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate /* 6407c478bd9Sstevel@tonic-gate * Build the list of remote fstypes so we know which ones we 6417c478bd9Sstevel@tonic-gate * should forcibly unmount. 6427c478bd9Sstevel@tonic-gate */ 6437c478bd9Sstevel@tonic-gate remote_fstypes = get_remote_fstypes(zlogp); 6447c478bd9Sstevel@tonic-gate for (; /* ever */; ) { 6457c478bd9Sstevel@tonic-gate uint_t newcount = 0; 6467c478bd9Sstevel@tonic-gate boolean_t unmounted; 6477c478bd9Sstevel@tonic-gate struct mnttab *mnp; 6487c478bd9Sstevel@tonic-gate char *path; 6497c478bd9Sstevel@tonic-gate uint_t i; 6507c478bd9Sstevel@tonic-gate 6517c478bd9Sstevel@tonic-gate mnts = NULL; 6527c478bd9Sstevel@tonic-gate nmnt = 0; 6537c478bd9Sstevel@tonic-gate /* 6547c478bd9Sstevel@tonic-gate * MNTTAB gives us a way to walk through mounted 6557c478bd9Sstevel@tonic-gate * filesystems; we need to be able to walk them in 6567c478bd9Sstevel@tonic-gate * reverse order, so we build a list of all mounted 6577c478bd9Sstevel@tonic-gate * filesystems. 6587c478bd9Sstevel@tonic-gate */ 6597c478bd9Sstevel@tonic-gate if (build_mnttable(zlogp, zroot, zrootlen, mnttab, &mnts, 6607c478bd9Sstevel@tonic-gate &nmnt) != 0) { 6617c478bd9Sstevel@tonic-gate error++; 6627c478bd9Sstevel@tonic-gate goto out; 6637c478bd9Sstevel@tonic-gate } 6647c478bd9Sstevel@tonic-gate for (i = 0; i < nmnt; i++) { 6657c478bd9Sstevel@tonic-gate mnp = &mnts[nmnt - i - 1]; /* access in reverse order */ 6667c478bd9Sstevel@tonic-gate path = mnp->mnt_mountp; 6677c478bd9Sstevel@tonic-gate unmounted = B_FALSE; 6687c478bd9Sstevel@tonic-gate /* 6697c478bd9Sstevel@tonic-gate * Try forced unmount first for remote filesystems. 6707c478bd9Sstevel@tonic-gate * 6717c478bd9Sstevel@tonic-gate * Not all remote filesystems support forced unmounts, 6727c478bd9Sstevel@tonic-gate * so if this fails (ENOTSUP) we'll continue on 6737c478bd9Sstevel@tonic-gate * and try a regular unmount. 6747c478bd9Sstevel@tonic-gate */ 6757c478bd9Sstevel@tonic-gate if (is_remote_fstype(mnp->mnt_fstype, remote_fstypes)) { 6767c478bd9Sstevel@tonic-gate if (umount2(path, MS_FORCE) == 0) 6777c478bd9Sstevel@tonic-gate unmounted = B_TRUE; 6787c478bd9Sstevel@tonic-gate } 6797c478bd9Sstevel@tonic-gate /* 6807c478bd9Sstevel@tonic-gate * Try forced unmount if we're stuck. 6817c478bd9Sstevel@tonic-gate */ 6827c478bd9Sstevel@tonic-gate if (stuck) { 6837c478bd9Sstevel@tonic-gate if (umount2(path, MS_FORCE) == 0) { 6847c478bd9Sstevel@tonic-gate unmounted = B_TRUE; 6857c478bd9Sstevel@tonic-gate stuck = B_FALSE; 6867c478bd9Sstevel@tonic-gate } else { 6877c478bd9Sstevel@tonic-gate /* 6887c478bd9Sstevel@tonic-gate * The first failure indicates a 6897c478bd9Sstevel@tonic-gate * mount we won't be able to get 6907c478bd9Sstevel@tonic-gate * rid of automatically, so we 6917c478bd9Sstevel@tonic-gate * bail. 6927c478bd9Sstevel@tonic-gate */ 6937c478bd9Sstevel@tonic-gate error++; 6947c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 6957c478bd9Sstevel@tonic-gate "unable to unmount '%s'", path); 6967c478bd9Sstevel@tonic-gate free_mnttable(mnts, nmnt); 6977c478bd9Sstevel@tonic-gate goto out; 6987c478bd9Sstevel@tonic-gate } 6997c478bd9Sstevel@tonic-gate } 7007c478bd9Sstevel@tonic-gate /* 7017c478bd9Sstevel@tonic-gate * Try regular unmounts for everything else. 7027c478bd9Sstevel@tonic-gate */ 7037c478bd9Sstevel@tonic-gate if (!unmounted && umount2(path, 0) != 0) 7047c478bd9Sstevel@tonic-gate newcount++; 7057c478bd9Sstevel@tonic-gate } 7067c478bd9Sstevel@tonic-gate free_mnttable(mnts, nmnt); 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate if (newcount == 0) 7097c478bd9Sstevel@tonic-gate break; 7107c478bd9Sstevel@tonic-gate if (newcount >= oldcount) { 7117c478bd9Sstevel@tonic-gate /* 7127c478bd9Sstevel@tonic-gate * Last round didn't unmount anything; we're stuck and 7137c478bd9Sstevel@tonic-gate * should start trying forced unmounts. 7147c478bd9Sstevel@tonic-gate */ 7157c478bd9Sstevel@tonic-gate stuck = B_TRUE; 7167c478bd9Sstevel@tonic-gate } 7177c478bd9Sstevel@tonic-gate oldcount = newcount; 7187c478bd9Sstevel@tonic-gate 7197c478bd9Sstevel@tonic-gate /* 7207c478bd9Sstevel@tonic-gate * Autofs doesn't let you unmount its trigger nodes from 7217c478bd9Sstevel@tonic-gate * userland so we have to tell the kernel to cleanup for us. 7227c478bd9Sstevel@tonic-gate */ 7237c478bd9Sstevel@tonic-gate if (autofs_cleanup(zoneid) != 0) { 7247c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to remove autofs nodes"); 7257c478bd9Sstevel@tonic-gate error++; 7267c478bd9Sstevel@tonic-gate goto out; 7277c478bd9Sstevel@tonic-gate } 7287c478bd9Sstevel@tonic-gate } 7297c478bd9Sstevel@tonic-gate 7307c478bd9Sstevel@tonic-gate out: 7317c478bd9Sstevel@tonic-gate free_remote_fstypes(remote_fstypes); 7327c478bd9Sstevel@tonic-gate (void) fclose(mnttab); 7337c478bd9Sstevel@tonic-gate return (error ? -1 : 0); 7347c478bd9Sstevel@tonic-gate } 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate static int 7377c478bd9Sstevel@tonic-gate fs_compare(const void *m1, const void *m2) 7387c478bd9Sstevel@tonic-gate { 7397c478bd9Sstevel@tonic-gate struct zone_fstab *i = (struct zone_fstab *)m1; 7407c478bd9Sstevel@tonic-gate struct zone_fstab *j = (struct zone_fstab *)m2; 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate return (strcmp(i->zone_fs_dir, j->zone_fs_dir)); 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate 7457c478bd9Sstevel@tonic-gate /* 7467c478bd9Sstevel@tonic-gate * Fork and exec (and wait for) the mentioned binary with the provided 7477c478bd9Sstevel@tonic-gate * arguments. Returns (-1) if something went wrong with fork(2) or exec(2), 7487c478bd9Sstevel@tonic-gate * returns the exit status otherwise. 7497c478bd9Sstevel@tonic-gate * 7507c478bd9Sstevel@tonic-gate * If we were unable to exec the provided pathname (for whatever 7517c478bd9Sstevel@tonic-gate * reason), we return the special token ZEXIT_EXEC. The current value 7527c478bd9Sstevel@tonic-gate * of ZEXIT_EXEC doesn't conflict with legitimate exit codes of the 7537c478bd9Sstevel@tonic-gate * consumers of this function; any future consumers must make sure this 7547c478bd9Sstevel@tonic-gate * remains the case. 7557c478bd9Sstevel@tonic-gate */ 7567c478bd9Sstevel@tonic-gate static int 7577c478bd9Sstevel@tonic-gate forkexec(zlog_t *zlogp, const char *path, char *const argv[]) 7587c478bd9Sstevel@tonic-gate { 7597c478bd9Sstevel@tonic-gate pid_t child_pid; 7607c478bd9Sstevel@tonic-gate int child_status = 0; 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate /* 7637c478bd9Sstevel@tonic-gate * Do not let another thread localize a message while we are forking. 7647c478bd9Sstevel@tonic-gate */ 7657c478bd9Sstevel@tonic-gate (void) mutex_lock(&msglock); 7667c478bd9Sstevel@tonic-gate child_pid = fork(); 7677c478bd9Sstevel@tonic-gate (void) mutex_unlock(&msglock); 7687c478bd9Sstevel@tonic-gate if (child_pid == -1) { 7697c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "could not fork for %s", argv[0]); 7707c478bd9Sstevel@tonic-gate return (-1); 7717c478bd9Sstevel@tonic-gate } else if (child_pid == 0) { 7727c478bd9Sstevel@tonic-gate closefrom(0); 7731390a385Sgjelinek /* redirect stdin, stdout & stderr to /dev/null */ 7741390a385Sgjelinek (void) open("/dev/null", O_RDONLY); /* stdin */ 7751390a385Sgjelinek (void) open("/dev/null", O_WRONLY); /* stdout */ 7761390a385Sgjelinek (void) open("/dev/null", O_WRONLY); /* stderr */ 7777c478bd9Sstevel@tonic-gate (void) execv(path, argv); 7787c478bd9Sstevel@tonic-gate /* 7797c478bd9Sstevel@tonic-gate * Since we are in the child, there is no point calling zerror() 7807c478bd9Sstevel@tonic-gate * since there is nobody waiting to consume it. So exit with a 7817c478bd9Sstevel@tonic-gate * special code that the parent will recognize and call zerror() 7827c478bd9Sstevel@tonic-gate * accordingly. 7837c478bd9Sstevel@tonic-gate */ 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate _exit(ZEXIT_EXEC); 7867c478bd9Sstevel@tonic-gate } else { 7877c478bd9Sstevel@tonic-gate (void) waitpid(child_pid, &child_status, 0); 7887c478bd9Sstevel@tonic-gate } 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate if (WIFSIGNALED(child_status)) { 7917c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s unexpectedly terminated due to " 7927c478bd9Sstevel@tonic-gate "signal %d", path, WTERMSIG(child_status)); 7937c478bd9Sstevel@tonic-gate return (-1); 7947c478bd9Sstevel@tonic-gate } 7957c478bd9Sstevel@tonic-gate assert(WIFEXITED(child_status)); 7967c478bd9Sstevel@tonic-gate if (WEXITSTATUS(child_status) == ZEXIT_EXEC) { 7977c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "failed to exec %s", path); 7987c478bd9Sstevel@tonic-gate return (-1); 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate return (WEXITSTATUS(child_status)); 8017c478bd9Sstevel@tonic-gate } 8027c478bd9Sstevel@tonic-gate 8037c478bd9Sstevel@tonic-gate static int 80493239addSjohnlev isregfile(const char *path) 80593239addSjohnlev { 80693239addSjohnlev struct stat64 st; 80793239addSjohnlev 80893239addSjohnlev if (stat64(path, &st) == -1) 80993239addSjohnlev return (-1); 81093239addSjohnlev 81193239addSjohnlev return (S_ISREG(st.st_mode)); 81293239addSjohnlev } 81393239addSjohnlev 81493239addSjohnlev static int 8157c478bd9Sstevel@tonic-gate dofsck(zlog_t *zlogp, const char *fstype, const char *rawdev) 8167c478bd9Sstevel@tonic-gate { 8177c478bd9Sstevel@tonic-gate char cmdbuf[MAXPATHLEN]; 8187c478bd9Sstevel@tonic-gate char *argv[4]; 8197c478bd9Sstevel@tonic-gate int status; 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate /* 8227c478bd9Sstevel@tonic-gate * We could alternatively have called /usr/sbin/fsck -F <fstype>, but 8237c478bd9Sstevel@tonic-gate * that would cost us an extra fork/exec without buying us anything. 8247c478bd9Sstevel@tonic-gate */ 8257c478bd9Sstevel@tonic-gate if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/lib/fs/%s/fsck", fstype) 8269acbbeafSnn35248 >= sizeof (cmdbuf)) { 8277c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "file-system type %s too long", fstype); 8287c478bd9Sstevel@tonic-gate return (-1); 8297c478bd9Sstevel@tonic-gate } 8307c478bd9Sstevel@tonic-gate 83193239addSjohnlev /* 83293239addSjohnlev * If it doesn't exist, that's OK: we verified this previously 83393239addSjohnlev * in zoneadm. 83493239addSjohnlev */ 83593239addSjohnlev if (isregfile(cmdbuf) == -1) 83693239addSjohnlev return (0); 83793239addSjohnlev 8387c478bd9Sstevel@tonic-gate argv[0] = "fsck"; 8397c478bd9Sstevel@tonic-gate argv[1] = "-m"; 8407c478bd9Sstevel@tonic-gate argv[2] = (char *)rawdev; 8417c478bd9Sstevel@tonic-gate argv[3] = NULL; 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate status = forkexec(zlogp, cmdbuf, argv); 8447c478bd9Sstevel@tonic-gate if (status == 0 || status == -1) 8457c478bd9Sstevel@tonic-gate return (status); 8467c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "fsck of '%s' failed with exit status %d; " 8477c478bd9Sstevel@tonic-gate "run fsck manually", rawdev, status); 8487c478bd9Sstevel@tonic-gate return (-1); 8497c478bd9Sstevel@tonic-gate } 8507c478bd9Sstevel@tonic-gate 8517c478bd9Sstevel@tonic-gate static int 8527c478bd9Sstevel@tonic-gate domount(zlog_t *zlogp, const char *fstype, const char *opts, 8537c478bd9Sstevel@tonic-gate const char *special, const char *directory) 8547c478bd9Sstevel@tonic-gate { 8557c478bd9Sstevel@tonic-gate char cmdbuf[MAXPATHLEN]; 8567c478bd9Sstevel@tonic-gate char *argv[6]; 8577c478bd9Sstevel@tonic-gate int status; 8587c478bd9Sstevel@tonic-gate 8597c478bd9Sstevel@tonic-gate /* 8607c478bd9Sstevel@tonic-gate * We could alternatively have called /usr/sbin/mount -F <fstype>, but 8617c478bd9Sstevel@tonic-gate * that would cost us an extra fork/exec without buying us anything. 8627c478bd9Sstevel@tonic-gate */ 8637c478bd9Sstevel@tonic-gate if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/lib/fs/%s/mount", fstype) 8649acbbeafSnn35248 >= sizeof (cmdbuf)) { 8657c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "file-system type %s too long", fstype); 8667c478bd9Sstevel@tonic-gate return (-1); 8677c478bd9Sstevel@tonic-gate } 8687c478bd9Sstevel@tonic-gate argv[0] = "mount"; 8697c478bd9Sstevel@tonic-gate if (opts[0] == '\0') { 8707c478bd9Sstevel@tonic-gate argv[1] = (char *)special; 8717c478bd9Sstevel@tonic-gate argv[2] = (char *)directory; 8727c478bd9Sstevel@tonic-gate argv[3] = NULL; 8737c478bd9Sstevel@tonic-gate } else { 8747c478bd9Sstevel@tonic-gate argv[1] = "-o"; 8757c478bd9Sstevel@tonic-gate argv[2] = (char *)opts; 8767c478bd9Sstevel@tonic-gate argv[3] = (char *)special; 8777c478bd9Sstevel@tonic-gate argv[4] = (char *)directory; 8787c478bd9Sstevel@tonic-gate argv[5] = NULL; 8797c478bd9Sstevel@tonic-gate } 8807c478bd9Sstevel@tonic-gate 8817c478bd9Sstevel@tonic-gate status = forkexec(zlogp, cmdbuf, argv); 8827c478bd9Sstevel@tonic-gate if (status == 0 || status == -1) 8837c478bd9Sstevel@tonic-gate return (status); 8847c478bd9Sstevel@tonic-gate if (opts[0] == '\0') 8857c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "\"%s %s %s\" " 8867c478bd9Sstevel@tonic-gate "failed with exit code %d", 8877c478bd9Sstevel@tonic-gate cmdbuf, special, directory, status); 8887c478bd9Sstevel@tonic-gate else 8897c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "\"%s -o %s %s %s\" " 8907c478bd9Sstevel@tonic-gate "failed with exit code %d", 8917c478bd9Sstevel@tonic-gate cmdbuf, opts, special, directory, status); 8927c478bd9Sstevel@tonic-gate return (-1); 8937c478bd9Sstevel@tonic-gate } 8947c478bd9Sstevel@tonic-gate 8957c478bd9Sstevel@tonic-gate /* 896d314f035Sedp * Check if a given mount point path exists. 897d314f035Sedp * If it does, make sure it doesn't contain any symlinks. 898d314f035Sedp * Note that if "leaf" is false we're checking an intermediate 899d314f035Sedp * component of the mount point path, so it must be a directory. 900d314f035Sedp * If "leaf" is true, then we're checking the entire mount point 901d314f035Sedp * path, so the mount point itself can be anything aside from a 902d314f035Sedp * symbolic link. 903d314f035Sedp * 904d314f035Sedp * If the path is invalid then a negative value is returned. If the 905d314f035Sedp * path exists and is a valid mount point path then 0 is returned. 906d314f035Sedp * If the path doesn't exist return a positive value. 9077c478bd9Sstevel@tonic-gate */ 9087c478bd9Sstevel@tonic-gate static int 909d314f035Sedp valid_mount_point(zlog_t *zlogp, const char *path, const boolean_t leaf) 9107c478bd9Sstevel@tonic-gate { 9117c478bd9Sstevel@tonic-gate struct stat statbuf; 9127c478bd9Sstevel@tonic-gate char respath[MAXPATHLEN]; 9137c478bd9Sstevel@tonic-gate int res; 9147c478bd9Sstevel@tonic-gate 9157c478bd9Sstevel@tonic-gate if (lstat(path, &statbuf) != 0) { 9167c478bd9Sstevel@tonic-gate if (errno == ENOENT) 917d314f035Sedp return (1); 9187c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "can't stat %s", path); 9197c478bd9Sstevel@tonic-gate return (-1); 9207c478bd9Sstevel@tonic-gate } 9217c478bd9Sstevel@tonic-gate if (S_ISLNK(statbuf.st_mode)) { 9227c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s is a symlink", path); 9237c478bd9Sstevel@tonic-gate return (-1); 9247c478bd9Sstevel@tonic-gate } 925d314f035Sedp if (!leaf && !S_ISDIR(statbuf.st_mode)) { 9267c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s is not a directory", path); 9277c478bd9Sstevel@tonic-gate return (-1); 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate if ((res = resolvepath(path, respath, sizeof (respath))) == -1) { 9307c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to resolve path %s", path); 9317c478bd9Sstevel@tonic-gate return (-1); 9327c478bd9Sstevel@tonic-gate } 9337c478bd9Sstevel@tonic-gate respath[res] = '\0'; 9347c478bd9Sstevel@tonic-gate if (strcmp(path, respath) != 0) { 9357c478bd9Sstevel@tonic-gate /* 936d314f035Sedp * We don't like ".."s, "."s, or "//"s throwing us off 9377c478bd9Sstevel@tonic-gate */ 9387c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s is not a canonical path", path); 9397c478bd9Sstevel@tonic-gate return (-1); 9407c478bd9Sstevel@tonic-gate } 9417c478bd9Sstevel@tonic-gate return (0); 9427c478bd9Sstevel@tonic-gate } 9437c478bd9Sstevel@tonic-gate 9447c478bd9Sstevel@tonic-gate /* 945d314f035Sedp * Validate a mount point path. A valid mount point path is an 946d314f035Sedp * absolute path that either doesn't exist, or, if it does exists it 947d314f035Sedp * must be an absolute canonical path that doesn't have any symbolic 948d314f035Sedp * links in it. The target of a mount point path can be any filesystem 949d314f035Sedp * object. (Different filesystems can support different mount points, 950d314f035Sedp * for example "lofs" and "mntfs" both support files and directories 951d314f035Sedp * while "ufs" just supports directories.) 9527c478bd9Sstevel@tonic-gate * 953d314f035Sedp * If the path is invalid then a negative value is returned. If the 954d314f035Sedp * path exists and is a valid mount point path then 0 is returned. 955d314f035Sedp * If the path doesn't exist return a positive value. 9567c478bd9Sstevel@tonic-gate */ 957d314f035Sedp int 958d314f035Sedp valid_mount_path(zlog_t *zlogp, const char *rootpath, const char *spec, 959d314f035Sedp const char *dir, const char *fstype) 9607c478bd9Sstevel@tonic-gate { 961d314f035Sedp char abspath[MAXPATHLEN], *slashp, *slashp_next; 962d314f035Sedp int rv; 9637c478bd9Sstevel@tonic-gate 9647c478bd9Sstevel@tonic-gate /* 965d314f035Sedp * Sanity check the target mount point path. 966d314f035Sedp * It must be a non-null string that starts with a '/'. 9677c478bd9Sstevel@tonic-gate */ 968d314f035Sedp if (dir[0] != '/') { 969d314f035Sedp if (spec[0] == '\0') { 970d314f035Sedp /* 971d314f035Sedp * This must be an invalid ipd entry (see comments 972d314f035Sedp * in mount_filesystems_ipdent()). 973d314f035Sedp */ 974d314f035Sedp zerror(zlogp, B_FALSE, 975d314f035Sedp "invalid inherit-pkg-dir entry: \"%s\"", dir); 976d314f035Sedp } else { 977d314f035Sedp /* Something went wrong. */ 978d314f035Sedp zerror(zlogp, B_FALSE, "invalid mount directory, " 979d314f035Sedp "type: \"%s\", special: \"%s\", dir: \"%s\"", 980d314f035Sedp fstype, spec, dir); 981d314f035Sedp } 982d314f035Sedp return (-1); 9837c478bd9Sstevel@tonic-gate } 9847c478bd9Sstevel@tonic-gate 985d314f035Sedp /* 986d314f035Sedp * Join rootpath and dir. Make sure abspath ends with '/', this 987d314f035Sedp * is added to all paths (even non-directory paths) to allow us 988d314f035Sedp * to detect the end of paths below. If the path already ends 989d314f035Sedp * in a '/', then that's ok too (although we'll fail the 990d314f035Sedp * cannonical path check in valid_mount_point()). 991d314f035Sedp */ 992d314f035Sedp if (snprintf(abspath, sizeof (abspath), 993d314f035Sedp "%s%s/", rootpath, dir) >= sizeof (abspath)) { 994d314f035Sedp zerror(zlogp, B_FALSE, "pathname %s%s is too long", 995d314f035Sedp rootpath, dir); 996d314f035Sedp return (-1); 997d314f035Sedp } 998d314f035Sedp 999d314f035Sedp /* 1000d314f035Sedp * Starting with rootpath, verify the mount path one component 1001d314f035Sedp * at a time. Continue until we've evaluated all of abspath. 1002d314f035Sedp */ 10037c478bd9Sstevel@tonic-gate slashp = &abspath[strlen(rootpath)]; 10047c478bd9Sstevel@tonic-gate assert(*slashp == '/'); 10057c478bd9Sstevel@tonic-gate do { 1006d314f035Sedp slashp_next = strchr(slashp + 1, '/'); 10077c478bd9Sstevel@tonic-gate *slashp = '\0'; 1008d314f035Sedp if (slashp_next != NULL) { 1009d314f035Sedp /* This is an intermediary mount path component. */ 1010d314f035Sedp rv = valid_mount_point(zlogp, abspath, B_FALSE); 1011d314f035Sedp } else { 1012d314f035Sedp /* This is the last component of the mount path. */ 1013d314f035Sedp rv = valid_mount_point(zlogp, abspath, B_TRUE); 1014d314f035Sedp } 1015d314f035Sedp if (rv < 0) 1016d314f035Sedp return (rv); 10177c478bd9Sstevel@tonic-gate *slashp = '/'; 1018d314f035Sedp } while ((slashp = slashp_next) != NULL); 1019d314f035Sedp return (rv); 10207c478bd9Sstevel@tonic-gate } 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate static int 10239acbbeafSnn35248 mount_one_dev_device_cb(void *arg, const char *match, const char *name) 10249acbbeafSnn35248 { 10259acbbeafSnn35248 di_prof_t prof = arg; 10269acbbeafSnn35248 10279acbbeafSnn35248 if (name == NULL) 10289acbbeafSnn35248 return (di_prof_add_dev(prof, match)); 10299acbbeafSnn35248 return (di_prof_add_map(prof, match, name)); 10309acbbeafSnn35248 } 10319acbbeafSnn35248 10329acbbeafSnn35248 static int 10339acbbeafSnn35248 mount_one_dev_symlink_cb(void *arg, const char *source, const char *target) 10349acbbeafSnn35248 { 10359acbbeafSnn35248 di_prof_t prof = arg; 10369acbbeafSnn35248 10379acbbeafSnn35248 return (di_prof_add_symlink(prof, source, target)); 10389acbbeafSnn35248 } 10399acbbeafSnn35248 10402b24ab6bSSebastien Roy int 10412b24ab6bSSebastien Roy vplat_get_iptype(zlog_t *zlogp, zone_iptype_t *iptypep) 1042f4b3ec61Sdh155122 { 1043f4b3ec61Sdh155122 zone_dochandle_t handle; 1044f4b3ec61Sdh155122 1045f4b3ec61Sdh155122 if ((handle = zonecfg_init_handle()) == NULL) { 1046f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 1047f4b3ec61Sdh155122 return (-1); 1048f4b3ec61Sdh155122 } 1049f4b3ec61Sdh155122 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 1050f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "invalid configuration"); 1051f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 1052f4b3ec61Sdh155122 return (-1); 1053f4b3ec61Sdh155122 } 1054f4b3ec61Sdh155122 if (zonecfg_get_iptype(handle, iptypep) != Z_OK) { 1055f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "invalid ip-type configuration"); 1056f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 1057f4b3ec61Sdh155122 return (-1); 1058f4b3ec61Sdh155122 } 1059f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 1060f4b3ec61Sdh155122 return (0); 1061f4b3ec61Sdh155122 } 1062f4b3ec61Sdh155122 10639acbbeafSnn35248 /* 10649acbbeafSnn35248 * Apply the standard lists of devices/symlinks/mappings and the user-specified 10659acbbeafSnn35248 * list of devices (via zonecfg) to the /dev filesystem. The filesystem will 10669acbbeafSnn35248 * use these as a profile/filter to determine what exists in /dev. 10679acbbeafSnn35248 */ 10689acbbeafSnn35248 static int 10690679f794S mount_one_dev(zlog_t *zlogp, char *devpath, zone_mnt_t mount_cmd) 10709acbbeafSnn35248 { 10719acbbeafSnn35248 char brand[MAXNAMELEN]; 10729acbbeafSnn35248 zone_dochandle_t handle = NULL; 1073123807fbSedp brand_handle_t bh = NULL; 10749acbbeafSnn35248 struct zone_devtab ztab; 10759acbbeafSnn35248 di_prof_t prof = NULL; 10769acbbeafSnn35248 int err; 10779acbbeafSnn35248 int retval = -1; 1078f4b3ec61Sdh155122 zone_iptype_t iptype; 1079f4b3ec61Sdh155122 const char *curr_iptype; 10809acbbeafSnn35248 10819acbbeafSnn35248 if (di_prof_init(devpath, &prof)) { 10829acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to initialize profile"); 10839acbbeafSnn35248 goto cleanup; 10849acbbeafSnn35248 } 10859acbbeafSnn35248 10860679f794S /* 10870679f794S * Get a handle to the brand info for this zone. 1088*e5816e35SEdward Pilatowicz * If we are mounting the zone, then we must always use the default 10890679f794S * brand device mounts. 10900679f794S */ 10910679f794S if (ALT_MOUNT(mount_cmd)) { 1092*e5816e35SEdward Pilatowicz (void) strlcpy(brand, default_brand, sizeof (brand)); 10930679f794S } else { 109462868012SSteve Lawrence (void) strlcpy(brand, brand_name, sizeof (brand)); 10950679f794S } 10960679f794S 10970679f794S if ((bh = brand_open(brand)) == NULL) { 10989acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 10999acbbeafSnn35248 goto cleanup; 11009acbbeafSnn35248 } 11019acbbeafSnn35248 11022b24ab6bSSebastien Roy if (vplat_get_iptype(zlogp, &iptype) < 0) { 1103f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 1104f4b3ec61Sdh155122 goto cleanup; 1105f4b3ec61Sdh155122 } 1106f4b3ec61Sdh155122 switch (iptype) { 1107f4b3ec61Sdh155122 case ZS_SHARED: 1108f4b3ec61Sdh155122 curr_iptype = "shared"; 1109f4b3ec61Sdh155122 break; 1110f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 1111f4b3ec61Sdh155122 curr_iptype = "exclusive"; 1112f4b3ec61Sdh155122 break; 1113f4b3ec61Sdh155122 } 1114f4b3ec61Sdh155122 1115123807fbSedp if (brand_platform_iter_devices(bh, zone_name, 1116f4b3ec61Sdh155122 mount_one_dev_device_cb, prof, curr_iptype) != 0) { 11179acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to add standard device"); 11189acbbeafSnn35248 goto cleanup; 11199acbbeafSnn35248 } 11209acbbeafSnn35248 1121123807fbSedp if (brand_platform_iter_link(bh, 11229acbbeafSnn35248 mount_one_dev_symlink_cb, prof) != 0) { 11239acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to add standard symlink"); 11249acbbeafSnn35248 goto cleanup; 11259acbbeafSnn35248 } 11269acbbeafSnn35248 11279acbbeafSnn35248 /* Add user-specified devices and directories */ 11289acbbeafSnn35248 if ((handle = zonecfg_init_handle()) == NULL) { 11299acbbeafSnn35248 zerror(zlogp, B_FALSE, "can't initialize zone handle"); 11309acbbeafSnn35248 goto cleanup; 11319acbbeafSnn35248 } 11329acbbeafSnn35248 if (err = zonecfg_get_handle(zone_name, handle)) { 11339acbbeafSnn35248 zerror(zlogp, B_FALSE, "can't get handle for zone " 11349acbbeafSnn35248 "%s: %s", zone_name, zonecfg_strerror(err)); 11359acbbeafSnn35248 goto cleanup; 11369acbbeafSnn35248 } 11379acbbeafSnn35248 if (err = zonecfg_setdevent(handle)) { 11389acbbeafSnn35248 zerror(zlogp, B_FALSE, "%s: %s", zone_name, 11399acbbeafSnn35248 zonecfg_strerror(err)); 11409acbbeafSnn35248 goto cleanup; 11419acbbeafSnn35248 } 11429acbbeafSnn35248 while (zonecfg_getdevent(handle, &ztab) == Z_OK) { 11439acbbeafSnn35248 if (di_prof_add_dev(prof, ztab.zone_dev_match)) { 11449acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to add " 11459acbbeafSnn35248 "user-specified device"); 11469acbbeafSnn35248 goto cleanup; 11479acbbeafSnn35248 } 11489acbbeafSnn35248 } 11499acbbeafSnn35248 (void) zonecfg_enddevent(handle); 11509acbbeafSnn35248 11519acbbeafSnn35248 /* Send profile to kernel */ 11529acbbeafSnn35248 if (di_prof_commit(prof)) { 11539acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to commit profile"); 11549acbbeafSnn35248 goto cleanup; 11559acbbeafSnn35248 } 11569acbbeafSnn35248 11579acbbeafSnn35248 retval = 0; 11589acbbeafSnn35248 11599acbbeafSnn35248 cleanup: 1160123807fbSedp if (bh != NULL) 1161123807fbSedp brand_close(bh); 1162e767a340Sgjelinek if (handle != NULL) 11639acbbeafSnn35248 zonecfg_fini_handle(handle); 11649acbbeafSnn35248 if (prof) 11659acbbeafSnn35248 di_prof_fini(prof); 11669acbbeafSnn35248 return (retval); 11679acbbeafSnn35248 } 11689acbbeafSnn35248 11699acbbeafSnn35248 static int 11700679f794S mount_one(zlog_t *zlogp, struct zone_fstab *fsptr, const char *rootpath, 11710679f794S zone_mnt_t mount_cmd) 11727c478bd9Sstevel@tonic-gate { 11737c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 1174108322fbScarlsonj char specpath[MAXPATHLEN]; 11757c478bd9Sstevel@tonic-gate char optstr[MAX_MNTOPT_STR]; 11767c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 11779acbbeafSnn35248 int rv; 11787c478bd9Sstevel@tonic-gate 1179d314f035Sedp if ((rv = valid_mount_path(zlogp, rootpath, fsptr->zone_fs_special, 1180d314f035Sedp fsptr->zone_fs_dir, fsptr->zone_fs_type)) < 0) { 11817c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s%s is not a valid mount point", 11827c478bd9Sstevel@tonic-gate rootpath, fsptr->zone_fs_dir); 11837c478bd9Sstevel@tonic-gate return (-1); 1184d314f035Sedp } else if (rv > 0) { 1185d314f035Sedp /* The mount point path doesn't exist, create it now. */ 1186d314f035Sedp if (make_one_dir(zlogp, rootpath, fsptr->zone_fs_dir, 1187d314f035Sedp DEFAULT_DIR_MODE, DEFAULT_DIR_USER, 1188d314f035Sedp DEFAULT_DIR_GROUP) != 0) { 1189d314f035Sedp zerror(zlogp, B_FALSE, "failed to create mount point"); 1190d314f035Sedp return (-1); 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate 1193d314f035Sedp /* 1194d314f035Sedp * Now this might seem weird, but we need to invoke 1195d314f035Sedp * valid_mount_path() again. Why? Because it checks 1196d314f035Sedp * to make sure that the mount point path is canonical, 1197d314f035Sedp * which it can only do if the path exists, so now that 1198d314f035Sedp * we've created the path we have to verify it again. 1199d314f035Sedp */ 1200d314f035Sedp if ((rv = valid_mount_path(zlogp, rootpath, 1201d314f035Sedp fsptr->zone_fs_special, fsptr->zone_fs_dir, 1202d314f035Sedp fsptr->zone_fs_type)) < 0) { 1203d314f035Sedp zerror(zlogp, B_FALSE, 1204d314f035Sedp "%s%s is not a valid mount point", 1205d314f035Sedp rootpath, fsptr->zone_fs_dir); 12067c478bd9Sstevel@tonic-gate return (-1); 1207d314f035Sedp } 1208d314f035Sedp } 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", rootpath, 12117c478bd9Sstevel@tonic-gate fsptr->zone_fs_dir); 12127c478bd9Sstevel@tonic-gate 12137c478bd9Sstevel@tonic-gate if (strlen(fsptr->zone_fs_special) == 0) { 12147c478bd9Sstevel@tonic-gate /* 12157c478bd9Sstevel@tonic-gate * A zero-length special is how we distinguish IPDs from 1216108322fbScarlsonj * general-purpose FSs. Make sure it mounts from a place that 1217108322fbScarlsonj * can be seen via the alternate zone's root. 12187c478bd9Sstevel@tonic-gate */ 1219108322fbScarlsonj if (snprintf(specpath, sizeof (specpath), "%s%s", 1220108322fbScarlsonj zonecfg_get_root(), fsptr->zone_fs_dir) >= 1221108322fbScarlsonj sizeof (specpath)) { 1222108322fbScarlsonj zerror(zlogp, B_FALSE, "cannot mount %s: path too " 1223108322fbScarlsonj "long in alternate root", fsptr->zone_fs_dir); 1224108322fbScarlsonj return (-1); 1225108322fbScarlsonj } 1226108322fbScarlsonj if (zonecfg_in_alt_root()) 1227108322fbScarlsonj resolve_lofs(zlogp, specpath, sizeof (specpath)); 12287c478bd9Sstevel@tonic-gate if (domount(zlogp, MNTTYPE_LOFS, IPD_DEFAULT_OPTS, 1229108322fbScarlsonj specpath, path) != 0) { 12307c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to loopback mount %s", 1231108322fbScarlsonj specpath); 12327c478bd9Sstevel@tonic-gate return (-1); 12337c478bd9Sstevel@tonic-gate } 12347c478bd9Sstevel@tonic-gate return (0); 12357c478bd9Sstevel@tonic-gate } 12367c478bd9Sstevel@tonic-gate 12377c478bd9Sstevel@tonic-gate /* 12387c478bd9Sstevel@tonic-gate * In general the strategy here is to do just as much verification as 12397c478bd9Sstevel@tonic-gate * necessary to avoid crashing or otherwise doing something bad; if the 12407c478bd9Sstevel@tonic-gate * administrator initiated the operation via zoneadm(1m), he'll get 12417c478bd9Sstevel@tonic-gate * auto-verification which will let him know what's wrong. If he 12427c478bd9Sstevel@tonic-gate * modifies the zone configuration of a running zone and doesn't attempt 12437c478bd9Sstevel@tonic-gate * to verify that it's OK we won't crash but won't bother trying to be 12447c478bd9Sstevel@tonic-gate * too helpful either. zoneadm verify is only a couple keystrokes away. 12457c478bd9Sstevel@tonic-gate */ 12467c478bd9Sstevel@tonic-gate if (!zonecfg_valid_fs_type(fsptr->zone_fs_type)) { 12477c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "cannot mount %s on %s: " 12487c478bd9Sstevel@tonic-gate "invalid file-system type %s", fsptr->zone_fs_special, 12497c478bd9Sstevel@tonic-gate fsptr->zone_fs_dir, fsptr->zone_fs_type); 12507c478bd9Sstevel@tonic-gate return (-1); 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate /* 1254108322fbScarlsonj * If we're looking at an alternate root environment, then construct 1255fa3d7ae1Sedp * read-only loopback mounts as necessary. Note that any special 1256fa3d7ae1Sedp * paths for lofs zone mounts in an alternate root must have 1257fa3d7ae1Sedp * already been pre-pended with any alternate root path by the 1258fa3d7ae1Sedp * time we get here. 1259108322fbScarlsonj */ 1260108322fbScarlsonj if (zonecfg_in_alt_root()) { 1261108322fbScarlsonj struct stat64 st; 1262108322fbScarlsonj 1263108322fbScarlsonj if (stat64(fsptr->zone_fs_special, &st) != -1 && 126468eeb376Scarlsonj S_ISBLK(st.st_mode)) { 1265fa3d7ae1Sedp /* 1266fa3d7ae1Sedp * If we're going to mount a block device we need 1267fa3d7ae1Sedp * to check if that device is already mounted 1268fa3d7ae1Sedp * somewhere else, and if so, do a lofs mount 1269fa3d7ae1Sedp * of the device instead of a direct mount 1270fa3d7ae1Sedp */ 127168eeb376Scarlsonj if (check_lofs_needed(zlogp, fsptr) == -1) 1272108322fbScarlsonj return (-1); 127368eeb376Scarlsonj } else if (strcmp(fsptr->zone_fs_type, MNTTYPE_LOFS) == 0) { 1274fa3d7ae1Sedp /* 1275fa3d7ae1Sedp * For lofs mounts, the special node is inside the 1276fa3d7ae1Sedp * alternate root. We need lofs resolution for 1277fa3d7ae1Sedp * this case in order to get at the underlying 1278fa3d7ae1Sedp * read-write path. 1279fa3d7ae1Sedp */ 1280fa3d7ae1Sedp resolve_lofs(zlogp, fsptr->zone_fs_special, 1281108322fbScarlsonj sizeof (fsptr->zone_fs_special)); 1282108322fbScarlsonj } 1283108322fbScarlsonj } 1284108322fbScarlsonj 1285108322fbScarlsonj /* 12867c478bd9Sstevel@tonic-gate * Run 'fsck -m' if there's a device to fsck. 12877c478bd9Sstevel@tonic-gate */ 12887c478bd9Sstevel@tonic-gate if (fsptr->zone_fs_raw[0] != '\0' && 128993239addSjohnlev dofsck(zlogp, fsptr->zone_fs_type, fsptr->zone_fs_raw) != 0) { 12907c478bd9Sstevel@tonic-gate return (-1); 129193239addSjohnlev } else if (isregfile(fsptr->zone_fs_special) == 1 && 129293239addSjohnlev dofsck(zlogp, fsptr->zone_fs_type, fsptr->zone_fs_special) != 0) { 129393239addSjohnlev return (-1); 129493239addSjohnlev } 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate /* 12977c478bd9Sstevel@tonic-gate * Build up mount option string. 12987c478bd9Sstevel@tonic-gate */ 12997c478bd9Sstevel@tonic-gate optstr[0] = '\0'; 13007c478bd9Sstevel@tonic-gate if (fsptr->zone_fs_options != NULL) { 13017c478bd9Sstevel@tonic-gate (void) strlcpy(optstr, fsptr->zone_fs_options->zone_fsopt_opt, 13027c478bd9Sstevel@tonic-gate sizeof (optstr)); 13037c478bd9Sstevel@tonic-gate for (optptr = fsptr->zone_fs_options->zone_fsopt_next; 13047c478bd9Sstevel@tonic-gate optptr != NULL; optptr = optptr->zone_fsopt_next) { 13057c478bd9Sstevel@tonic-gate (void) strlcat(optstr, ",", sizeof (optstr)); 13067c478bd9Sstevel@tonic-gate (void) strlcat(optstr, optptr->zone_fsopt_opt, 13077c478bd9Sstevel@tonic-gate sizeof (optstr)); 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate } 13109acbbeafSnn35248 13119acbbeafSnn35248 if ((rv = domount(zlogp, fsptr->zone_fs_type, optstr, 13129acbbeafSnn35248 fsptr->zone_fs_special, path)) != 0) 13139acbbeafSnn35248 return (rv); 13149acbbeafSnn35248 13159acbbeafSnn35248 /* 13169acbbeafSnn35248 * The mount succeeded. If this was not a mount of /dev then 13179acbbeafSnn35248 * we're done. 13189acbbeafSnn35248 */ 13199acbbeafSnn35248 if (strcmp(fsptr->zone_fs_type, MNTTYPE_DEV) != 0) 13209acbbeafSnn35248 return (0); 13219acbbeafSnn35248 13229acbbeafSnn35248 /* 13239acbbeafSnn35248 * We just mounted an instance of a /dev filesystem, so now we 13249acbbeafSnn35248 * need to configure it. 13259acbbeafSnn35248 */ 13260679f794S return (mount_one_dev(zlogp, path, mount_cmd)); 13277c478bd9Sstevel@tonic-gate } 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate static void 13307c478bd9Sstevel@tonic-gate free_fs_data(struct zone_fstab *fsarray, uint_t nelem) 13317c478bd9Sstevel@tonic-gate { 13327c478bd9Sstevel@tonic-gate uint_t i; 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate if (fsarray == NULL) 13357c478bd9Sstevel@tonic-gate return; 13367c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) 13377c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fsarray[i].zone_fs_options); 13387c478bd9Sstevel@tonic-gate free(fsarray); 13397c478bd9Sstevel@tonic-gate } 13407c478bd9Sstevel@tonic-gate 1341108322fbScarlsonj /* 1342f4368d3dSvp157776 * This function initiates the creation of a small Solaris Environment for 1343f4368d3dSvp157776 * scratch zone. The Environment creation process is split up into two 1344f4368d3dSvp157776 * functions(build_mounted_pre_var() and build_mounted_post_var()). It 1345f4368d3dSvp157776 * is done this way because: 1346f4368d3dSvp157776 * We need to have both /etc and /var in the root of the scratchzone. 1347f4368d3dSvp157776 * We loopback mount zone's own /etc and /var into the root of the 1348f4368d3dSvp157776 * scratch zone. Unlike /etc, /var can be a seperate filesystem. So we 1349f4368d3dSvp157776 * need to delay the mount of /var till the zone's root gets populated. 1350f4368d3dSvp157776 * So mounting of localdirs[](/etc and /var) have been moved to the 1351f4368d3dSvp157776 * build_mounted_post_var() which gets called only after the zone 1352f4368d3dSvp157776 * specific filesystems are mounted. 13536cfd72c6Sgjelinek * 13546cfd72c6Sgjelinek * Note that the scratch zone we set up for updating the zone (Z_MNT_UPDATE) 13556cfd72c6Sgjelinek * does not loopback mount the zone's own /etc and /var into the root of the 13566cfd72c6Sgjelinek * scratch zone. 1357108322fbScarlsonj */ 1358108322fbScarlsonj static boolean_t 1359f4368d3dSvp157776 build_mounted_pre_var(zlog_t *zlogp, char *rootpath, 136016bca938Svp157776 size_t rootlen, const char *zonepath, char *luroot, size_t lurootlen) 1361108322fbScarlsonj { 1362108322fbScarlsonj char tmp[MAXPATHLEN], fromdir[MAXPATHLEN]; 1363108322fbScarlsonj const char **cpp; 1364108322fbScarlsonj static const char *mkdirs[] = { 13653f604e0fSdp "/system", "/system/contract", "/system/object", "/proc", 13663f604e0fSdp "/dev", "/tmp", "/a", NULL 1367108322fbScarlsonj }; 1368108322fbScarlsonj char *altstr; 1369f4368d3dSvp157776 FILE *fp; 1370108322fbScarlsonj uuid_t uuid; 1371108322fbScarlsonj 1372108322fbScarlsonj resolve_lofs(zlogp, rootpath, rootlen); 137316bca938Svp157776 (void) snprintf(luroot, lurootlen, "%s/lu", zonepath); 137416bca938Svp157776 resolve_lofs(zlogp, luroot, lurootlen); 1375108322fbScarlsonj (void) snprintf(tmp, sizeof (tmp), "%s/bin", luroot); 1376108322fbScarlsonj (void) symlink("./usr/bin", tmp); 1377108322fbScarlsonj 1378108322fbScarlsonj /* 1379108322fbScarlsonj * These are mostly special mount points; not handled here. (See 1380108322fbScarlsonj * zone_mount_early.) 1381108322fbScarlsonj */ 1382108322fbScarlsonj for (cpp = mkdirs; *cpp != NULL; cpp++) { 1383108322fbScarlsonj (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 1384108322fbScarlsonj if (mkdir(tmp, 0755) != 0) { 1385108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1386108322fbScarlsonj return (B_FALSE); 1387108322fbScarlsonj } 1388108322fbScarlsonj } 1389f4368d3dSvp157776 /* 1390f4368d3dSvp157776 * This is here to support lucopy. If there's an instance of this same 1391f4368d3dSvp157776 * zone on the current running system, then we mount its root up as 1392f4368d3dSvp157776 * read-only inside the scratch zone. 1393f4368d3dSvp157776 */ 1394f4368d3dSvp157776 (void) zonecfg_get_uuid(zone_name, uuid); 1395f4368d3dSvp157776 altstr = strdup(zonecfg_get_root()); 1396f4368d3dSvp157776 if (altstr == NULL) { 1397f4368d3dSvp157776 zerror(zlogp, B_TRUE, "memory allocation failed"); 1398f4368d3dSvp157776 return (B_FALSE); 1399f4368d3dSvp157776 } 1400f4368d3dSvp157776 zonecfg_set_root(""); 1401f4368d3dSvp157776 (void) strlcpy(tmp, zone_name, sizeof (tmp)); 1402f4368d3dSvp157776 (void) zonecfg_get_name_by_uuid(uuid, tmp, sizeof (tmp)); 1403f4368d3dSvp157776 if (zone_get_rootpath(tmp, fromdir, sizeof (fromdir)) == Z_OK && 1404f4368d3dSvp157776 strcmp(fromdir, rootpath) != 0) { 1405f4368d3dSvp157776 (void) snprintf(tmp, sizeof (tmp), "%s/b", luroot); 1406f4368d3dSvp157776 if (mkdir(tmp, 0755) != 0) { 1407f4368d3dSvp157776 zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1408f4368d3dSvp157776 return (B_FALSE); 1409f4368d3dSvp157776 } 1410f4368d3dSvp157776 if (domount(zlogp, MNTTYPE_LOFS, IPD_DEFAULT_OPTS, fromdir, 1411f4368d3dSvp157776 tmp) != 0) { 1412f4368d3dSvp157776 zerror(zlogp, B_TRUE, "cannot mount %s on %s", tmp, 1413f4368d3dSvp157776 fromdir); 1414f4368d3dSvp157776 return (B_FALSE); 1415f4368d3dSvp157776 } 1416f4368d3dSvp157776 } 1417f4368d3dSvp157776 zonecfg_set_root(altstr); 1418f4368d3dSvp157776 free(altstr); 1419f4368d3dSvp157776 1420f4368d3dSvp157776 if ((fp = zonecfg_open_scratch(luroot, B_TRUE)) == NULL) { 1421f4368d3dSvp157776 zerror(zlogp, B_TRUE, "cannot open zone mapfile"); 1422f4368d3dSvp157776 return (B_FALSE); 1423f4368d3dSvp157776 } 1424f4368d3dSvp157776 (void) ftruncate(fileno(fp), 0); 1425f4368d3dSvp157776 if (zonecfg_add_scratch(fp, zone_name, kernzone, "/") == -1) { 1426f4368d3dSvp157776 zerror(zlogp, B_TRUE, "cannot add zone mapfile entry"); 1427f4368d3dSvp157776 } 1428f4368d3dSvp157776 zonecfg_close_scratch(fp); 1429f4368d3dSvp157776 (void) snprintf(tmp, sizeof (tmp), "%s/a", luroot); 1430f4368d3dSvp157776 if (domount(zlogp, MNTTYPE_LOFS, "", rootpath, tmp) != 0) 1431f4368d3dSvp157776 return (B_FALSE); 1432f4368d3dSvp157776 (void) strlcpy(rootpath, tmp, rootlen); 1433f4368d3dSvp157776 return (B_TRUE); 1434f4368d3dSvp157776 } 1435f4368d3dSvp157776 1436f4368d3dSvp157776 1437f4368d3dSvp157776 static boolean_t 14386cfd72c6Sgjelinek build_mounted_post_var(zlog_t *zlogp, zone_mnt_t mount_cmd, char *rootpath, 14396cfd72c6Sgjelinek const char *luroot) 1440f4368d3dSvp157776 { 1441f4368d3dSvp157776 char tmp[MAXPATHLEN], fromdir[MAXPATHLEN]; 1442f4368d3dSvp157776 const char **cpp; 14436cfd72c6Sgjelinek const char **loopdirs; 14446cfd72c6Sgjelinek const char **tmpdirs; 1445f4368d3dSvp157776 static const char *localdirs[] = { 1446f4368d3dSvp157776 "/etc", "/var", NULL 1447f4368d3dSvp157776 }; 14486cfd72c6Sgjelinek static const char *scr_loopdirs[] = { 1449f4368d3dSvp157776 "/etc/lib", "/etc/fs", "/lib", "/sbin", "/platform", 1450f4368d3dSvp157776 "/usr", NULL 1451f4368d3dSvp157776 }; 14526cfd72c6Sgjelinek static const char *upd_loopdirs[] = { 14536cfd72c6Sgjelinek "/etc", "/kernel", "/lib", "/opt", "/platform", "/sbin", 14546cfd72c6Sgjelinek "/usr", "/var", NULL 14556cfd72c6Sgjelinek }; 14566cfd72c6Sgjelinek static const char *scr_tmpdirs[] = { 1457f4368d3dSvp157776 "/tmp", "/var/run", NULL 1458f4368d3dSvp157776 }; 14596cfd72c6Sgjelinek static const char *upd_tmpdirs[] = { 14606cfd72c6Sgjelinek "/tmp", "/var/run", "/var/tmp", NULL 14616cfd72c6Sgjelinek }; 1462f4368d3dSvp157776 struct stat st; 1463f4368d3dSvp157776 14646cfd72c6Sgjelinek if (mount_cmd == Z_MNT_SCRATCH) { 1465108322fbScarlsonj /* 14666cfd72c6Sgjelinek * These are mounted read-write from the zone undergoing 14676cfd72c6Sgjelinek * upgrade. We must be careful not to 'leak' things from the 14686cfd72c6Sgjelinek * main system into the zone, and this accomplishes that goal. 1469108322fbScarlsonj */ 1470108322fbScarlsonj for (cpp = localdirs; *cpp != NULL; cpp++) { 14716cfd72c6Sgjelinek (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, 1472108322fbScarlsonj *cpp); 14736cfd72c6Sgjelinek (void) snprintf(fromdir, sizeof (fromdir), "%s%s", 14746cfd72c6Sgjelinek rootpath, *cpp); 1475108322fbScarlsonj if (mkdir(tmp, 0755) != 0) { 1476108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1477108322fbScarlsonj return (B_FALSE); 1478108322fbScarlsonj } 14796cfd72c6Sgjelinek if (domount(zlogp, MNTTYPE_LOFS, "", fromdir, tmp) 14806cfd72c6Sgjelinek != 0) { 14816cfd72c6Sgjelinek zerror(zlogp, B_TRUE, "cannot mount %s on %s", 14826cfd72c6Sgjelinek tmp, *cpp); 1483108322fbScarlsonj return (B_FALSE); 1484108322fbScarlsonj } 1485108322fbScarlsonj } 14866cfd72c6Sgjelinek } 14876cfd72c6Sgjelinek 14886cfd72c6Sgjelinek if (mount_cmd == Z_MNT_UPDATE) 14896cfd72c6Sgjelinek loopdirs = upd_loopdirs; 14906cfd72c6Sgjelinek else 14916cfd72c6Sgjelinek loopdirs = scr_loopdirs; 1492108322fbScarlsonj 1493108322fbScarlsonj /* 1494108322fbScarlsonj * These are things mounted read-only from the running system because 1495108322fbScarlsonj * they contain binaries that must match system. 1496108322fbScarlsonj */ 1497108322fbScarlsonj for (cpp = loopdirs; *cpp != NULL; cpp++) { 1498108322fbScarlsonj (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 1499108322fbScarlsonj if (mkdir(tmp, 0755) != 0) { 1500108322fbScarlsonj if (errno != EEXIST) { 1501108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1502108322fbScarlsonj return (B_FALSE); 1503108322fbScarlsonj } 1504108322fbScarlsonj if (lstat(tmp, &st) != 0) { 1505108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot stat %s", tmp); 1506108322fbScarlsonj return (B_FALSE); 1507108322fbScarlsonj } 1508108322fbScarlsonj /* 1509108322fbScarlsonj * Ignore any non-directories encountered. These are 1510108322fbScarlsonj * things that have been converted into symlinks 1511108322fbScarlsonj * (/etc/fs and /etc/lib) and no longer need a lofs 1512108322fbScarlsonj * fixup. 1513108322fbScarlsonj */ 1514108322fbScarlsonj if (!S_ISDIR(st.st_mode)) 1515108322fbScarlsonj continue; 1516108322fbScarlsonj } 1517108322fbScarlsonj if (domount(zlogp, MNTTYPE_LOFS, IPD_DEFAULT_OPTS, *cpp, 1518108322fbScarlsonj tmp) != 0) { 1519108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot mount %s on %s", tmp, 1520108322fbScarlsonj *cpp); 1521108322fbScarlsonj return (B_FALSE); 1522108322fbScarlsonj } 1523108322fbScarlsonj } 1524108322fbScarlsonj 15256cfd72c6Sgjelinek if (mount_cmd == Z_MNT_UPDATE) 15266cfd72c6Sgjelinek tmpdirs = upd_tmpdirs; 15276cfd72c6Sgjelinek else 15286cfd72c6Sgjelinek tmpdirs = scr_tmpdirs; 15296cfd72c6Sgjelinek 1530108322fbScarlsonj /* 1531108322fbScarlsonj * These are things with tmpfs mounted inside. 1532108322fbScarlsonj */ 1533108322fbScarlsonj for (cpp = tmpdirs; *cpp != NULL; cpp++) { 1534108322fbScarlsonj (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 15356cfd72c6Sgjelinek if (mount_cmd == Z_MNT_SCRATCH && mkdir(tmp, 0755) != 0 && 15366cfd72c6Sgjelinek errno != EEXIST) { 1537108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1538108322fbScarlsonj return (B_FALSE); 1539108322fbScarlsonj } 1540d30e996aSgjelinek 1541d30e996aSgjelinek /* 1542d30e996aSgjelinek * We could set the mode for /tmp when we do the mkdir but 1543d30e996aSgjelinek * since that can be modified by the umask we will just set 1544d30e996aSgjelinek * the correct mode for /tmp now. 1545d30e996aSgjelinek */ 1546d30e996aSgjelinek if (strcmp(*cpp, "/tmp") == 0 && chmod(tmp, 01777) != 0) { 1547d30e996aSgjelinek zerror(zlogp, B_TRUE, "cannot chmod %s", tmp); 1548d30e996aSgjelinek return (B_FALSE); 1549d30e996aSgjelinek } 1550d30e996aSgjelinek 1551108322fbScarlsonj if (domount(zlogp, MNTTYPE_TMPFS, "", "swap", tmp) != 0) { 1552108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot mount swap on %s", *cpp); 1553108322fbScarlsonj return (B_FALSE); 1554108322fbScarlsonj } 1555108322fbScarlsonj } 1556108322fbScarlsonj return (B_TRUE); 1557108322fbScarlsonj } 1558108322fbScarlsonj 15599acbbeafSnn35248 typedef struct plat_gmount_cb_data { 15609acbbeafSnn35248 zlog_t *pgcd_zlogp; 15619acbbeafSnn35248 struct zone_fstab **pgcd_fs_tab; 15629acbbeafSnn35248 int *pgcd_num_fs; 15639acbbeafSnn35248 } plat_gmount_cb_data_t; 15649acbbeafSnn35248 15659acbbeafSnn35248 /* 15669acbbeafSnn35248 * plat_gmount_cb() is a callback function invoked by libbrand to iterate 15679acbbeafSnn35248 * through all global brand platform mounts. 15689acbbeafSnn35248 */ 15699acbbeafSnn35248 int 15709acbbeafSnn35248 plat_gmount_cb(void *data, const char *spec, const char *dir, 15719acbbeafSnn35248 const char *fstype, const char *opt) 15729acbbeafSnn35248 { 15739acbbeafSnn35248 plat_gmount_cb_data_t *cp = data; 15749acbbeafSnn35248 zlog_t *zlogp = cp->pgcd_zlogp; 15759acbbeafSnn35248 struct zone_fstab *fs_ptr = *cp->pgcd_fs_tab; 15769acbbeafSnn35248 int num_fs = *cp->pgcd_num_fs; 15779acbbeafSnn35248 struct zone_fstab *fsp, *tmp_ptr; 15789acbbeafSnn35248 15799acbbeafSnn35248 num_fs++; 15809acbbeafSnn35248 if ((tmp_ptr = realloc(fs_ptr, num_fs * sizeof (*tmp_ptr))) == NULL) { 15819acbbeafSnn35248 zerror(zlogp, B_TRUE, "memory allocation failed"); 15829acbbeafSnn35248 return (-1); 15839acbbeafSnn35248 } 15849acbbeafSnn35248 15859acbbeafSnn35248 fs_ptr = tmp_ptr; 15869acbbeafSnn35248 fsp = &fs_ptr[num_fs - 1]; 15879acbbeafSnn35248 15889acbbeafSnn35248 /* update the callback struct passed in */ 15899acbbeafSnn35248 *cp->pgcd_fs_tab = fs_ptr; 15909acbbeafSnn35248 *cp->pgcd_num_fs = num_fs; 15919acbbeafSnn35248 15929acbbeafSnn35248 fsp->zone_fs_raw[0] = '\0'; 15939acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_special, spec, 15949acbbeafSnn35248 sizeof (fsp->zone_fs_special)); 15959acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_dir, dir, sizeof (fsp->zone_fs_dir)); 15969acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_type, fstype, sizeof (fsp->zone_fs_type)); 15979acbbeafSnn35248 fsp->zone_fs_options = NULL; 1598fa3d7ae1Sedp if ((opt != NULL) && 1599fa3d7ae1Sedp (zonecfg_add_fs_option(fsp, (char *)opt) != Z_OK)) { 16009acbbeafSnn35248 zerror(zlogp, B_FALSE, "error adding property"); 16019acbbeafSnn35248 return (-1); 16029acbbeafSnn35248 } 16039acbbeafSnn35248 16049acbbeafSnn35248 return (0); 16059acbbeafSnn35248 } 16069acbbeafSnn35248 16079acbbeafSnn35248 static int 16089acbbeafSnn35248 mount_filesystems_ipdent(zone_dochandle_t handle, zlog_t *zlogp, 16099acbbeafSnn35248 struct zone_fstab **fs_tabp, int *num_fsp) 16109acbbeafSnn35248 { 16119acbbeafSnn35248 struct zone_fstab *tmp_ptr, *fs_ptr, *fsp, fstab; 16129acbbeafSnn35248 int num_fs; 16139acbbeafSnn35248 16149acbbeafSnn35248 num_fs = *num_fsp; 16159acbbeafSnn35248 fs_ptr = *fs_tabp; 16169acbbeafSnn35248 16179acbbeafSnn35248 if (zonecfg_setipdent(handle) != Z_OK) { 16189acbbeafSnn35248 zerror(zlogp, B_FALSE, "invalid configuration"); 16199acbbeafSnn35248 return (-1); 16209acbbeafSnn35248 } 16219acbbeafSnn35248 while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 16229acbbeafSnn35248 num_fs++; 16239acbbeafSnn35248 if ((tmp_ptr = realloc(fs_ptr, 16249acbbeafSnn35248 num_fs * sizeof (*tmp_ptr))) == NULL) { 16259acbbeafSnn35248 zerror(zlogp, B_TRUE, "memory allocation failed"); 16269acbbeafSnn35248 (void) zonecfg_endipdent(handle); 16279acbbeafSnn35248 return (-1); 16289acbbeafSnn35248 } 16299acbbeafSnn35248 16309acbbeafSnn35248 /* update the pointers passed in */ 16319acbbeafSnn35248 *fs_tabp = tmp_ptr; 16329acbbeafSnn35248 *num_fsp = num_fs; 16339acbbeafSnn35248 16349acbbeafSnn35248 /* 16359acbbeafSnn35248 * IPDs logically only have a mount point; all other properties 16369acbbeafSnn35248 * are implied. 16379acbbeafSnn35248 */ 16389acbbeafSnn35248 fs_ptr = tmp_ptr; 16399acbbeafSnn35248 fsp = &fs_ptr[num_fs - 1]; 16409acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_dir, 16419acbbeafSnn35248 fstab.zone_fs_dir, sizeof (fsp->zone_fs_dir)); 16429acbbeafSnn35248 fsp->zone_fs_special[0] = '\0'; 16439acbbeafSnn35248 fsp->zone_fs_raw[0] = '\0'; 16449acbbeafSnn35248 fsp->zone_fs_type[0] = '\0'; 16459acbbeafSnn35248 fsp->zone_fs_options = NULL; 16469acbbeafSnn35248 } 16479acbbeafSnn35248 (void) zonecfg_endipdent(handle); 16489acbbeafSnn35248 return (0); 16499acbbeafSnn35248 } 16509acbbeafSnn35248 16519acbbeafSnn35248 static int 16529acbbeafSnn35248 mount_filesystems_fsent(zone_dochandle_t handle, zlog_t *zlogp, 16536cfd72c6Sgjelinek struct zone_fstab **fs_tabp, int *num_fsp, zone_mnt_t mount_cmd) 16549acbbeafSnn35248 { 16559acbbeafSnn35248 struct zone_fstab *tmp_ptr, *fs_ptr, *fsp, fstab; 16569acbbeafSnn35248 int num_fs; 16579acbbeafSnn35248 16589acbbeafSnn35248 num_fs = *num_fsp; 16599acbbeafSnn35248 fs_ptr = *fs_tabp; 16609acbbeafSnn35248 16619acbbeafSnn35248 if (zonecfg_setfsent(handle) != Z_OK) { 16629acbbeafSnn35248 zerror(zlogp, B_FALSE, "invalid configuration"); 16639acbbeafSnn35248 return (-1); 16649acbbeafSnn35248 } 16659acbbeafSnn35248 while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 16669acbbeafSnn35248 /* 16679acbbeafSnn35248 * ZFS filesystems will not be accessible under an alternate 16689acbbeafSnn35248 * root, since the pool will not be known. Ignore them in this 16699acbbeafSnn35248 * case. 16709acbbeafSnn35248 */ 16716cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd) && 16726cfd72c6Sgjelinek strcmp(fstab.zone_fs_type, MNTTYPE_ZFS) == 0) 16739acbbeafSnn35248 continue; 16749acbbeafSnn35248 16759acbbeafSnn35248 num_fs++; 16769acbbeafSnn35248 if ((tmp_ptr = realloc(fs_ptr, 16779acbbeafSnn35248 num_fs * sizeof (*tmp_ptr))) == NULL) { 16789acbbeafSnn35248 zerror(zlogp, B_TRUE, "memory allocation failed"); 16799acbbeafSnn35248 (void) zonecfg_endfsent(handle); 16809acbbeafSnn35248 return (-1); 16819acbbeafSnn35248 } 16829acbbeafSnn35248 /* update the pointers passed in */ 16839acbbeafSnn35248 *fs_tabp = tmp_ptr; 16849acbbeafSnn35248 *num_fsp = num_fs; 16859acbbeafSnn35248 16869acbbeafSnn35248 fs_ptr = tmp_ptr; 16879acbbeafSnn35248 fsp = &fs_ptr[num_fs - 1]; 16889acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_dir, 16899acbbeafSnn35248 fstab.zone_fs_dir, sizeof (fsp->zone_fs_dir)); 16909acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_raw, fstab.zone_fs_raw, 16919acbbeafSnn35248 sizeof (fsp->zone_fs_raw)); 16929acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_type, fstab.zone_fs_type, 16939acbbeafSnn35248 sizeof (fsp->zone_fs_type)); 16949acbbeafSnn35248 fsp->zone_fs_options = fstab.zone_fs_options; 1695fa3d7ae1Sedp 1696fa3d7ae1Sedp /* 1697fa3d7ae1Sedp * For all lofs mounts, make sure that the 'special' 1698fa3d7ae1Sedp * entry points inside the alternate root. The 1699fa3d7ae1Sedp * source path for a lofs mount in a given zone needs 1700fa3d7ae1Sedp * to be relative to the root of the boot environment 1701fa3d7ae1Sedp * that contains the zone. Note that we don't do this 1702fa3d7ae1Sedp * for non-lofs mounts since they will have a device 1703fa3d7ae1Sedp * as a backing store and device paths must always be 1704fa3d7ae1Sedp * specified relative to the current boot environment. 1705fa3d7ae1Sedp */ 1706fa3d7ae1Sedp fsp->zone_fs_special[0] = '\0'; 1707fa3d7ae1Sedp if (strcmp(fsp->zone_fs_type, MNTTYPE_LOFS) == 0) { 1708fa3d7ae1Sedp (void) strlcat(fsp->zone_fs_special, zonecfg_get_root(), 1709fa3d7ae1Sedp sizeof (fsp->zone_fs_special)); 1710fa3d7ae1Sedp } 1711fa3d7ae1Sedp (void) strlcat(fsp->zone_fs_special, fstab.zone_fs_special, 1712fa3d7ae1Sedp sizeof (fsp->zone_fs_special)); 17139acbbeafSnn35248 } 17149acbbeafSnn35248 (void) zonecfg_endfsent(handle); 17159acbbeafSnn35248 return (0); 17169acbbeafSnn35248 } 17179acbbeafSnn35248 17187c478bd9Sstevel@tonic-gate static int 17196cfd72c6Sgjelinek mount_filesystems(zlog_t *zlogp, zone_mnt_t mount_cmd) 17207c478bd9Sstevel@tonic-gate { 17217c478bd9Sstevel@tonic-gate char rootpath[MAXPATHLEN]; 17227c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 17239acbbeafSnn35248 char brand[MAXNAMELEN]; 172416bca938Svp157776 char luroot[MAXPATHLEN]; 17259acbbeafSnn35248 int i, num_fs = 0; 17269acbbeafSnn35248 struct zone_fstab *fs_ptr = NULL; 17277c478bd9Sstevel@tonic-gate zone_dochandle_t handle = NULL; 17287c478bd9Sstevel@tonic-gate zone_state_t zstate; 1729123807fbSedp brand_handle_t bh; 17309acbbeafSnn35248 plat_gmount_cb_data_t cb; 17317c478bd9Sstevel@tonic-gate 17327c478bd9Sstevel@tonic-gate if (zone_get_state(zone_name, &zstate) != Z_OK || 1733108322fbScarlsonj (zstate != ZONE_STATE_READY && zstate != ZONE_STATE_MOUNTED)) { 17347c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 1735108322fbScarlsonj "zone must be in '%s' or '%s' state to mount file-systems", 1736108322fbScarlsonj zone_state_str(ZONE_STATE_READY), 1737108322fbScarlsonj zone_state_str(ZONE_STATE_MOUNTED)); 17387c478bd9Sstevel@tonic-gate goto bad; 17397c478bd9Sstevel@tonic-gate } 17407c478bd9Sstevel@tonic-gate 17417c478bd9Sstevel@tonic-gate if (zone_get_zonepath(zone_name, zonepath, sizeof (zonepath)) != Z_OK) { 17427c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to determine zone path"); 17437c478bd9Sstevel@tonic-gate goto bad; 17447c478bd9Sstevel@tonic-gate } 17457c478bd9Sstevel@tonic-gate 17467c478bd9Sstevel@tonic-gate if (zone_get_rootpath(zone_name, rootpath, sizeof (rootpath)) != Z_OK) { 17477c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to determine zone root"); 17487c478bd9Sstevel@tonic-gate goto bad; 17497c478bd9Sstevel@tonic-gate } 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 1752ffbafc53Scomay zerror(zlogp, B_TRUE, "getting zone configuration handle"); 17537c478bd9Sstevel@tonic-gate goto bad; 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK || 17567c478bd9Sstevel@tonic-gate zonecfg_setfsent(handle) != Z_OK) { 17577c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "invalid configuration"); 17587c478bd9Sstevel@tonic-gate goto bad; 17597c478bd9Sstevel@tonic-gate } 17607c478bd9Sstevel@tonic-gate 17610679f794S /* 1762*e5816e35SEdward Pilatowicz * If we are mounting the zone, then we must always use the default 17630679f794S * brand global mounts. 17640679f794S */ 17650679f794S if (ALT_MOUNT(mount_cmd)) { 1766*e5816e35SEdward Pilatowicz (void) strlcpy(brand, default_brand, sizeof (brand)); 17670679f794S } else { 176862868012SSteve Lawrence (void) strlcpy(brand, brand_name, sizeof (brand)); 17690679f794S } 17700679f794S 17719acbbeafSnn35248 /* Get a handle to the brand info for this zone */ 17720679f794S if ((bh = brand_open(brand)) == NULL) { 17739acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 1774e767a340Sgjelinek zonecfg_fini_handle(handle); 17759acbbeafSnn35248 return (-1); 17769acbbeafSnn35248 } 17779acbbeafSnn35248 17789acbbeafSnn35248 /* 17799acbbeafSnn35248 * Get the list of global filesystems to mount from the brand 17809acbbeafSnn35248 * configuration. 17819acbbeafSnn35248 */ 17829acbbeafSnn35248 cb.pgcd_zlogp = zlogp; 17839acbbeafSnn35248 cb.pgcd_fs_tab = &fs_ptr; 17849acbbeafSnn35248 cb.pgcd_num_fs = &num_fs; 1785123807fbSedp if (brand_platform_iter_gmounts(bh, zonepath, 17869acbbeafSnn35248 plat_gmount_cb, &cb) != 0) { 17879acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to mount filesystems"); 1788123807fbSedp brand_close(bh); 1789e767a340Sgjelinek zonecfg_fini_handle(handle); 17909acbbeafSnn35248 return (-1); 17919acbbeafSnn35248 } 1792123807fbSedp brand_close(bh); 17939acbbeafSnn35248 17947c478bd9Sstevel@tonic-gate /* 17957c478bd9Sstevel@tonic-gate * Iterate through the rest of the filesystems, first the IPDs, then 17967c478bd9Sstevel@tonic-gate * the general FSs. Sort them all, then mount them in sorted order. 17977c478bd9Sstevel@tonic-gate * This is to make sure the higher level directories (e.g., /usr) 17987c478bd9Sstevel@tonic-gate * get mounted before any beneath them (e.g., /usr/local). 17997c478bd9Sstevel@tonic-gate */ 18009acbbeafSnn35248 if (mount_filesystems_ipdent(handle, zlogp, &fs_ptr, &num_fs) != 0) 18017c478bd9Sstevel@tonic-gate goto bad; 18027c478bd9Sstevel@tonic-gate 18039acbbeafSnn35248 if (mount_filesystems_fsent(handle, zlogp, &fs_ptr, &num_fs, 18049acbbeafSnn35248 mount_cmd) != 0) 18057c478bd9Sstevel@tonic-gate goto bad; 1806fa9e4066Sahrens 18077c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 18087c478bd9Sstevel@tonic-gate handle = NULL; 18097c478bd9Sstevel@tonic-gate 1810108322fbScarlsonj /* 18119acbbeafSnn35248 * Normally when we mount a zone all the zone filesystems 18129acbbeafSnn35248 * get mounted relative to rootpath, which is usually 18139acbbeafSnn35248 * <zonepath>/root. But when mounting a zone for administration 18149acbbeafSnn35248 * purposes via the zone "mount" state, build_mounted_pre_var() 18159acbbeafSnn35248 * updates rootpath to be <zonepath>/lu/a so we'll mount all 18169acbbeafSnn35248 * the zones filesystems there instead. 18179acbbeafSnn35248 * 18189acbbeafSnn35248 * build_mounted_pre_var() and build_mounted_post_var() will 18199acbbeafSnn35248 * also do some extra work to create directories and lofs mount 18209acbbeafSnn35248 * a bunch of global zone file system paths into <zonepath>/lu. 18219acbbeafSnn35248 * 18229acbbeafSnn35248 * This allows us to be able to enter the zone (now rooted at 18239acbbeafSnn35248 * <zonepath>/lu) and run the upgrade/patch tools that are in the 18249acbbeafSnn35248 * global zone and have them upgrade the to-be-modified zone's 18259acbbeafSnn35248 * files mounted on /a. (Which mirrors the existing standard 18269acbbeafSnn35248 * upgrade environment.) 18279acbbeafSnn35248 * 18289acbbeafSnn35248 * There is of course one catch. When doing the upgrade 18299acbbeafSnn35248 * we need <zoneroot>/lu/dev to be the /dev filesystem 18309acbbeafSnn35248 * for the zone and we don't want to have any /dev filesystem 18319acbbeafSnn35248 * mounted at <zoneroot>/lu/a/dev. Since /dev is specified 18329acbbeafSnn35248 * as a normal zone filesystem by default we'll try to mount 18339acbbeafSnn35248 * it at <zoneroot>/lu/a/dev, so we have to detect this 18349acbbeafSnn35248 * case and instead mount it at <zoneroot>/lu/dev. 18359acbbeafSnn35248 * 18369acbbeafSnn35248 * All this work is done in three phases: 1837f4368d3dSvp157776 * 1) Create and populate lu directory (build_mounted_pre_var()). 1838f4368d3dSvp157776 * 2) Mount the required filesystems as per the zone configuration. 1839f4368d3dSvp157776 * 3) Set up the rest of the scratch zone environment 1840f4368d3dSvp157776 * (build_mounted_post_var()). 1841108322fbScarlsonj */ 18426cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd) && !build_mounted_pre_var(zlogp, 184316bca938Svp157776 rootpath, sizeof (rootpath), zonepath, luroot, sizeof (luroot))) 1844108322fbScarlsonj goto bad; 1845108322fbScarlsonj 18467c478bd9Sstevel@tonic-gate qsort(fs_ptr, num_fs, sizeof (*fs_ptr), fs_compare); 18479acbbeafSnn35248 18487c478bd9Sstevel@tonic-gate for (i = 0; i < num_fs; i++) { 18496cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd) && 18509acbbeafSnn35248 strcmp(fs_ptr[i].zone_fs_dir, "/dev") == 0) { 18519acbbeafSnn35248 size_t slen = strlen(rootpath) - 2; 18529acbbeafSnn35248 18539acbbeafSnn35248 /* 18549acbbeafSnn35248 * By default we'll try to mount /dev as /a/dev 18559acbbeafSnn35248 * but /dev is special and always goes at the top 18569acbbeafSnn35248 * so strip the trailing '/a' from the rootpath. 18579acbbeafSnn35248 */ 18589acbbeafSnn35248 assert(strcmp(&rootpath[slen], "/a") == 0); 18599acbbeafSnn35248 rootpath[slen] = '\0'; 18600679f794S if (mount_one(zlogp, &fs_ptr[i], rootpath, mount_cmd) 18610679f794S != 0) 18629acbbeafSnn35248 goto bad; 18639acbbeafSnn35248 rootpath[slen] = '/'; 18649acbbeafSnn35248 continue; 18659acbbeafSnn35248 } 18660679f794S if (mount_one(zlogp, &fs_ptr[i], rootpath, mount_cmd) != 0) 18677c478bd9Sstevel@tonic-gate goto bad; 18687c478bd9Sstevel@tonic-gate } 18696cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd) && 18706cfd72c6Sgjelinek !build_mounted_post_var(zlogp, mount_cmd, rootpath, luroot)) 1871f4368d3dSvp157776 goto bad; 187245916cd2Sjpk 187345916cd2Sjpk /* 187445916cd2Sjpk * For Trusted Extensions cross-mount each lower level /export/home 187545916cd2Sjpk */ 18766cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT && 18776cfd72c6Sgjelinek tsol_mounts(zlogp, zone_name, rootpath) != 0) 187845916cd2Sjpk goto bad; 187945916cd2Sjpk 18807c478bd9Sstevel@tonic-gate free_fs_data(fs_ptr, num_fs); 18817c478bd9Sstevel@tonic-gate 18827c478bd9Sstevel@tonic-gate /* 18837c478bd9Sstevel@tonic-gate * Everything looks fine. 18847c478bd9Sstevel@tonic-gate */ 18857c478bd9Sstevel@tonic-gate return (0); 18867c478bd9Sstevel@tonic-gate 18877c478bd9Sstevel@tonic-gate bad: 18887c478bd9Sstevel@tonic-gate if (handle != NULL) 18897c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 18907c478bd9Sstevel@tonic-gate free_fs_data(fs_ptr, num_fs); 18917c478bd9Sstevel@tonic-gate return (-1); 18927c478bd9Sstevel@tonic-gate } 18937c478bd9Sstevel@tonic-gate 18947c478bd9Sstevel@tonic-gate /* caller makes sure neither parameter is NULL */ 18957c478bd9Sstevel@tonic-gate static int 18967c478bd9Sstevel@tonic-gate addr2netmask(char *prefixstr, int maxprefixlen, uchar_t *maskstr) 18977c478bd9Sstevel@tonic-gate { 18987c478bd9Sstevel@tonic-gate int prefixlen; 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate prefixlen = atoi(prefixstr); 19017c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > maxprefixlen) 19027c478bd9Sstevel@tonic-gate return (1); 19037c478bd9Sstevel@tonic-gate while (prefixlen > 0) { 19047c478bd9Sstevel@tonic-gate if (prefixlen >= 8) { 19057c478bd9Sstevel@tonic-gate *maskstr++ = 0xFF; 19067c478bd9Sstevel@tonic-gate prefixlen -= 8; 19077c478bd9Sstevel@tonic-gate continue; 19087c478bd9Sstevel@tonic-gate } 19097c478bd9Sstevel@tonic-gate *maskstr |= 1 << (8 - prefixlen); 19107c478bd9Sstevel@tonic-gate prefixlen--; 19117c478bd9Sstevel@tonic-gate } 19127c478bd9Sstevel@tonic-gate return (0); 19137c478bd9Sstevel@tonic-gate } 19147c478bd9Sstevel@tonic-gate 19157c478bd9Sstevel@tonic-gate /* 19167c478bd9Sstevel@tonic-gate * Tear down all interfaces belonging to the given zone. This should 19177c478bd9Sstevel@tonic-gate * be called with the zone in a state other than "running", so that 19187c478bd9Sstevel@tonic-gate * interfaces can't be assigned to the zone after this returns. 19197c478bd9Sstevel@tonic-gate * 19207c478bd9Sstevel@tonic-gate * If anything goes wrong, log an error message and return an error. 19217c478bd9Sstevel@tonic-gate */ 19227c478bd9Sstevel@tonic-gate static int 1923f4b3ec61Sdh155122 unconfigure_shared_network_interfaces(zlog_t *zlogp, zoneid_t zone_id) 19247c478bd9Sstevel@tonic-gate { 19257c478bd9Sstevel@tonic-gate struct lifnum lifn; 19267c478bd9Sstevel@tonic-gate struct lifconf lifc; 19277c478bd9Sstevel@tonic-gate struct lifreq *lifrp, lifrl; 19287c478bd9Sstevel@tonic-gate int64_t lifc_flags = LIFC_NOXMIT | LIFC_ALLZONES; 19297c478bd9Sstevel@tonic-gate int num_ifs, s, i, ret_code = 0; 19307c478bd9Sstevel@tonic-gate uint_t bufsize; 19317c478bd9Sstevel@tonic-gate char *buf = NULL; 19327c478bd9Sstevel@tonic-gate 19337c478bd9Sstevel@tonic-gate if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { 19347c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "could not get socket"); 19357c478bd9Sstevel@tonic-gate ret_code = -1; 19367c478bd9Sstevel@tonic-gate goto bad; 19377c478bd9Sstevel@tonic-gate } 19387c478bd9Sstevel@tonic-gate lifn.lifn_family = AF_UNSPEC; 19397c478bd9Sstevel@tonic-gate lifn.lifn_flags = (int)lifc_flags; 19407c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFNUM, (char *)&lifn) < 0) { 19417c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 1942f4b3ec61Sdh155122 "could not determine number of network interfaces"); 19437c478bd9Sstevel@tonic-gate ret_code = -1; 19447c478bd9Sstevel@tonic-gate goto bad; 19457c478bd9Sstevel@tonic-gate } 19467c478bd9Sstevel@tonic-gate num_ifs = lifn.lifn_count; 19477c478bd9Sstevel@tonic-gate bufsize = num_ifs * sizeof (struct lifreq); 19487c478bd9Sstevel@tonic-gate if ((buf = malloc(bufsize)) == NULL) { 19497c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "memory allocation failed"); 19507c478bd9Sstevel@tonic-gate ret_code = -1; 19517c478bd9Sstevel@tonic-gate goto bad; 19527c478bd9Sstevel@tonic-gate } 19537c478bd9Sstevel@tonic-gate lifc.lifc_family = AF_UNSPEC; 19547c478bd9Sstevel@tonic-gate lifc.lifc_flags = (int)lifc_flags; 19557c478bd9Sstevel@tonic-gate lifc.lifc_len = bufsize; 19567c478bd9Sstevel@tonic-gate lifc.lifc_buf = buf; 19577c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFCONF, (char *)&lifc) < 0) { 1958f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "could not get configured network " 1959f4b3ec61Sdh155122 "interfaces"); 19607c478bd9Sstevel@tonic-gate ret_code = -1; 19617c478bd9Sstevel@tonic-gate goto bad; 19627c478bd9Sstevel@tonic-gate } 19637c478bd9Sstevel@tonic-gate lifrp = lifc.lifc_req; 19647c478bd9Sstevel@tonic-gate for (i = lifc.lifc_len / sizeof (struct lifreq); i > 0; i--, lifrp++) { 19657c478bd9Sstevel@tonic-gate (void) close(s); 19667c478bd9Sstevel@tonic-gate if ((s = socket(lifrp->lifr_addr.ss_family, SOCK_DGRAM, 0)) < 19677c478bd9Sstevel@tonic-gate 0) { 19687c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not get socket", 19697c478bd9Sstevel@tonic-gate lifrl.lifr_name); 19707c478bd9Sstevel@tonic-gate ret_code = -1; 19717c478bd9Sstevel@tonic-gate continue; 19727c478bd9Sstevel@tonic-gate } 19737c478bd9Sstevel@tonic-gate (void) memset(&lifrl, 0, sizeof (lifrl)); 19747c478bd9Sstevel@tonic-gate (void) strncpy(lifrl.lifr_name, lifrp->lifr_name, 19757c478bd9Sstevel@tonic-gate sizeof (lifrl.lifr_name)); 19767c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFZONE, (caddr_t)&lifrl) < 0) { 1977c1c0ebd5Ssl108498 if (errno == ENXIO) 1978c1c0ebd5Ssl108498 /* 1979c1c0ebd5Ssl108498 * Interface may have been removed by admin or 1980c1c0ebd5Ssl108498 * another zone halting. 1981c1c0ebd5Ssl108498 */ 1982c1c0ebd5Ssl108498 continue; 19837c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 1984c1c0ebd5Ssl108498 "%s: could not determine the zone to which this " 1985f4b3ec61Sdh155122 "network interface is bound", lifrl.lifr_name); 19867c478bd9Sstevel@tonic-gate ret_code = -1; 19877c478bd9Sstevel@tonic-gate continue; 19887c478bd9Sstevel@tonic-gate } 19897c478bd9Sstevel@tonic-gate if (lifrl.lifr_zoneid == zone_id) { 19907c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCLIFREMOVEIF, (caddr_t)&lifrl) < 0) { 19917c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 1992f4b3ec61Sdh155122 "%s: could not remove network interface", 19937c478bd9Sstevel@tonic-gate lifrl.lifr_name); 19947c478bd9Sstevel@tonic-gate ret_code = -1; 19957c478bd9Sstevel@tonic-gate continue; 19967c478bd9Sstevel@tonic-gate } 19977c478bd9Sstevel@tonic-gate } 19987c478bd9Sstevel@tonic-gate } 19997c478bd9Sstevel@tonic-gate bad: 20007c478bd9Sstevel@tonic-gate if (s > 0) 20017c478bd9Sstevel@tonic-gate (void) close(s); 20027c478bd9Sstevel@tonic-gate if (buf) 20037c478bd9Sstevel@tonic-gate free(buf); 20047c478bd9Sstevel@tonic-gate return (ret_code); 20057c478bd9Sstevel@tonic-gate } 20067c478bd9Sstevel@tonic-gate 20077c478bd9Sstevel@tonic-gate static union sockunion { 20087c478bd9Sstevel@tonic-gate struct sockaddr sa; 20097c478bd9Sstevel@tonic-gate struct sockaddr_in sin; 20107c478bd9Sstevel@tonic-gate struct sockaddr_dl sdl; 20117c478bd9Sstevel@tonic-gate struct sockaddr_in6 sin6; 20127c478bd9Sstevel@tonic-gate } so_dst, so_ifp; 20137c478bd9Sstevel@tonic-gate 20147c478bd9Sstevel@tonic-gate static struct { 20157c478bd9Sstevel@tonic-gate struct rt_msghdr hdr; 20167c478bd9Sstevel@tonic-gate char space[512]; 20177c478bd9Sstevel@tonic-gate } rtmsg; 20187c478bd9Sstevel@tonic-gate 20197c478bd9Sstevel@tonic-gate static int 20207c478bd9Sstevel@tonic-gate salen(struct sockaddr *sa) 20217c478bd9Sstevel@tonic-gate { 20227c478bd9Sstevel@tonic-gate switch (sa->sa_family) { 20237c478bd9Sstevel@tonic-gate case AF_INET: 20247c478bd9Sstevel@tonic-gate return (sizeof (struct sockaddr_in)); 20257c478bd9Sstevel@tonic-gate case AF_LINK: 20267c478bd9Sstevel@tonic-gate return (sizeof (struct sockaddr_dl)); 20277c478bd9Sstevel@tonic-gate case AF_INET6: 20287c478bd9Sstevel@tonic-gate return (sizeof (struct sockaddr_in6)); 20297c478bd9Sstevel@tonic-gate default: 20307c478bd9Sstevel@tonic-gate return (sizeof (struct sockaddr)); 20317c478bd9Sstevel@tonic-gate } 20327c478bd9Sstevel@tonic-gate } 20337c478bd9Sstevel@tonic-gate 20347c478bd9Sstevel@tonic-gate #define ROUNDUP_LONG(a) \ 20357c478bd9Sstevel@tonic-gate ((a) > 0 ? (1 + (((a) - 1) | (sizeof (long) - 1))) : sizeof (long)) 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate /* 20387c478bd9Sstevel@tonic-gate * Look up which zone is using a given IP address. The address in question 20397c478bd9Sstevel@tonic-gate * is expected to have been stuffed into the structure to which lifr points 20407c478bd9Sstevel@tonic-gate * via a previous SIOCGLIFADDR ioctl(). 20417c478bd9Sstevel@tonic-gate * 20427c478bd9Sstevel@tonic-gate * This is done using black router socket magic. 20437c478bd9Sstevel@tonic-gate * 20447c478bd9Sstevel@tonic-gate * Return the name of the zone on success or NULL on failure. 20457c478bd9Sstevel@tonic-gate * 20467c478bd9Sstevel@tonic-gate * This is a lot of code for a simple task; a new ioctl request to take care 20477c478bd9Sstevel@tonic-gate * of this might be a useful RFE. 20487c478bd9Sstevel@tonic-gate */ 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate static char * 20517c478bd9Sstevel@tonic-gate who_is_using(zlog_t *zlogp, struct lifreq *lifr) 20527c478bd9Sstevel@tonic-gate { 20537c478bd9Sstevel@tonic-gate static char answer[ZONENAME_MAX]; 20547c478bd9Sstevel@tonic-gate pid_t pid; 20557c478bd9Sstevel@tonic-gate int s, rlen, l, i; 20567c478bd9Sstevel@tonic-gate char *cp = rtmsg.space; 20577c478bd9Sstevel@tonic-gate struct sockaddr_dl *ifp = NULL; 20587c478bd9Sstevel@tonic-gate struct sockaddr *sa; 20597c478bd9Sstevel@tonic-gate char save_if_name[LIFNAMSIZ]; 20607c478bd9Sstevel@tonic-gate 20617c478bd9Sstevel@tonic-gate answer[0] = '\0'; 20627c478bd9Sstevel@tonic-gate 20637c478bd9Sstevel@tonic-gate pid = getpid(); 20647c478bd9Sstevel@tonic-gate if ((s = socket(PF_ROUTE, SOCK_RAW, 0)) < 0) { 20657c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "could not get routing socket"); 20667c478bd9Sstevel@tonic-gate return (NULL); 20677c478bd9Sstevel@tonic-gate } 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate if (lifr->lifr_addr.ss_family == AF_INET) { 20707c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 20717c478bd9Sstevel@tonic-gate 20727c478bd9Sstevel@tonic-gate so_dst.sa.sa_family = AF_INET; 20737c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)&lifr->lifr_addr; 20747c478bd9Sstevel@tonic-gate so_dst.sin.sin_addr = sin4->sin_addr; 20757c478bd9Sstevel@tonic-gate } else { 20767c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 20777c478bd9Sstevel@tonic-gate 20787c478bd9Sstevel@tonic-gate so_dst.sa.sa_family = AF_INET6; 20797c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)&lifr->lifr_addr; 20807c478bd9Sstevel@tonic-gate so_dst.sin6.sin6_addr = sin6->sin6_addr; 20817c478bd9Sstevel@tonic-gate } 20827c478bd9Sstevel@tonic-gate 20837c478bd9Sstevel@tonic-gate so_ifp.sa.sa_family = AF_LINK; 20847c478bd9Sstevel@tonic-gate 20857c478bd9Sstevel@tonic-gate (void) memset(&rtmsg, 0, sizeof (rtmsg)); 20867c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_type = RTM_GET; 20877c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_flags = RTF_UP | RTF_HOST; 20887c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_version = RTM_VERSION; 20897c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_seq = ++rts_seqno; 20907c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_addrs = RTA_IFP | RTA_DST; 20917c478bd9Sstevel@tonic-gate 20927c478bd9Sstevel@tonic-gate l = ROUNDUP_LONG(salen(&so_dst.sa)); 20937c478bd9Sstevel@tonic-gate (void) memmove(cp, &(so_dst), l); 20947c478bd9Sstevel@tonic-gate cp += l; 20957c478bd9Sstevel@tonic-gate l = ROUNDUP_LONG(salen(&so_ifp.sa)); 20967c478bd9Sstevel@tonic-gate (void) memmove(cp, &(so_ifp), l); 20977c478bd9Sstevel@tonic-gate cp += l; 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_msglen = l = cp - (char *)&rtmsg; 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate if ((rlen = write(s, &rtmsg, l)) < 0) { 21027c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "writing to routing socket"); 21037c478bd9Sstevel@tonic-gate return (NULL); 21047c478bd9Sstevel@tonic-gate } else if (rlen < (int)rtmsg.hdr.rtm_msglen) { 21057c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 21067c478bd9Sstevel@tonic-gate "write to routing socket got only %d for len\n", rlen); 21077c478bd9Sstevel@tonic-gate return (NULL); 21087c478bd9Sstevel@tonic-gate } 21097c478bd9Sstevel@tonic-gate do { 21107c478bd9Sstevel@tonic-gate l = read(s, &rtmsg, sizeof (rtmsg)); 21117c478bd9Sstevel@tonic-gate } while (l > 0 && (rtmsg.hdr.rtm_seq != rts_seqno || 21127c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_pid != pid)); 21137c478bd9Sstevel@tonic-gate if (l < 0) { 21147c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "reading from routing socket"); 21157c478bd9Sstevel@tonic-gate return (NULL); 21167c478bd9Sstevel@tonic-gate } 21177c478bd9Sstevel@tonic-gate 21187c478bd9Sstevel@tonic-gate if (rtmsg.hdr.rtm_version != RTM_VERSION) { 21197c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 21207c478bd9Sstevel@tonic-gate "routing message version %d not understood", 21217c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_version); 21227c478bd9Sstevel@tonic-gate return (NULL); 21237c478bd9Sstevel@tonic-gate } 21247c478bd9Sstevel@tonic-gate if (rtmsg.hdr.rtm_msglen != (ushort_t)l) { 21257c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "message length mismatch, " 21267c478bd9Sstevel@tonic-gate "expected %d bytes, returned %d bytes", 21277c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_msglen, l); 21287c478bd9Sstevel@tonic-gate return (NULL); 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate if (rtmsg.hdr.rtm_errno != 0) { 21317c478bd9Sstevel@tonic-gate errno = rtmsg.hdr.rtm_errno; 21327c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "RTM_GET routing socket message"); 21337c478bd9Sstevel@tonic-gate return (NULL); 21347c478bd9Sstevel@tonic-gate } 21357c478bd9Sstevel@tonic-gate if ((rtmsg.hdr.rtm_addrs & RTA_IFP) == 0) { 2136f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "network interface not found"); 21377c478bd9Sstevel@tonic-gate return (NULL); 21387c478bd9Sstevel@tonic-gate } 21397c478bd9Sstevel@tonic-gate cp = ((char *)(&rtmsg.hdr + 1)); 21407c478bd9Sstevel@tonic-gate for (i = 1; i != 0; i <<= 1) { 21417c478bd9Sstevel@tonic-gate /* LINTED E_BAD_PTR_CAST_ALIGN */ 21427c478bd9Sstevel@tonic-gate sa = (struct sockaddr *)cp; 21437c478bd9Sstevel@tonic-gate if (i != RTA_IFP) { 21447c478bd9Sstevel@tonic-gate if ((i & rtmsg.hdr.rtm_addrs) != 0) 21457c478bd9Sstevel@tonic-gate cp += ROUNDUP_LONG(salen(sa)); 21467c478bd9Sstevel@tonic-gate continue; 21477c478bd9Sstevel@tonic-gate } 21487c478bd9Sstevel@tonic-gate if (sa->sa_family == AF_LINK && 21497c478bd9Sstevel@tonic-gate ((struct sockaddr_dl *)sa)->sdl_nlen != 0) 21507c478bd9Sstevel@tonic-gate ifp = (struct sockaddr_dl *)sa; 21517c478bd9Sstevel@tonic-gate break; 21527c478bd9Sstevel@tonic-gate } 21537c478bd9Sstevel@tonic-gate if (ifp == NULL) { 2154f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "network interface could not be " 2155f4b3ec61Sdh155122 "determined"); 21567c478bd9Sstevel@tonic-gate return (NULL); 21577c478bd9Sstevel@tonic-gate } 21587c478bd9Sstevel@tonic-gate 21597c478bd9Sstevel@tonic-gate /* 21607c478bd9Sstevel@tonic-gate * We need to set the I/F name to what we got above, then do the 21617c478bd9Sstevel@tonic-gate * appropriate ioctl to get its zone name. But lifr->lifr_name is 21627c478bd9Sstevel@tonic-gate * used by the calling function to do a REMOVEIF, so if we leave the 21637c478bd9Sstevel@tonic-gate * "good" zone's I/F name in place, *that* I/F will be removed instead 21647c478bd9Sstevel@tonic-gate * of the bad one. So we save the old (bad) I/F name before over- 21657c478bd9Sstevel@tonic-gate * writing it and doing the ioctl, then restore it after the ioctl. 21667c478bd9Sstevel@tonic-gate */ 21677c478bd9Sstevel@tonic-gate (void) strlcpy(save_if_name, lifr->lifr_name, sizeof (save_if_name)); 21687c478bd9Sstevel@tonic-gate (void) strncpy(lifr->lifr_name, ifp->sdl_data, ifp->sdl_nlen); 21697c478bd9Sstevel@tonic-gate lifr->lifr_name[ifp->sdl_nlen] = '\0'; 21707c478bd9Sstevel@tonic-gate i = ioctl(s, SIOCGLIFZONE, lifr); 21717c478bd9Sstevel@tonic-gate (void) strlcpy(lifr->lifr_name, save_if_name, sizeof (save_if_name)); 21727c478bd9Sstevel@tonic-gate if (i < 0) { 21737c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 2174f4b3ec61Sdh155122 "%s: could not determine the zone network interface " 2175f4b3ec61Sdh155122 "belongs to", lifr->lifr_name); 21767c478bd9Sstevel@tonic-gate return (NULL); 21777c478bd9Sstevel@tonic-gate } 21787c478bd9Sstevel@tonic-gate if (getzonenamebyid(lifr->lifr_zoneid, answer, sizeof (answer)) < 0) 21797c478bd9Sstevel@tonic-gate (void) snprintf(answer, sizeof (answer), "%d", 21807c478bd9Sstevel@tonic-gate lifr->lifr_zoneid); 21817c478bd9Sstevel@tonic-gate 21827c478bd9Sstevel@tonic-gate if (strlen(answer) > 0) 21837c478bd9Sstevel@tonic-gate return (answer); 21847c478bd9Sstevel@tonic-gate return (NULL); 21857c478bd9Sstevel@tonic-gate } 21867c478bd9Sstevel@tonic-gate 21877c478bd9Sstevel@tonic-gate /* 21887c478bd9Sstevel@tonic-gate * Configures a single interface: a new virtual interface is added, based on 21897c478bd9Sstevel@tonic-gate * the physical interface nwiftabptr->zone_nwif_physical, with the address 21907c478bd9Sstevel@tonic-gate * specified in nwiftabptr->zone_nwif_address, for zone zone_id. Note that 21917c478bd9Sstevel@tonic-gate * the "address" can be an IPv6 address (with a /prefixlength required), an 21927c478bd9Sstevel@tonic-gate * IPv4 address (with a /prefixlength optional), or a name; for the latter, 21937c478bd9Sstevel@tonic-gate * an IPv4 name-to-address resolution will be attempted. 21947c478bd9Sstevel@tonic-gate * 21957c478bd9Sstevel@tonic-gate * If anything goes wrong, we log an detailed error message, attempt to tear 21967c478bd9Sstevel@tonic-gate * down whatever we set up and return an error. 21977c478bd9Sstevel@tonic-gate */ 21987c478bd9Sstevel@tonic-gate static int 21997c478bd9Sstevel@tonic-gate configure_one_interface(zlog_t *zlogp, zoneid_t zone_id, 2200f14f3ae7Sjv227347 struct zone_nwiftab *nwiftabptr) 22017c478bd9Sstevel@tonic-gate { 22027c478bd9Sstevel@tonic-gate struct lifreq lifr; 22037c478bd9Sstevel@tonic-gate struct sockaddr_in netmask4; 22047c478bd9Sstevel@tonic-gate struct sockaddr_in6 netmask6; 22052e481403SVamsi Nagineni struct sockaddr_storage laddr; 22067c478bd9Sstevel@tonic-gate struct in_addr in4; 22077c478bd9Sstevel@tonic-gate sa_family_t af; 22087c478bd9Sstevel@tonic-gate char *slashp = strchr(nwiftabptr->zone_nwif_address, '/'); 22097c478bd9Sstevel@tonic-gate int s; 22107c478bd9Sstevel@tonic-gate boolean_t got_netmask = B_FALSE; 2211f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India boolean_t is_loopback = B_FALSE; 22127c478bd9Sstevel@tonic-gate char addrstr4[INET_ADDRSTRLEN]; 22137c478bd9Sstevel@tonic-gate int res; 22147c478bd9Sstevel@tonic-gate 22157c478bd9Sstevel@tonic-gate res = zonecfg_valid_net_address(nwiftabptr->zone_nwif_address, &lifr); 22167c478bd9Sstevel@tonic-gate if (res != Z_OK) { 22177c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s: %s", zonecfg_strerror(res), 22187c478bd9Sstevel@tonic-gate nwiftabptr->zone_nwif_address); 22197c478bd9Sstevel@tonic-gate return (-1); 22207c478bd9Sstevel@tonic-gate } 22217c478bd9Sstevel@tonic-gate af = lifr.lifr_addr.ss_family; 22227c478bd9Sstevel@tonic-gate if (af == AF_INET) 22237c478bd9Sstevel@tonic-gate in4 = ((struct sockaddr_in *)(&lifr.lifr_addr))->sin_addr; 22247c478bd9Sstevel@tonic-gate if ((s = socket(af, SOCK_DGRAM, 0)) < 0) { 22257c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "could not get socket"); 22267c478bd9Sstevel@tonic-gate return (-1); 22277c478bd9Sstevel@tonic-gate } 22287c478bd9Sstevel@tonic-gate 22292e481403SVamsi Nagineni /* 22302e481403SVamsi Nagineni * This is a similar kind of "hack" like in addif() to get around 22312e481403SVamsi Nagineni * the problem of SIOCLIFADDIF. The problem is that this ioctl 22322e481403SVamsi Nagineni * does not include the netmask when adding a logical interface. 22332e481403SVamsi Nagineni * To get around this problem, we first add the logical interface 22342e481403SVamsi Nagineni * with a 0 address. After that, we set the netmask if provided. 22352e481403SVamsi Nagineni * Finally we set the interface address. 22362e481403SVamsi Nagineni */ 22372e481403SVamsi Nagineni laddr = lifr.lifr_addr; 22387c478bd9Sstevel@tonic-gate (void) strlcpy(lifr.lifr_name, nwiftabptr->zone_nwif_physical, 22397c478bd9Sstevel@tonic-gate sizeof (lifr.lifr_name)); 22402e481403SVamsi Nagineni (void) memset(&lifr.lifr_addr, 0, sizeof (lifr.lifr_addr)); 22412e481403SVamsi Nagineni 22427c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCLIFADDIF, (caddr_t)&lifr) < 0) { 224322321485Svp157776 /* 224422321485Svp157776 * Here, we know that the interface can't be brought up. 224522321485Svp157776 * A similar warning message was already printed out to 224622321485Svp157776 * the console by zoneadm(1M) so instead we log the 224722321485Svp157776 * message to syslog and continue. 224822321485Svp157776 */ 2249f4b3ec61Sdh155122 zerror(&logsys, B_TRUE, "WARNING: skipping network interface " 225022321485Svp157776 "'%s' which may not be present/plumbed in the " 225122321485Svp157776 "global zone.", lifr.lifr_name); 22527c478bd9Sstevel@tonic-gate (void) close(s); 225322321485Svp157776 return (Z_OK); 22547c478bd9Sstevel@tonic-gate } 22557c478bd9Sstevel@tonic-gate 22567c478bd9Sstevel@tonic-gate /* Preserve literal IPv4 address for later potential printing. */ 22577c478bd9Sstevel@tonic-gate if (af == AF_INET) 22587c478bd9Sstevel@tonic-gate (void) inet_ntop(AF_INET, &in4, addrstr4, INET_ADDRSTRLEN); 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate lifr.lifr_zoneid = zone_id; 22617c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCSLIFZONE, (caddr_t)&lifr) < 0) { 2262f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "%s: could not place network interface " 2263f4b3ec61Sdh155122 "into zone", lifr.lifr_name); 22647c478bd9Sstevel@tonic-gate goto bad; 22657c478bd9Sstevel@tonic-gate } 22667c478bd9Sstevel@tonic-gate 2267f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India /* 2268f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India * Loopback interface will use the default netmask assigned, if no 2269f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India * netmask is found. 2270f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India */ 22717c478bd9Sstevel@tonic-gate if (strcmp(nwiftabptr->zone_nwif_physical, "lo0") == 0) { 2272f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India is_loopback = B_TRUE; 2273f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India } 22747c478bd9Sstevel@tonic-gate if (af == AF_INET) { 22757c478bd9Sstevel@tonic-gate /* 22767c478bd9Sstevel@tonic-gate * The IPv4 netmask can be determined either 22777c478bd9Sstevel@tonic-gate * directly if a prefix length was supplied with 22787c478bd9Sstevel@tonic-gate * the address or via the netmasks database. Not 22797c478bd9Sstevel@tonic-gate * being able to determine it is a common failure, 22807c478bd9Sstevel@tonic-gate * but it often is not fatal to operation of the 22817c478bd9Sstevel@tonic-gate * interface. In that case, a warning will be 22827c478bd9Sstevel@tonic-gate * printed after the rest of the interface's 22837c478bd9Sstevel@tonic-gate * parameters have been configured. 22847c478bd9Sstevel@tonic-gate */ 22857c478bd9Sstevel@tonic-gate (void) memset(&netmask4, 0, sizeof (netmask4)); 22867c478bd9Sstevel@tonic-gate if (slashp != NULL) { 22877c478bd9Sstevel@tonic-gate if (addr2netmask(slashp + 1, V4_ADDR_LEN, 22887c478bd9Sstevel@tonic-gate (uchar_t *)&netmask4.sin_addr) != 0) { 22897c478bd9Sstevel@tonic-gate *slashp = '/'; 22907c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 22917c478bd9Sstevel@tonic-gate "%s: invalid prefix length in %s", 22927c478bd9Sstevel@tonic-gate lifr.lifr_name, 22937c478bd9Sstevel@tonic-gate nwiftabptr->zone_nwif_address); 22947c478bd9Sstevel@tonic-gate goto bad; 22957c478bd9Sstevel@tonic-gate } 22967c478bd9Sstevel@tonic-gate got_netmask = B_TRUE; 22977c478bd9Sstevel@tonic-gate } else if (getnetmaskbyaddr(in4, 22987c478bd9Sstevel@tonic-gate &netmask4.sin_addr) == 0) { 22997c478bd9Sstevel@tonic-gate got_netmask = B_TRUE; 23007c478bd9Sstevel@tonic-gate } 23017c478bd9Sstevel@tonic-gate if (got_netmask) { 23027c478bd9Sstevel@tonic-gate netmask4.sin_family = af; 23037c478bd9Sstevel@tonic-gate (void) memcpy(&lifr.lifr_addr, &netmask4, 23047c478bd9Sstevel@tonic-gate sizeof (netmask4)); 23057c478bd9Sstevel@tonic-gate } 23067c478bd9Sstevel@tonic-gate } else { 23077c478bd9Sstevel@tonic-gate (void) memset(&netmask6, 0, sizeof (netmask6)); 23087c478bd9Sstevel@tonic-gate if (addr2netmask(slashp + 1, V6_ADDR_LEN, 23097c478bd9Sstevel@tonic-gate (uchar_t *)&netmask6.sin6_addr) != 0) { 23107c478bd9Sstevel@tonic-gate *slashp = '/'; 23117c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 23127c478bd9Sstevel@tonic-gate "%s: invalid prefix length in %s", 23137c478bd9Sstevel@tonic-gate lifr.lifr_name, 23147c478bd9Sstevel@tonic-gate nwiftabptr->zone_nwif_address); 23157c478bd9Sstevel@tonic-gate goto bad; 23167c478bd9Sstevel@tonic-gate } 23177c478bd9Sstevel@tonic-gate got_netmask = B_TRUE; 23187c478bd9Sstevel@tonic-gate netmask6.sin6_family = af; 23197c478bd9Sstevel@tonic-gate (void) memcpy(&lifr.lifr_addr, &netmask6, 23207c478bd9Sstevel@tonic-gate sizeof (netmask6)); 23217c478bd9Sstevel@tonic-gate } 23227c478bd9Sstevel@tonic-gate if (got_netmask && 23237c478bd9Sstevel@tonic-gate ioctl(s, SIOCSLIFNETMASK, (caddr_t)&lifr) < 0) { 23247c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not set netmask", 23257c478bd9Sstevel@tonic-gate lifr.lifr_name); 23267c478bd9Sstevel@tonic-gate goto bad; 23277c478bd9Sstevel@tonic-gate } 23287c478bd9Sstevel@tonic-gate 23292e481403SVamsi Nagineni /* Set the interface address */ 23302e481403SVamsi Nagineni lifr.lifr_addr = laddr; 23317c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr) < 0) { 23327c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 23332e481403SVamsi Nagineni "%s: could not set IP address to %s", 23342e481403SVamsi Nagineni lifr.lifr_name, nwiftabptr->zone_nwif_address); 23357c478bd9Sstevel@tonic-gate goto bad; 23367c478bd9Sstevel@tonic-gate } 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) { 23397c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not get flags", 23407c478bd9Sstevel@tonic-gate lifr.lifr_name); 23417c478bd9Sstevel@tonic-gate goto bad; 23427c478bd9Sstevel@tonic-gate } 23437c478bd9Sstevel@tonic-gate lifr.lifr_flags |= IFF_UP; 23447c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCSLIFFLAGS, (caddr_t)&lifr) < 0) { 23457c478bd9Sstevel@tonic-gate int save_errno = errno; 23467c478bd9Sstevel@tonic-gate char *zone_using; 23477c478bd9Sstevel@tonic-gate 23487c478bd9Sstevel@tonic-gate /* 23497c478bd9Sstevel@tonic-gate * If we failed with something other than EADDRNOTAVAIL, 23507c478bd9Sstevel@tonic-gate * then skip to the end. Otherwise, look up our address, 23517c478bd9Sstevel@tonic-gate * then call a function to determine which zone is already 23527c478bd9Sstevel@tonic-gate * using that address. 23537c478bd9Sstevel@tonic-gate */ 23547c478bd9Sstevel@tonic-gate if (errno != EADDRNOTAVAIL) { 23557c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 2356f4b3ec61Sdh155122 "%s: could not bring network interface up", 2357f4b3ec61Sdh155122 lifr.lifr_name); 23587c478bd9Sstevel@tonic-gate goto bad; 23597c478bd9Sstevel@tonic-gate } 23607c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) { 23617c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not get address", 23627c478bd9Sstevel@tonic-gate lifr.lifr_name); 23637c478bd9Sstevel@tonic-gate goto bad; 23647c478bd9Sstevel@tonic-gate } 23657c478bd9Sstevel@tonic-gate zone_using = who_is_using(zlogp, &lifr); 23667c478bd9Sstevel@tonic-gate errno = save_errno; 23677c478bd9Sstevel@tonic-gate if (zone_using == NULL) 23687c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 2369f4b3ec61Sdh155122 "%s: could not bring network interface up", 2370f4b3ec61Sdh155122 lifr.lifr_name); 23717c478bd9Sstevel@tonic-gate else 2372f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "%s: could not bring network " 2373f4b3ec61Sdh155122 "interface up: address in use by zone '%s'", 2374f4b3ec61Sdh155122 lifr.lifr_name, zone_using); 23757c478bd9Sstevel@tonic-gate goto bad; 23767c478bd9Sstevel@tonic-gate } 23777c478bd9Sstevel@tonic-gate 2378f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India if (!got_netmask && !is_loopback) { 23797c478bd9Sstevel@tonic-gate /* 23807c478bd9Sstevel@tonic-gate * A common, but often non-fatal problem, is that the system 23817c478bd9Sstevel@tonic-gate * cannot find the netmask for an interface address. This is 23827c478bd9Sstevel@tonic-gate * often caused by it being only in /etc/inet/netmasks, but 23837c478bd9Sstevel@tonic-gate * /etc/nsswitch.conf says to use NIS or NIS+ and it's not 23847c478bd9Sstevel@tonic-gate * in that. This doesn't show up at boot because the netmask 23857c478bd9Sstevel@tonic-gate * is obtained from /etc/inet/netmasks when no network 23867c478bd9Sstevel@tonic-gate * interfaces are up, but isn't consulted when NIS/NIS+ is 23877c478bd9Sstevel@tonic-gate * available. We warn the user here that something like this 23887c478bd9Sstevel@tonic-gate * has happened and we're just running with a default and 23897c478bd9Sstevel@tonic-gate * possible incorrect netmask. 23907c478bd9Sstevel@tonic-gate */ 23917c478bd9Sstevel@tonic-gate char buffer[INET6_ADDRSTRLEN]; 23927c478bd9Sstevel@tonic-gate void *addr; 2393e11c3f44Smeem const char *nomatch = "no matching subnet found in netmasks(4)"; 23947c478bd9Sstevel@tonic-gate 23957c478bd9Sstevel@tonic-gate if (af == AF_INET) 23967c478bd9Sstevel@tonic-gate addr = &((struct sockaddr_in *) 23977c478bd9Sstevel@tonic-gate (&lifr.lifr_addr))->sin_addr; 23987c478bd9Sstevel@tonic-gate else 23997c478bd9Sstevel@tonic-gate addr = &((struct sockaddr_in6 *) 24007c478bd9Sstevel@tonic-gate (&lifr.lifr_addr))->sin6_addr; 24017c478bd9Sstevel@tonic-gate 2402e11c3f44Smeem /* 2403e11c3f44Smeem * Find out what netmask the interface is going to be using. 2404e11c3f44Smeem * If we just brought up an IPMP data address on an underlying 2405e11c3f44Smeem * interface above, the address will have already migrated, so 2406e11c3f44Smeem * the SIOCGLIFNETMASK won't be able to find it (but we need 2407e11c3f44Smeem * to bring the address up to get the actual netmask). Just 2408e11c3f44Smeem * omit printing the actual netmask in this corner-case. 2409e11c3f44Smeem */ 24107c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFNETMASK, (caddr_t)&lifr) < 0 || 2411e11c3f44Smeem inet_ntop(af, addr, buffer, sizeof (buffer)) == NULL) { 2412e11c3f44Smeem zerror(zlogp, B_FALSE, "WARNING: %s; using default.", 2413e11c3f44Smeem nomatch); 2414e11c3f44Smeem } else { 24157c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 2416e11c3f44Smeem "WARNING: %s: %s: %s; using default of %s.", 2417e11c3f44Smeem lifr.lifr_name, nomatch, addrstr4, buffer); 2418e11c3f44Smeem } 24197c478bd9Sstevel@tonic-gate } 24207c478bd9Sstevel@tonic-gate 2421de860bd9Sgfaden /* 2422de860bd9Sgfaden * If a default router was specified for this interface 2423de860bd9Sgfaden * set the route now. Ignore if already set. 2424de860bd9Sgfaden */ 2425de860bd9Sgfaden if (strlen(nwiftabptr->zone_nwif_defrouter) > 0) { 2426de860bd9Sgfaden int status; 2427de860bd9Sgfaden char *argv[7]; 2428de860bd9Sgfaden 2429de860bd9Sgfaden argv[0] = "route"; 2430de860bd9Sgfaden argv[1] = "add"; 2431de860bd9Sgfaden argv[2] = "-ifp"; 2432de860bd9Sgfaden argv[3] = nwiftabptr->zone_nwif_physical; 2433de860bd9Sgfaden argv[4] = "default"; 2434de860bd9Sgfaden argv[5] = nwiftabptr->zone_nwif_defrouter; 2435de860bd9Sgfaden argv[6] = NULL; 2436de860bd9Sgfaden 2437de860bd9Sgfaden status = forkexec(zlogp, "/usr/sbin/route", argv); 2438de860bd9Sgfaden if (status != 0 && status != EEXIST) 2439de860bd9Sgfaden zerror(zlogp, B_FALSE, "Unable to set route for " 2440de860bd9Sgfaden "interface %s to %s\n", 2441de860bd9Sgfaden nwiftabptr->zone_nwif_physical, 2442de860bd9Sgfaden nwiftabptr->zone_nwif_defrouter); 2443de860bd9Sgfaden } 2444de860bd9Sgfaden 24457c478bd9Sstevel@tonic-gate (void) close(s); 24467c478bd9Sstevel@tonic-gate return (Z_OK); 24477c478bd9Sstevel@tonic-gate bad: 24487c478bd9Sstevel@tonic-gate (void) ioctl(s, SIOCLIFREMOVEIF, (caddr_t)&lifr); 24497c478bd9Sstevel@tonic-gate (void) close(s); 24507c478bd9Sstevel@tonic-gate return (-1); 24517c478bd9Sstevel@tonic-gate } 24527c478bd9Sstevel@tonic-gate 24537c478bd9Sstevel@tonic-gate /* 24547c478bd9Sstevel@tonic-gate * Sets up network interfaces based on information from the zone configuration. 2455f14f3ae7Sjv227347 * IPv4 and IPv6 loopback interfaces are set up "for free", modeling the global 2456f14f3ae7Sjv227347 * system. 24577c478bd9Sstevel@tonic-gate * 24587c478bd9Sstevel@tonic-gate * If anything goes wrong, we log a general error message, attempt to tear down 24597c478bd9Sstevel@tonic-gate * whatever we set up, and return an error. 24607c478bd9Sstevel@tonic-gate */ 24617c478bd9Sstevel@tonic-gate static int 2462f4b3ec61Sdh155122 configure_shared_network_interfaces(zlog_t *zlogp) 24637c478bd9Sstevel@tonic-gate { 24647c478bd9Sstevel@tonic-gate zone_dochandle_t handle; 24657c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab, loopback_iftab; 24667c478bd9Sstevel@tonic-gate zoneid_t zoneid; 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate if ((zoneid = getzoneidbyname(zone_name)) == ZONE_ID_UNDEFINED) { 24697c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to get zoneid"); 24707c478bd9Sstevel@tonic-gate return (-1); 24717c478bd9Sstevel@tonic-gate } 24727c478bd9Sstevel@tonic-gate 24737c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 24747c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "getting zone configuration handle"); 24757c478bd9Sstevel@tonic-gate return (-1); 24767c478bd9Sstevel@tonic-gate } 24777c478bd9Sstevel@tonic-gate if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 24787c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "invalid configuration"); 24797c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 24807c478bd9Sstevel@tonic-gate return (-1); 24817c478bd9Sstevel@tonic-gate } 24827c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) == Z_OK) { 24837c478bd9Sstevel@tonic-gate for (;;) { 24847c478bd9Sstevel@tonic-gate if (zonecfg_getnwifent(handle, &nwiftab) != Z_OK) 24857c478bd9Sstevel@tonic-gate break; 2486f14f3ae7Sjv227347 if (configure_one_interface(zlogp, zoneid, &nwiftab) != 24877c478bd9Sstevel@tonic-gate Z_OK) { 24887c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 24897c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 24907c478bd9Sstevel@tonic-gate return (-1); 24917c478bd9Sstevel@tonic-gate } 24927c478bd9Sstevel@tonic-gate } 24937c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 24947c478bd9Sstevel@tonic-gate } 24957c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 2496fdb7141fSgfaden if (is_system_labeled()) { 2497fdb7141fSgfaden /* 2498fdb7141fSgfaden * Labeled zones share the loopback interface 2499fdb7141fSgfaden * so it is not plumbed for shared stack instances. 2500fdb7141fSgfaden */ 2501fdb7141fSgfaden return (0); 2502fdb7141fSgfaden } 25037c478bd9Sstevel@tonic-gate (void) strlcpy(loopback_iftab.zone_nwif_physical, "lo0", 25047c478bd9Sstevel@tonic-gate sizeof (loopback_iftab.zone_nwif_physical)); 25057c478bd9Sstevel@tonic-gate (void) strlcpy(loopback_iftab.zone_nwif_address, "127.0.0.1", 25067c478bd9Sstevel@tonic-gate sizeof (loopback_iftab.zone_nwif_address)); 2507442d3e9eSgfaden loopback_iftab.zone_nwif_defrouter[0] = '\0'; 2508f14f3ae7Sjv227347 if (configure_one_interface(zlogp, zoneid, &loopback_iftab) != Z_OK) 25097c478bd9Sstevel@tonic-gate return (-1); 2510f14f3ae7Sjv227347 2511f14f3ae7Sjv227347 /* Always plumb up the IPv6 loopback interface. */ 25127c478bd9Sstevel@tonic-gate (void) strlcpy(loopback_iftab.zone_nwif_address, "::1/128", 25137c478bd9Sstevel@tonic-gate sizeof (loopback_iftab.zone_nwif_address)); 2514f14f3ae7Sjv227347 if (configure_one_interface(zlogp, zoneid, &loopback_iftab) != Z_OK) 25157c478bd9Sstevel@tonic-gate return (-1); 25167c478bd9Sstevel@tonic-gate return (0); 25177c478bd9Sstevel@tonic-gate } 25187c478bd9Sstevel@tonic-gate 251989b1c373Smeem static void 252089b1c373Smeem zdlerror(zlog_t *zlogp, dladm_status_t err, const char *dlname, const char *str) 252189b1c373Smeem { 252289b1c373Smeem char errmsg[DLADM_STRSIZE]; 252389b1c373Smeem 252489b1c373Smeem (void) dladm_status2str(err, errmsg); 252589b1c373Smeem zerror(zlogp, B_FALSE, "%s '%s': %s", str, dlname, errmsg); 252689b1c373Smeem } 252789b1c373Smeem 2528f4b3ec61Sdh155122 static int 25292b24ab6bSSebastien Roy add_datalink(zlog_t *zlogp, char *zone_name, datalink_id_t linkid, char *dlname) 2530f4b3ec61Sdh155122 { 253189b1c373Smeem dladm_status_t err; 253289b1c373Smeem 2533f4b3ec61Sdh155122 /* First check if it's in use by global zone. */ 2534f4b3ec61Sdh155122 if (zonecfg_ifname_exists(AF_INET, dlname) || 2535f4b3ec61Sdh155122 zonecfg_ifname_exists(AF_INET6, dlname)) { 253689b1c373Smeem zerror(zlogp, B_FALSE, "WARNING: skipping network interface " 253789b1c373Smeem "'%s' which is used in the global zone", dlname); 2538f4b3ec61Sdh155122 return (-1); 2539f4b3ec61Sdh155122 } 2540f4b3ec61Sdh155122 2541d62bc4baSyz147064 /* Set zoneid of this link. */ 25422b24ab6bSSebastien Roy err = dladm_set_linkprop(dld_handle, linkid, "zone", &zone_name, 1, 25432b24ab6bSSebastien Roy DLADM_OPT_ACTIVE); 254489b1c373Smeem if (err != DLADM_STATUS_OK) { 254589b1c373Smeem zdlerror(zlogp, err, dlname, 254689b1c373Smeem "WARNING: unable to add network interface"); 2547f4b3ec61Sdh155122 return (-1); 2548f4b3ec61Sdh155122 } 2549f4b3ec61Sdh155122 return (0); 2550f4b3ec61Sdh155122 } 2551f4b3ec61Sdh155122 2552f4b3ec61Sdh155122 /* 2553f4b3ec61Sdh155122 * Add the kernel access control information for the interface names. 2554f4b3ec61Sdh155122 * If anything goes wrong, we log a general error message, attempt to tear down 2555f4b3ec61Sdh155122 * whatever we set up, and return an error. 2556f4b3ec61Sdh155122 */ 2557f4b3ec61Sdh155122 static int 2558f4b3ec61Sdh155122 configure_exclusive_network_interfaces(zlog_t *zlogp) 2559f4b3ec61Sdh155122 { 2560f4b3ec61Sdh155122 zone_dochandle_t handle; 2561f4b3ec61Sdh155122 struct zone_nwiftab nwiftab; 2562f4b3ec61Sdh155122 char rootpath[MAXPATHLEN]; 2563f4b3ec61Sdh155122 char path[MAXPATHLEN]; 25642b24ab6bSSebastien Roy datalink_id_t linkid; 2565f4b3ec61Sdh155122 di_prof_t prof = NULL; 2566f4b3ec61Sdh155122 boolean_t added = B_FALSE; 2567f4b3ec61Sdh155122 2568f4b3ec61Sdh155122 if ((handle = zonecfg_init_handle()) == NULL) { 2569f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 2570f4b3ec61Sdh155122 return (-1); 2571f4b3ec61Sdh155122 } 2572f4b3ec61Sdh155122 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 2573f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "invalid configuration"); 2574f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2575f4b3ec61Sdh155122 return (-1); 2576f4b3ec61Sdh155122 } 2577f4b3ec61Sdh155122 2578f4b3ec61Sdh155122 if (zonecfg_setnwifent(handle) != Z_OK) { 2579f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2580f4b3ec61Sdh155122 return (0); 2581f4b3ec61Sdh155122 } 2582f4b3ec61Sdh155122 2583f4b3ec61Sdh155122 for (;;) { 2584f4b3ec61Sdh155122 if (zonecfg_getnwifent(handle, &nwiftab) != Z_OK) 2585f4b3ec61Sdh155122 break; 2586f4b3ec61Sdh155122 2587f4b3ec61Sdh155122 if (prof == NULL) { 2588f4b3ec61Sdh155122 if (zone_get_devroot(zone_name, rootpath, 2589f4b3ec61Sdh155122 sizeof (rootpath)) != Z_OK) { 2590f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2591f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2592f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, 2593f4b3ec61Sdh155122 "unable to determine dev root"); 2594f4b3ec61Sdh155122 return (-1); 2595f4b3ec61Sdh155122 } 2596f4b3ec61Sdh155122 (void) snprintf(path, sizeof (path), "%s%s", rootpath, 2597f4b3ec61Sdh155122 "/dev"); 2598f4b3ec61Sdh155122 if (di_prof_init(path, &prof) != 0) { 2599f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2600f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2601f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, 2602f4b3ec61Sdh155122 "failed to initialize profile"); 2603f4b3ec61Sdh155122 return (-1); 2604f4b3ec61Sdh155122 } 2605f4b3ec61Sdh155122 } 2606f4b3ec61Sdh155122 2607f4b3ec61Sdh155122 /* 2608d62bc4baSyz147064 * Create the /dev entry for backward compatibility. 2609f4b3ec61Sdh155122 * Only create the /dev entry if it's not in use. 2610d62bc4baSyz147064 * Note that the zone still boots when the assigned 2611d62bc4baSyz147064 * interface is inaccessible, used by others, etc. 2612d62bc4baSyz147064 * Also, when vanity naming is used, some interface do 2613d62bc4baSyz147064 * do not have corresponding /dev node names (for example, 2614d62bc4baSyz147064 * vanity named aggregations). The /dev entry is not 2615d62bc4baSyz147064 * created in that case. The /dev/net entry is always 2616d62bc4baSyz147064 * accessible. 2617f4b3ec61Sdh155122 */ 26182b24ab6bSSebastien Roy if (dladm_name2info(dld_handle, nwiftab.zone_nwif_physical, 26192b24ab6bSSebastien Roy &linkid, NULL, NULL, NULL) == DLADM_STATUS_OK && 26202b24ab6bSSebastien Roy add_datalink(zlogp, zone_name, linkid, 26212b24ab6bSSebastien Roy nwiftab.zone_nwif_physical) == 0) { 26223bc21d0aSAruna Ramakrishna - Sun Microsystems added = B_TRUE; 26233bc21d0aSAruna Ramakrishna - Sun Microsystems } else { 2624f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2625f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 26263bc21d0aSAruna Ramakrishna - Sun Microsystems zerror(zlogp, B_TRUE, "failed to add network device"); 2627f4b3ec61Sdh155122 return (-1); 2628f4b3ec61Sdh155122 } 2629d62bc4baSyz147064 } 2630f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2631f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2632f4b3ec61Sdh155122 2633f4b3ec61Sdh155122 if (prof != NULL && added) { 2634f4b3ec61Sdh155122 if (di_prof_commit(prof) != 0) { 2635f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "failed to commit profile"); 2636f4b3ec61Sdh155122 return (-1); 2637f4b3ec61Sdh155122 } 2638f4b3ec61Sdh155122 } 2639f4b3ec61Sdh155122 if (prof != NULL) 2640f4b3ec61Sdh155122 di_prof_fini(prof); 2641f4b3ec61Sdh155122 2642f4b3ec61Sdh155122 return (0); 2643f4b3ec61Sdh155122 } 2644f4b3ec61Sdh155122 2645f4b3ec61Sdh155122 static int 26462b24ab6bSSebastien Roy unconfigure_exclusive_network_interfaces(zlog_t *zlogp, zoneid_t zoneid) 2647f4b3ec61Sdh155122 { 26482b24ab6bSSebastien Roy int dlnum = 0; 2649f4b3ec61Sdh155122 26502b24ab6bSSebastien Roy /* 26512b24ab6bSSebastien Roy * The kernel shutdown callback for the dls module should have removed 26522b24ab6bSSebastien Roy * all datalinks from this zone. If any remain, then there's a 26532b24ab6bSSebastien Roy * problem. 26542b24ab6bSSebastien Roy */ 2655f4b3ec61Sdh155122 if (zone_list_datalink(zoneid, &dlnum, NULL) != 0) { 2656f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to list network interfaces"); 2657f4b3ec61Sdh155122 return (-1); 2658f4b3ec61Sdh155122 } 26592b24ab6bSSebastien Roy if (dlnum != 0) { 26602b24ab6bSSebastien Roy zerror(zlogp, B_FALSE, 26612b24ab6bSSebastien Roy "datalinks remain in zone after shutdown"); 2662f4b3ec61Sdh155122 return (-1); 2663f4b3ec61Sdh155122 } 2664f4b3ec61Sdh155122 return (0); 2665f4b3ec61Sdh155122 } 2666f4b3ec61Sdh155122 26677c478bd9Sstevel@tonic-gate static int 26687c478bd9Sstevel@tonic-gate tcp_abort_conn(zlog_t *zlogp, zoneid_t zoneid, 26697c478bd9Sstevel@tonic-gate const struct sockaddr_storage *local, const struct sockaddr_storage *remote) 26707c478bd9Sstevel@tonic-gate { 26717c478bd9Sstevel@tonic-gate int fd; 26727c478bd9Sstevel@tonic-gate struct strioctl ioc; 26737c478bd9Sstevel@tonic-gate tcp_ioc_abort_conn_t conn; 26747c478bd9Sstevel@tonic-gate int error; 26757c478bd9Sstevel@tonic-gate 26767c478bd9Sstevel@tonic-gate conn.ac_local = *local; 26777c478bd9Sstevel@tonic-gate conn.ac_remote = *remote; 26787c478bd9Sstevel@tonic-gate conn.ac_start = TCPS_SYN_SENT; 26797c478bd9Sstevel@tonic-gate conn.ac_end = TCPS_TIME_WAIT; 26807c478bd9Sstevel@tonic-gate conn.ac_zoneid = zoneid; 26817c478bd9Sstevel@tonic-gate 26827c478bd9Sstevel@tonic-gate ioc.ic_cmd = TCP_IOC_ABORT_CONN; 26837c478bd9Sstevel@tonic-gate ioc.ic_timout = -1; /* infinite timeout */ 26847c478bd9Sstevel@tonic-gate ioc.ic_len = sizeof (conn); 26857c478bd9Sstevel@tonic-gate ioc.ic_dp = (char *)&conn; 26867c478bd9Sstevel@tonic-gate 26877c478bd9Sstevel@tonic-gate if ((fd = open("/dev/tcp", O_RDONLY)) < 0) { 26887c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to open %s", "/dev/tcp"); 26897c478bd9Sstevel@tonic-gate return (-1); 26907c478bd9Sstevel@tonic-gate } 26917c478bd9Sstevel@tonic-gate 26927c478bd9Sstevel@tonic-gate error = ioctl(fd, I_STR, &ioc); 26937c478bd9Sstevel@tonic-gate (void) close(fd); 26947c478bd9Sstevel@tonic-gate if (error == 0 || errno == ENOENT) /* ENOENT is not an error */ 26957c478bd9Sstevel@tonic-gate return (0); 26967c478bd9Sstevel@tonic-gate return (-1); 26977c478bd9Sstevel@tonic-gate } 26987c478bd9Sstevel@tonic-gate 26997c478bd9Sstevel@tonic-gate static int 27007c478bd9Sstevel@tonic-gate tcp_abort_connections(zlog_t *zlogp, zoneid_t zoneid) 27017c478bd9Sstevel@tonic-gate { 27027c478bd9Sstevel@tonic-gate struct sockaddr_storage l, r; 27037c478bd9Sstevel@tonic-gate struct sockaddr_in *local, *remote; 27047c478bd9Sstevel@tonic-gate struct sockaddr_in6 *local6, *remote6; 27057c478bd9Sstevel@tonic-gate int error; 27067c478bd9Sstevel@tonic-gate 27077c478bd9Sstevel@tonic-gate /* 27087c478bd9Sstevel@tonic-gate * Abort IPv4 connections. 27097c478bd9Sstevel@tonic-gate */ 27107c478bd9Sstevel@tonic-gate bzero(&l, sizeof (*local)); 27117c478bd9Sstevel@tonic-gate local = (struct sockaddr_in *)&l; 27127c478bd9Sstevel@tonic-gate local->sin_family = AF_INET; 27137c478bd9Sstevel@tonic-gate local->sin_addr.s_addr = INADDR_ANY; 27147c478bd9Sstevel@tonic-gate local->sin_port = 0; 27157c478bd9Sstevel@tonic-gate 27167c478bd9Sstevel@tonic-gate bzero(&r, sizeof (*remote)); 27177c478bd9Sstevel@tonic-gate remote = (struct sockaddr_in *)&r; 27187c478bd9Sstevel@tonic-gate remote->sin_family = AF_INET; 27197c478bd9Sstevel@tonic-gate remote->sin_addr.s_addr = INADDR_ANY; 27207c478bd9Sstevel@tonic-gate remote->sin_port = 0; 27217c478bd9Sstevel@tonic-gate 27227c478bd9Sstevel@tonic-gate if ((error = tcp_abort_conn(zlogp, zoneid, &l, &r)) != 0) 27237c478bd9Sstevel@tonic-gate return (error); 27247c478bd9Sstevel@tonic-gate 27257c478bd9Sstevel@tonic-gate /* 27267c478bd9Sstevel@tonic-gate * Abort IPv6 connections. 27277c478bd9Sstevel@tonic-gate */ 27287c478bd9Sstevel@tonic-gate bzero(&l, sizeof (*local6)); 27297c478bd9Sstevel@tonic-gate local6 = (struct sockaddr_in6 *)&l; 27307c478bd9Sstevel@tonic-gate local6->sin6_family = AF_INET6; 27317c478bd9Sstevel@tonic-gate local6->sin6_port = 0; 27327c478bd9Sstevel@tonic-gate local6->sin6_addr = in6addr_any; 27337c478bd9Sstevel@tonic-gate 27347c478bd9Sstevel@tonic-gate bzero(&r, sizeof (*remote6)); 27357c478bd9Sstevel@tonic-gate remote6 = (struct sockaddr_in6 *)&r; 27367c478bd9Sstevel@tonic-gate remote6->sin6_family = AF_INET6; 27377c478bd9Sstevel@tonic-gate remote6->sin6_port = 0; 27387c478bd9Sstevel@tonic-gate remote6->sin6_addr = in6addr_any; 27397c478bd9Sstevel@tonic-gate 27407c478bd9Sstevel@tonic-gate if ((error = tcp_abort_conn(zlogp, zoneid, &l, &r)) != 0) 27417c478bd9Sstevel@tonic-gate return (error); 27427c478bd9Sstevel@tonic-gate return (0); 27437c478bd9Sstevel@tonic-gate } 27447c478bd9Sstevel@tonic-gate 27457c478bd9Sstevel@tonic-gate static int 27466cfd72c6Sgjelinek get_privset(zlog_t *zlogp, priv_set_t *privs, zone_mnt_t mount_cmd) 2747ffbafc53Scomay { 2748ffbafc53Scomay int error = -1; 2749ffbafc53Scomay zone_dochandle_t handle; 2750ffbafc53Scomay char *privname = NULL; 2751ffbafc53Scomay 2752ffbafc53Scomay if ((handle = zonecfg_init_handle()) == NULL) { 2753ffbafc53Scomay zerror(zlogp, B_TRUE, "getting zone configuration handle"); 2754ffbafc53Scomay return (-1); 2755ffbafc53Scomay } 2756ffbafc53Scomay if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 2757ffbafc53Scomay zerror(zlogp, B_FALSE, "invalid configuration"); 2758ffbafc53Scomay zonecfg_fini_handle(handle); 2759ffbafc53Scomay return (-1); 2760ffbafc53Scomay } 2761ffbafc53Scomay 27626cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd)) { 2763bf1d7e28Sdh155122 zone_iptype_t iptype; 2764bf1d7e28Sdh155122 const char *curr_iptype; 2765bf1d7e28Sdh155122 2766bf1d7e28Sdh155122 if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 2767bf1d7e28Sdh155122 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 2768bf1d7e28Sdh155122 zonecfg_fini_handle(handle); 2769bf1d7e28Sdh155122 return (-1); 2770bf1d7e28Sdh155122 } 2771bf1d7e28Sdh155122 2772bf1d7e28Sdh155122 switch (iptype) { 2773bf1d7e28Sdh155122 case ZS_SHARED: 2774bf1d7e28Sdh155122 curr_iptype = "shared"; 2775bf1d7e28Sdh155122 break; 2776bf1d7e28Sdh155122 case ZS_EXCLUSIVE: 2777bf1d7e28Sdh155122 curr_iptype = "exclusive"; 2778bf1d7e28Sdh155122 break; 2779bf1d7e28Sdh155122 } 2780bf1d7e28Sdh155122 2781e767a340Sgjelinek if (zonecfg_default_privset(privs, curr_iptype) == Z_OK) { 2782e767a340Sgjelinek zonecfg_fini_handle(handle); 27839acbbeafSnn35248 return (0); 2784e767a340Sgjelinek } 27859acbbeafSnn35248 zerror(zlogp, B_FALSE, 27869acbbeafSnn35248 "failed to determine the zone's default privilege set"); 27879acbbeafSnn35248 zonecfg_fini_handle(handle); 27889acbbeafSnn35248 return (-1); 27899acbbeafSnn35248 } 27909acbbeafSnn35248 2791ffbafc53Scomay switch (zonecfg_get_privset(handle, privs, &privname)) { 2792ffbafc53Scomay case Z_OK: 2793ffbafc53Scomay error = 0; 2794ffbafc53Scomay break; 2795ffbafc53Scomay case Z_PRIV_PROHIBITED: 2796ffbafc53Scomay zerror(zlogp, B_FALSE, "privilege \"%s\" is not permitted " 2797ffbafc53Scomay "within the zone's privilege set", privname); 2798ffbafc53Scomay break; 2799ffbafc53Scomay case Z_PRIV_REQUIRED: 2800ffbafc53Scomay zerror(zlogp, B_FALSE, "required privilege \"%s\" is missing " 2801ffbafc53Scomay "from the zone's privilege set", privname); 2802ffbafc53Scomay break; 2803ffbafc53Scomay case Z_PRIV_UNKNOWN: 2804ffbafc53Scomay zerror(zlogp, B_FALSE, "unknown privilege \"%s\" specified " 2805ffbafc53Scomay "in the zone's privilege set", privname); 2806ffbafc53Scomay break; 2807ffbafc53Scomay default: 2808ffbafc53Scomay zerror(zlogp, B_FALSE, "failed to determine the zone's " 2809ffbafc53Scomay "privilege set"); 2810ffbafc53Scomay break; 2811ffbafc53Scomay } 2812ffbafc53Scomay 2813ffbafc53Scomay free(privname); 2814ffbafc53Scomay zonecfg_fini_handle(handle); 2815ffbafc53Scomay return (error); 2816ffbafc53Scomay } 2817ffbafc53Scomay 2818ffbafc53Scomay static int 28197c478bd9Sstevel@tonic-gate get_rctls(zlog_t *zlogp, char **bufp, size_t *bufsizep) 28207c478bd9Sstevel@tonic-gate { 28217c478bd9Sstevel@tonic-gate nvlist_t *nvl = NULL; 28227c478bd9Sstevel@tonic-gate char *nvl_packed = NULL; 28237c478bd9Sstevel@tonic-gate size_t nvl_size = 0; 28247c478bd9Sstevel@tonic-gate nvlist_t **nvlv = NULL; 28257c478bd9Sstevel@tonic-gate int rctlcount = 0; 28267c478bd9Sstevel@tonic-gate int error = -1; 28277c478bd9Sstevel@tonic-gate zone_dochandle_t handle; 28287c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 28297c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk = NULL; 28307c478bd9Sstevel@tonic-gate 28317c478bd9Sstevel@tonic-gate *bufp = NULL; 28327c478bd9Sstevel@tonic-gate *bufsizep = 0; 28337c478bd9Sstevel@tonic-gate 28347c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 28357c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "getting zone configuration handle"); 28367c478bd9Sstevel@tonic-gate return (-1); 28377c478bd9Sstevel@tonic-gate } 28387c478bd9Sstevel@tonic-gate if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 28397c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "invalid configuration"); 28407c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 28417c478bd9Sstevel@tonic-gate return (-1); 28427c478bd9Sstevel@tonic-gate } 28437c478bd9Sstevel@tonic-gate 28447c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 28457c478bd9Sstevel@tonic-gate if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) { 28467c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "nvlist_alloc"); 28477c478bd9Sstevel@tonic-gate goto out; 28487c478bd9Sstevel@tonic-gate } 28497c478bd9Sstevel@tonic-gate 28507c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) { 28517c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setrctlent"); 28527c478bd9Sstevel@tonic-gate goto out; 28537c478bd9Sstevel@tonic-gate } 28547c478bd9Sstevel@tonic-gate 28557c478bd9Sstevel@tonic-gate if ((rctlblk = malloc(rctlblk_size())) == NULL) { 28567c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "memory allocation failed"); 28577c478bd9Sstevel@tonic-gate goto out; 28587c478bd9Sstevel@tonic-gate } 28597c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 28607c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlval; 28617c478bd9Sstevel@tonic-gate uint_t i, count; 28627c478bd9Sstevel@tonic-gate const char *name = rctltab.zone_rctl_name; 28637c478bd9Sstevel@tonic-gate 28647c478bd9Sstevel@tonic-gate /* zoneadm should have already warned about unknown rctls. */ 28657c478bd9Sstevel@tonic-gate if (!zonecfg_is_rctl(name)) { 28667c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 28677c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 28687c478bd9Sstevel@tonic-gate continue; 28697c478bd9Sstevel@tonic-gate } 28707c478bd9Sstevel@tonic-gate count = 0; 28717c478bd9Sstevel@tonic-gate for (rctlval = rctltab.zone_rctl_valptr; rctlval != NULL; 28727c478bd9Sstevel@tonic-gate rctlval = rctlval->zone_rctlval_next) { 28737c478bd9Sstevel@tonic-gate count++; 28747c478bd9Sstevel@tonic-gate } 28757c478bd9Sstevel@tonic-gate if (count == 0) { /* ignore */ 28767c478bd9Sstevel@tonic-gate continue; /* Nothing to free */ 28777c478bd9Sstevel@tonic-gate } 28787c478bd9Sstevel@tonic-gate if ((nvlv = malloc(sizeof (*nvlv) * count)) == NULL) 28797c478bd9Sstevel@tonic-gate goto out; 28807c478bd9Sstevel@tonic-gate i = 0; 28817c478bd9Sstevel@tonic-gate for (rctlval = rctltab.zone_rctl_valptr; rctlval != NULL; 28827c478bd9Sstevel@tonic-gate rctlval = rctlval->zone_rctlval_next, i++) { 28837c478bd9Sstevel@tonic-gate if (nvlist_alloc(&nvlv[i], NV_UNIQUE_NAME, 0) != 0) { 28847c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", 28857c478bd9Sstevel@tonic-gate "nvlist_alloc"); 28867c478bd9Sstevel@tonic-gate goto out; 28877c478bd9Sstevel@tonic-gate } 28887c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlval, rctlblk) 28897c478bd9Sstevel@tonic-gate != Z_OK) { 28907c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "invalid rctl value: " 28917c478bd9Sstevel@tonic-gate "(priv=%s,limit=%s,action=%s)", 28927c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_priv, 28937c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_limit, 28947c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_action); 28957c478bd9Sstevel@tonic-gate goto out; 28967c478bd9Sstevel@tonic-gate } 28977c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctl(name, rctlblk)) { 28987c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 28997c478bd9Sstevel@tonic-gate "(priv=%s,limit=%s,action=%s) is not a " 29007c478bd9Sstevel@tonic-gate "valid value for rctl '%s'", 29017c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_priv, 29027c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_limit, 29037c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_action, 29047c478bd9Sstevel@tonic-gate name); 29057c478bd9Sstevel@tonic-gate goto out; 29067c478bd9Sstevel@tonic-gate } 29077c478bd9Sstevel@tonic-gate if (nvlist_add_uint64(nvlv[i], "privilege", 29087c478bd9Sstevel@tonic-gate rctlblk_get_privilege(rctlblk)) != 0) { 29097c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", 29107c478bd9Sstevel@tonic-gate "nvlist_add_uint64"); 29117c478bd9Sstevel@tonic-gate goto out; 29127c478bd9Sstevel@tonic-gate } 29137c478bd9Sstevel@tonic-gate if (nvlist_add_uint64(nvlv[i], "limit", 29147c478bd9Sstevel@tonic-gate rctlblk_get_value(rctlblk)) != 0) { 29157c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", 29167c478bd9Sstevel@tonic-gate "nvlist_add_uint64"); 29177c478bd9Sstevel@tonic-gate goto out; 29187c478bd9Sstevel@tonic-gate } 29197c478bd9Sstevel@tonic-gate if (nvlist_add_uint64(nvlv[i], "action", 29207c478bd9Sstevel@tonic-gate (uint_t)rctlblk_get_local_action(rctlblk, NULL)) 29217c478bd9Sstevel@tonic-gate != 0) { 29227c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", 29237c478bd9Sstevel@tonic-gate "nvlist_add_uint64"); 29247c478bd9Sstevel@tonic-gate goto out; 29257c478bd9Sstevel@tonic-gate } 29267c478bd9Sstevel@tonic-gate } 29277c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 29287c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 29297c478bd9Sstevel@tonic-gate if (nvlist_add_nvlist_array(nvl, (char *)name, nvlv, count) 29307c478bd9Sstevel@tonic-gate != 0) { 29317c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", 29327c478bd9Sstevel@tonic-gate "nvlist_add_nvlist_array"); 29337c478bd9Sstevel@tonic-gate goto out; 29347c478bd9Sstevel@tonic-gate } 29357c478bd9Sstevel@tonic-gate for (i = 0; i < count; i++) 29367c478bd9Sstevel@tonic-gate nvlist_free(nvlv[i]); 29377c478bd9Sstevel@tonic-gate free(nvlv); 29387c478bd9Sstevel@tonic-gate nvlv = NULL; 29397c478bd9Sstevel@tonic-gate rctlcount++; 29407c478bd9Sstevel@tonic-gate } 29417c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 29427c478bd9Sstevel@tonic-gate 29437c478bd9Sstevel@tonic-gate if (rctlcount == 0) { 29447c478bd9Sstevel@tonic-gate error = 0; 29457c478bd9Sstevel@tonic-gate goto out; 29467c478bd9Sstevel@tonic-gate } 29477c478bd9Sstevel@tonic-gate if (nvlist_pack(nvl, &nvl_packed, &nvl_size, NV_ENCODE_NATIVE, 0) 29487c478bd9Sstevel@tonic-gate != 0) { 29497c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", "nvlist_pack"); 29507c478bd9Sstevel@tonic-gate goto out; 29517c478bd9Sstevel@tonic-gate } 29527c478bd9Sstevel@tonic-gate 29537c478bd9Sstevel@tonic-gate error = 0; 29547c478bd9Sstevel@tonic-gate *bufp = nvl_packed; 29557c478bd9Sstevel@tonic-gate *bufsizep = nvl_size; 29567c478bd9Sstevel@tonic-gate 29577c478bd9Sstevel@tonic-gate out: 29587c478bd9Sstevel@tonic-gate free(rctlblk); 29597c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 29607c478bd9Sstevel@tonic-gate if (error && nvl_packed != NULL) 29617c478bd9Sstevel@tonic-gate free(nvl_packed); 29627c478bd9Sstevel@tonic-gate if (nvl != NULL) 29637c478bd9Sstevel@tonic-gate nvlist_free(nvl); 29647c478bd9Sstevel@tonic-gate if (nvlv != NULL) 29657c478bd9Sstevel@tonic-gate free(nvlv); 29667c478bd9Sstevel@tonic-gate if (handle != NULL) 29677c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 29687c478bd9Sstevel@tonic-gate return (error); 29697c478bd9Sstevel@tonic-gate } 29707c478bd9Sstevel@tonic-gate 29717c478bd9Sstevel@tonic-gate static int 2972c5cd6260S get_implicit_datasets(zlog_t *zlogp, char **retstr) 2973c5cd6260S { 2974c5cd6260S char cmdbuf[2 * MAXPATHLEN]; 2975c5cd6260S 2976c5cd6260S if (query_hook[0] == '\0') 2977c5cd6260S return (0); 2978c5cd6260S 2979c5cd6260S if (snprintf(cmdbuf, sizeof (cmdbuf), "%s datasets", query_hook) 2980c5cd6260S > sizeof (cmdbuf)) 2981c5cd6260S return (-1); 2982c5cd6260S 2983c5cd6260S if (do_subproc(zlogp, cmdbuf, retstr) != 0) 2984c5cd6260S return (-1); 2985c5cd6260S 2986c5cd6260S return (0); 2987c5cd6260S } 2988c5cd6260S 2989c5cd6260S static int 2990fa9e4066Sahrens get_datasets(zlog_t *zlogp, char **bufp, size_t *bufsizep) 2991fa9e4066Sahrens { 2992fa9e4066Sahrens zone_dochandle_t handle; 2993fa9e4066Sahrens struct zone_dstab dstab; 2994fa9e4066Sahrens size_t total, offset, len; 2995fa9e4066Sahrens int error = -1; 2996e5a17f6aSgjelinek char *str = NULL; 2997c5cd6260S char *implicit_datasets = NULL; 2998c5cd6260S int implicit_len = 0; 2999fa9e4066Sahrens 3000fa9e4066Sahrens *bufp = NULL; 3001fa9e4066Sahrens *bufsizep = 0; 3002fa9e4066Sahrens 3003fa9e4066Sahrens if ((handle = zonecfg_init_handle()) == NULL) { 3004fa9e4066Sahrens zerror(zlogp, B_TRUE, "getting zone configuration handle"); 3005fa9e4066Sahrens return (-1); 3006fa9e4066Sahrens } 3007fa9e4066Sahrens if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 3008fa9e4066Sahrens zerror(zlogp, B_FALSE, "invalid configuration"); 3009fa9e4066Sahrens zonecfg_fini_handle(handle); 3010fa9e4066Sahrens return (-1); 3011fa9e4066Sahrens } 3012fa9e4066Sahrens 3013c5cd6260S if (get_implicit_datasets(zlogp, &implicit_datasets) != 0) { 3014c5cd6260S zerror(zlogp, B_FALSE, "getting implicit datasets failed"); 3015c5cd6260S goto out; 3016c5cd6260S } 3017c5cd6260S 3018fa9e4066Sahrens if (zonecfg_setdsent(handle) != Z_OK) { 3019fa9e4066Sahrens zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setdsent"); 3020fa9e4066Sahrens goto out; 3021fa9e4066Sahrens } 3022fa9e4066Sahrens 3023fa9e4066Sahrens total = 0; 3024fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) 3025fa9e4066Sahrens total += strlen(dstab.zone_dataset_name) + 1; 3026fa9e4066Sahrens (void) zonecfg_enddsent(handle); 3027fa9e4066Sahrens 3028c5cd6260S if (implicit_datasets != NULL) 3029c5cd6260S implicit_len = strlen(implicit_datasets); 3030c5cd6260S if (implicit_len > 0) 3031c5cd6260S total += implicit_len + 1; 3032c5cd6260S 3033fa9e4066Sahrens if (total == 0) { 3034fa9e4066Sahrens error = 0; 3035fa9e4066Sahrens goto out; 3036fa9e4066Sahrens } 3037fa9e4066Sahrens 3038fa9e4066Sahrens if ((str = malloc(total)) == NULL) { 3039fa9e4066Sahrens zerror(zlogp, B_TRUE, "memory allocation failed"); 3040fa9e4066Sahrens goto out; 3041fa9e4066Sahrens } 3042fa9e4066Sahrens 3043fa9e4066Sahrens if (zonecfg_setdsent(handle) != Z_OK) { 3044fa9e4066Sahrens zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setdsent"); 3045fa9e4066Sahrens goto out; 3046fa9e4066Sahrens } 3047fa9e4066Sahrens offset = 0; 3048fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 3049fa9e4066Sahrens len = strlen(dstab.zone_dataset_name); 3050fa9e4066Sahrens (void) strlcpy(str + offset, dstab.zone_dataset_name, 3051e5a17f6aSgjelinek total - offset); 3052fa9e4066Sahrens offset += len; 3053e5a17f6aSgjelinek if (offset < total - 1) 3054fa9e4066Sahrens str[offset++] = ','; 3055fa9e4066Sahrens } 3056fa9e4066Sahrens (void) zonecfg_enddsent(handle); 3057fa9e4066Sahrens 3058c5cd6260S if (implicit_len > 0) 3059c5cd6260S (void) strlcpy(str + offset, implicit_datasets, total - offset); 3060c5cd6260S 3061fa9e4066Sahrens error = 0; 3062fa9e4066Sahrens *bufp = str; 3063fa9e4066Sahrens *bufsizep = total; 3064fa9e4066Sahrens 3065fa9e4066Sahrens out: 3066fa9e4066Sahrens if (error != 0 && str != NULL) 3067fa9e4066Sahrens free(str); 3068fa9e4066Sahrens if (handle != NULL) 3069fa9e4066Sahrens zonecfg_fini_handle(handle); 3070c5cd6260S if (implicit_datasets != NULL) 3071c5cd6260S free(implicit_datasets); 3072fa9e4066Sahrens 3073fa9e4066Sahrens return (error); 3074fa9e4066Sahrens } 3075fa9e4066Sahrens 3076fa9e4066Sahrens static int 3077fa9e4066Sahrens validate_datasets(zlog_t *zlogp) 3078fa9e4066Sahrens { 3079fa9e4066Sahrens zone_dochandle_t handle; 3080fa9e4066Sahrens struct zone_dstab dstab; 3081fa9e4066Sahrens zfs_handle_t *zhp; 308299653d4eSeschrock libzfs_handle_t *hdl; 3083fa9e4066Sahrens 3084fa9e4066Sahrens if ((handle = zonecfg_init_handle()) == NULL) { 3085fa9e4066Sahrens zerror(zlogp, B_TRUE, "getting zone configuration handle"); 3086fa9e4066Sahrens return (-1); 3087fa9e4066Sahrens } 3088fa9e4066Sahrens if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 3089fa9e4066Sahrens zerror(zlogp, B_FALSE, "invalid configuration"); 3090fa9e4066Sahrens zonecfg_fini_handle(handle); 3091fa9e4066Sahrens return (-1); 3092fa9e4066Sahrens } 3093fa9e4066Sahrens 3094fa9e4066Sahrens if (zonecfg_setdsent(handle) != Z_OK) { 3095fa9e4066Sahrens zerror(zlogp, B_FALSE, "invalid configuration"); 3096fa9e4066Sahrens zonecfg_fini_handle(handle); 3097fa9e4066Sahrens return (-1); 3098fa9e4066Sahrens } 3099fa9e4066Sahrens 310099653d4eSeschrock if ((hdl = libzfs_init()) == NULL) { 310199653d4eSeschrock zerror(zlogp, B_FALSE, "opening ZFS library"); 310299653d4eSeschrock zonecfg_fini_handle(handle); 310399653d4eSeschrock return (-1); 310499653d4eSeschrock } 3105fa9e4066Sahrens 3106fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 3107fa9e4066Sahrens 310899653d4eSeschrock if ((zhp = zfs_open(hdl, dstab.zone_dataset_name, 3109fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) == NULL) { 3110fa9e4066Sahrens zerror(zlogp, B_FALSE, "cannot open ZFS dataset '%s'", 3111fa9e4066Sahrens dstab.zone_dataset_name); 3112fa9e4066Sahrens zonecfg_fini_handle(handle); 311399653d4eSeschrock libzfs_fini(hdl); 3114fa9e4066Sahrens return (-1); 3115fa9e4066Sahrens } 3116fa9e4066Sahrens 3117fa9e4066Sahrens /* 3118fa9e4066Sahrens * Automatically set the 'zoned' property. We check the value 3119fa9e4066Sahrens * first because we'll get EPERM if it is already set. 3120fa9e4066Sahrens */ 3121fa9e4066Sahrens if (!zfs_prop_get_int(zhp, ZFS_PROP_ZONED) && 3122e9dbad6fSeschrock zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_ZONED), 3123e9dbad6fSeschrock "on") != 0) { 3124fa9e4066Sahrens zerror(zlogp, B_FALSE, "cannot set 'zoned' " 3125fa9e4066Sahrens "property for ZFS dataset '%s'\n", 3126fa9e4066Sahrens dstab.zone_dataset_name); 3127fa9e4066Sahrens zonecfg_fini_handle(handle); 3128fa9e4066Sahrens zfs_close(zhp); 312999653d4eSeschrock libzfs_fini(hdl); 3130fa9e4066Sahrens return (-1); 3131fa9e4066Sahrens } 3132fa9e4066Sahrens 3133fa9e4066Sahrens zfs_close(zhp); 3134fa9e4066Sahrens } 3135fa9e4066Sahrens (void) zonecfg_enddsent(handle); 3136fa9e4066Sahrens 3137fa9e4066Sahrens zonecfg_fini_handle(handle); 313899653d4eSeschrock libzfs_fini(hdl); 3139fa9e4066Sahrens 3140fa9e4066Sahrens return (0); 3141fa9e4066Sahrens } 3142fa9e4066Sahrens 314345916cd2Sjpk /* 314445916cd2Sjpk * Mount lower level home directories into/from current zone 314545916cd2Sjpk * Share exported directories specified in dfstab for zone 314645916cd2Sjpk */ 314745916cd2Sjpk static int 314845916cd2Sjpk tsol_mounts(zlog_t *zlogp, char *zone_name, char *rootpath) 314945916cd2Sjpk { 315045916cd2Sjpk zoneid_t *zids = NULL; 315145916cd2Sjpk priv_set_t *zid_privs; 315245916cd2Sjpk const priv_impl_info_t *ip = NULL; 315345916cd2Sjpk uint_t nzents_saved; 315445916cd2Sjpk uint_t nzents; 315545916cd2Sjpk int i; 315645916cd2Sjpk char readonly[] = "ro"; 315745916cd2Sjpk struct zone_fstab lower_fstab; 315845916cd2Sjpk char *argv[4]; 315945916cd2Sjpk 316045916cd2Sjpk if (!is_system_labeled()) 316145916cd2Sjpk return (0); 316245916cd2Sjpk 316345916cd2Sjpk if (zid_label == NULL) { 316445916cd2Sjpk zid_label = m_label_alloc(MAC_LABEL); 316545916cd2Sjpk if (zid_label == NULL) 316645916cd2Sjpk return (-1); 316745916cd2Sjpk } 316845916cd2Sjpk 316945916cd2Sjpk /* Make sure our zone has an /export/home dir */ 317045916cd2Sjpk (void) make_one_dir(zlogp, rootpath, "/export/home", 317127e6fb21Sdp DEFAULT_DIR_MODE, DEFAULT_DIR_USER, DEFAULT_DIR_GROUP); 317245916cd2Sjpk 317345916cd2Sjpk lower_fstab.zone_fs_raw[0] = '\0'; 317445916cd2Sjpk (void) strlcpy(lower_fstab.zone_fs_type, MNTTYPE_LOFS, 317545916cd2Sjpk sizeof (lower_fstab.zone_fs_type)); 317645916cd2Sjpk lower_fstab.zone_fs_options = NULL; 317745916cd2Sjpk (void) zonecfg_add_fs_option(&lower_fstab, readonly); 317845916cd2Sjpk 317945916cd2Sjpk /* 318045916cd2Sjpk * Get the list of zones from the kernel 318145916cd2Sjpk */ 318245916cd2Sjpk if (zone_list(NULL, &nzents) != 0) { 318345916cd2Sjpk zerror(zlogp, B_TRUE, "unable to list zones"); 318445916cd2Sjpk zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 318545916cd2Sjpk return (-1); 318645916cd2Sjpk } 318745916cd2Sjpk again: 318845916cd2Sjpk if (nzents == 0) { 318945916cd2Sjpk zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 319045916cd2Sjpk return (-1); 319145916cd2Sjpk } 319245916cd2Sjpk 319345916cd2Sjpk zids = malloc(nzents * sizeof (zoneid_t)); 319445916cd2Sjpk if (zids == NULL) { 31953f2f09c1Sdp zerror(zlogp, B_TRUE, "memory allocation failed"); 319645916cd2Sjpk return (-1); 319745916cd2Sjpk } 319845916cd2Sjpk nzents_saved = nzents; 319945916cd2Sjpk 320045916cd2Sjpk if (zone_list(zids, &nzents) != 0) { 320145916cd2Sjpk zerror(zlogp, B_TRUE, "unable to list zones"); 320245916cd2Sjpk zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 320345916cd2Sjpk free(zids); 320445916cd2Sjpk return (-1); 320545916cd2Sjpk } 320645916cd2Sjpk if (nzents != nzents_saved) { 320745916cd2Sjpk /* list changed, try again */ 320845916cd2Sjpk free(zids); 320945916cd2Sjpk goto again; 321045916cd2Sjpk } 321145916cd2Sjpk 321245916cd2Sjpk ip = getprivimplinfo(); 321345916cd2Sjpk if ((zid_privs = priv_allocset()) == NULL) { 321445916cd2Sjpk zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 321545916cd2Sjpk zonecfg_free_fs_option_list( 321645916cd2Sjpk lower_fstab.zone_fs_options); 321745916cd2Sjpk free(zids); 321845916cd2Sjpk return (-1); 321945916cd2Sjpk } 322045916cd2Sjpk 322145916cd2Sjpk for (i = 0; i < nzents; i++) { 322245916cd2Sjpk char zid_name[ZONENAME_MAX]; 322345916cd2Sjpk zone_state_t zid_state; 322445916cd2Sjpk char zid_rpath[MAXPATHLEN]; 322545916cd2Sjpk struct stat stat_buf; 322645916cd2Sjpk 322745916cd2Sjpk if (zids[i] == GLOBAL_ZONEID) 322845916cd2Sjpk continue; 322945916cd2Sjpk 323045916cd2Sjpk if (getzonenamebyid(zids[i], zid_name, ZONENAME_MAX) == -1) 323145916cd2Sjpk continue; 323245916cd2Sjpk 323345916cd2Sjpk /* 323445916cd2Sjpk * Do special setup for the zone we are booting 323545916cd2Sjpk */ 323645916cd2Sjpk if (strcmp(zid_name, zone_name) == 0) { 323745916cd2Sjpk struct zone_fstab autofs_fstab; 323845916cd2Sjpk char map_path[MAXPATHLEN]; 323945916cd2Sjpk int fd; 324045916cd2Sjpk 324145916cd2Sjpk /* 324245916cd2Sjpk * Create auto_home_<zone> map for this zone 32439acbbeafSnn35248 * in the global zone. The non-global zone entry 324445916cd2Sjpk * will be created by automount when the zone 324545916cd2Sjpk * is booted. 324645916cd2Sjpk */ 324745916cd2Sjpk 324845916cd2Sjpk (void) snprintf(autofs_fstab.zone_fs_special, 324945916cd2Sjpk MAXPATHLEN, "auto_home_%s", zid_name); 325045916cd2Sjpk 325145916cd2Sjpk (void) snprintf(autofs_fstab.zone_fs_dir, MAXPATHLEN, 325245916cd2Sjpk "/zone/%s/home", zid_name); 325345916cd2Sjpk 325445916cd2Sjpk (void) snprintf(map_path, sizeof (map_path), 325545916cd2Sjpk "/etc/%s", autofs_fstab.zone_fs_special); 325645916cd2Sjpk /* 325745916cd2Sjpk * If the map file doesn't exist create a template 325845916cd2Sjpk */ 325945916cd2Sjpk if ((fd = open(map_path, O_RDWR | O_CREAT | O_EXCL, 326045916cd2Sjpk S_IRUSR | S_IWUSR | S_IRGRP| S_IROTH)) != -1) { 326145916cd2Sjpk int len; 326245916cd2Sjpk char map_rec[MAXPATHLEN]; 326345916cd2Sjpk 326445916cd2Sjpk len = snprintf(map_rec, sizeof (map_rec), 326545916cd2Sjpk "+%s\n*\t-fstype=lofs\t:%s/export/home/&\n", 326645916cd2Sjpk autofs_fstab.zone_fs_special, rootpath); 326745916cd2Sjpk (void) write(fd, map_rec, len); 326845916cd2Sjpk (void) close(fd); 326945916cd2Sjpk } 327045916cd2Sjpk 327145916cd2Sjpk /* 327245916cd2Sjpk * Mount auto_home_<zone> in the global zone if absent. 327345916cd2Sjpk * If it's already of type autofs, then 327445916cd2Sjpk * don't mount it again. 327545916cd2Sjpk */ 327645916cd2Sjpk if ((stat(autofs_fstab.zone_fs_dir, &stat_buf) == -1) || 327745916cd2Sjpk strcmp(stat_buf.st_fstype, MNTTYPE_AUTOFS) != 0) { 327845916cd2Sjpk char optstr[] = "indirect,ignore,nobrowse"; 327945916cd2Sjpk 328045916cd2Sjpk (void) make_one_dir(zlogp, "", 328127e6fb21Sdp autofs_fstab.zone_fs_dir, DEFAULT_DIR_MODE, 328227e6fb21Sdp DEFAULT_DIR_USER, DEFAULT_DIR_GROUP); 328345916cd2Sjpk 328445916cd2Sjpk /* 328545916cd2Sjpk * Mount will fail if automounter has already 328645916cd2Sjpk * processed the auto_home_<zonename> map 328745916cd2Sjpk */ 328845916cd2Sjpk (void) domount(zlogp, MNTTYPE_AUTOFS, optstr, 328945916cd2Sjpk autofs_fstab.zone_fs_special, 329045916cd2Sjpk autofs_fstab.zone_fs_dir); 329145916cd2Sjpk } 329245916cd2Sjpk continue; 329345916cd2Sjpk } 329445916cd2Sjpk 329545916cd2Sjpk 329645916cd2Sjpk if (zone_get_state(zid_name, &zid_state) != Z_OK || 329748451833Scarlsonj (zid_state != ZONE_STATE_READY && 329848451833Scarlsonj zid_state != ZONE_STATE_RUNNING)) 329945916cd2Sjpk /* Skip over zones without mounted filesystems */ 330045916cd2Sjpk continue; 330145916cd2Sjpk 330245916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_SLBL, zid_label, 330345916cd2Sjpk sizeof (m_label_t)) < 0) 330445916cd2Sjpk /* Skip over zones with unspecified label */ 330545916cd2Sjpk continue; 330645916cd2Sjpk 330745916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_ROOT, zid_rpath, 330845916cd2Sjpk sizeof (zid_rpath)) == -1) 330945916cd2Sjpk /* Skip over zones with bad path */ 331045916cd2Sjpk continue; 331145916cd2Sjpk 331245916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_PRIVSET, zid_privs, 331345916cd2Sjpk sizeof (priv_chunk_t) * ip->priv_setsize) == -1) 331445916cd2Sjpk /* Skip over zones with bad privs */ 331545916cd2Sjpk continue; 331645916cd2Sjpk 331745916cd2Sjpk /* 331845916cd2Sjpk * Reading down is valid according to our label model 331945916cd2Sjpk * but some customers want to disable it because it 332045916cd2Sjpk * allows execute down and other possible attacks. 332145916cd2Sjpk * Therefore, we restrict this feature to zones that 332245916cd2Sjpk * have the NET_MAC_AWARE privilege which is required 332345916cd2Sjpk * for NFS read-down semantics. 332445916cd2Sjpk */ 332545916cd2Sjpk if ((bldominates(zlabel, zid_label)) && 332645916cd2Sjpk (priv_ismember(zprivs, PRIV_NET_MAC_AWARE))) { 332745916cd2Sjpk /* 332845916cd2Sjpk * Our zone dominates this one. 332945916cd2Sjpk * Create a lofs mount from lower zone's /export/home 333045916cd2Sjpk */ 333145916cd2Sjpk (void) snprintf(lower_fstab.zone_fs_dir, MAXPATHLEN, 333245916cd2Sjpk "%s/zone/%s/export/home", rootpath, zid_name); 333345916cd2Sjpk 333445916cd2Sjpk /* 333545916cd2Sjpk * If the target is already an LOFS mount 333645916cd2Sjpk * then don't do it again. 333745916cd2Sjpk */ 333845916cd2Sjpk if ((stat(lower_fstab.zone_fs_dir, &stat_buf) == -1) || 333945916cd2Sjpk strcmp(stat_buf.st_fstype, MNTTYPE_LOFS) != 0) { 334045916cd2Sjpk 334145916cd2Sjpk if (snprintf(lower_fstab.zone_fs_special, 334245916cd2Sjpk MAXPATHLEN, "%s/export", 334345916cd2Sjpk zid_rpath) > MAXPATHLEN) 334445916cd2Sjpk continue; 334545916cd2Sjpk 334645916cd2Sjpk /* 334745916cd2Sjpk * Make sure the lower-level home exists 334845916cd2Sjpk */ 334945916cd2Sjpk if (make_one_dir(zlogp, 335027e6fb21Sdp lower_fstab.zone_fs_special, "/home", 335127e6fb21Sdp DEFAULT_DIR_MODE, DEFAULT_DIR_USER, 335227e6fb21Sdp DEFAULT_DIR_GROUP) != 0) 335345916cd2Sjpk continue; 335445916cd2Sjpk 335545916cd2Sjpk (void) strlcat(lower_fstab.zone_fs_special, 335645916cd2Sjpk "/home", MAXPATHLEN); 335745916cd2Sjpk 335845916cd2Sjpk /* 335945916cd2Sjpk * Mount can fail because the lower-level 336045916cd2Sjpk * zone may have already done a mount up. 336145916cd2Sjpk */ 33620679f794S (void) mount_one(zlogp, &lower_fstab, "", 33630679f794S Z_MNT_BOOT); 336445916cd2Sjpk } 336545916cd2Sjpk } else if ((bldominates(zid_label, zlabel)) && 336645916cd2Sjpk (priv_ismember(zid_privs, PRIV_NET_MAC_AWARE))) { 336745916cd2Sjpk /* 336845916cd2Sjpk * This zone dominates our zone. 336945916cd2Sjpk * Create a lofs mount from our zone's /export/home 337045916cd2Sjpk */ 337145916cd2Sjpk if (snprintf(lower_fstab.zone_fs_dir, MAXPATHLEN, 337245916cd2Sjpk "%s/zone/%s/export/home", zid_rpath, 337345916cd2Sjpk zone_name) > MAXPATHLEN) 337445916cd2Sjpk continue; 337545916cd2Sjpk 337645916cd2Sjpk /* 337745916cd2Sjpk * If the target is already an LOFS mount 337845916cd2Sjpk * then don't do it again. 337945916cd2Sjpk */ 338045916cd2Sjpk if ((stat(lower_fstab.zone_fs_dir, &stat_buf) == -1) || 338145916cd2Sjpk strcmp(stat_buf.st_fstype, MNTTYPE_LOFS) != 0) { 338245916cd2Sjpk 338345916cd2Sjpk (void) snprintf(lower_fstab.zone_fs_special, 338445916cd2Sjpk MAXPATHLEN, "%s/export/home", rootpath); 338545916cd2Sjpk 338645916cd2Sjpk /* 338745916cd2Sjpk * Mount can fail because the higher-level 338845916cd2Sjpk * zone may have already done a mount down. 338945916cd2Sjpk */ 33900679f794S (void) mount_one(zlogp, &lower_fstab, "", 33910679f794S Z_MNT_BOOT); 339245916cd2Sjpk } 339345916cd2Sjpk } 339445916cd2Sjpk } 339545916cd2Sjpk zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 339645916cd2Sjpk priv_freeset(zid_privs); 339745916cd2Sjpk free(zids); 339845916cd2Sjpk 339945916cd2Sjpk /* 340045916cd2Sjpk * Now share any exported directories from this zone. 340145916cd2Sjpk * Each zone can have its own dfstab. 340245916cd2Sjpk */ 340345916cd2Sjpk 340445916cd2Sjpk argv[0] = "zoneshare"; 340545916cd2Sjpk argv[1] = "-z"; 340645916cd2Sjpk argv[2] = zone_name; 340745916cd2Sjpk argv[3] = NULL; 340845916cd2Sjpk 340945916cd2Sjpk (void) forkexec(zlogp, "/usr/lib/zones/zoneshare", argv); 341045916cd2Sjpk /* Don't check for errors since they don't affect the zone */ 341145916cd2Sjpk 341245916cd2Sjpk return (0); 341345916cd2Sjpk } 341445916cd2Sjpk 341545916cd2Sjpk /* 341645916cd2Sjpk * Unmount lofs mounts from higher level zones 341745916cd2Sjpk * Unshare nfs exported directories 341845916cd2Sjpk */ 341945916cd2Sjpk static void 342045916cd2Sjpk tsol_unmounts(zlog_t *zlogp, char *zone_name) 342145916cd2Sjpk { 342245916cd2Sjpk zoneid_t *zids = NULL; 342345916cd2Sjpk uint_t nzents_saved; 342445916cd2Sjpk uint_t nzents; 342545916cd2Sjpk int i; 342645916cd2Sjpk char *argv[4]; 342745916cd2Sjpk char path[MAXPATHLEN]; 342845916cd2Sjpk 342945916cd2Sjpk if (!is_system_labeled()) 343045916cd2Sjpk return; 343145916cd2Sjpk 343245916cd2Sjpk /* 343345916cd2Sjpk * Get the list of zones from the kernel 343445916cd2Sjpk */ 343545916cd2Sjpk if (zone_list(NULL, &nzents) != 0) { 343645916cd2Sjpk return; 343745916cd2Sjpk } 343845916cd2Sjpk 343945916cd2Sjpk if (zid_label == NULL) { 344045916cd2Sjpk zid_label = m_label_alloc(MAC_LABEL); 344145916cd2Sjpk if (zid_label == NULL) 344245916cd2Sjpk return; 344345916cd2Sjpk } 344445916cd2Sjpk 344545916cd2Sjpk again: 344645916cd2Sjpk if (nzents == 0) 344745916cd2Sjpk return; 344845916cd2Sjpk 344945916cd2Sjpk zids = malloc(nzents * sizeof (zoneid_t)); 345045916cd2Sjpk if (zids == NULL) { 34513f2f09c1Sdp zerror(zlogp, B_TRUE, "memory allocation failed"); 345245916cd2Sjpk return; 345345916cd2Sjpk } 345445916cd2Sjpk nzents_saved = nzents; 345545916cd2Sjpk 345645916cd2Sjpk if (zone_list(zids, &nzents) != 0) { 345745916cd2Sjpk free(zids); 345845916cd2Sjpk return; 345945916cd2Sjpk } 346045916cd2Sjpk if (nzents != nzents_saved) { 346145916cd2Sjpk /* list changed, try again */ 346245916cd2Sjpk free(zids); 346345916cd2Sjpk goto again; 346445916cd2Sjpk } 346545916cd2Sjpk 346645916cd2Sjpk for (i = 0; i < nzents; i++) { 346745916cd2Sjpk char zid_name[ZONENAME_MAX]; 346845916cd2Sjpk zone_state_t zid_state; 346945916cd2Sjpk char zid_rpath[MAXPATHLEN]; 347045916cd2Sjpk 347145916cd2Sjpk if (zids[i] == GLOBAL_ZONEID) 347245916cd2Sjpk continue; 347345916cd2Sjpk 347445916cd2Sjpk if (getzonenamebyid(zids[i], zid_name, ZONENAME_MAX) == -1) 347545916cd2Sjpk continue; 347645916cd2Sjpk 347745916cd2Sjpk /* 347845916cd2Sjpk * Skip the zone we are halting 347945916cd2Sjpk */ 348045916cd2Sjpk if (strcmp(zid_name, zone_name) == 0) 348145916cd2Sjpk continue; 348245916cd2Sjpk 348345916cd2Sjpk if ((zone_getattr(zids[i], ZONE_ATTR_STATUS, &zid_state, 348445916cd2Sjpk sizeof (zid_state)) < 0) || 348545916cd2Sjpk (zid_state < ZONE_IS_READY)) 348645916cd2Sjpk /* Skip over zones without mounted filesystems */ 348745916cd2Sjpk continue; 348845916cd2Sjpk 348945916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_SLBL, zid_label, 349045916cd2Sjpk sizeof (m_label_t)) < 0) 349145916cd2Sjpk /* Skip over zones with unspecified label */ 349245916cd2Sjpk continue; 349345916cd2Sjpk 349445916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_ROOT, zid_rpath, 349545916cd2Sjpk sizeof (zid_rpath)) == -1) 349645916cd2Sjpk /* Skip over zones with bad path */ 349745916cd2Sjpk continue; 349845916cd2Sjpk 349945916cd2Sjpk if (zlabel != NULL && bldominates(zid_label, zlabel)) { 350045916cd2Sjpk /* 350145916cd2Sjpk * This zone dominates our zone. 350245916cd2Sjpk * Unmount the lofs mount of our zone's /export/home 350345916cd2Sjpk */ 350445916cd2Sjpk 350545916cd2Sjpk if (snprintf(path, MAXPATHLEN, 350645916cd2Sjpk "%s/zone/%s/export/home", zid_rpath, 350745916cd2Sjpk zone_name) > MAXPATHLEN) 350845916cd2Sjpk continue; 350945916cd2Sjpk 351045916cd2Sjpk /* Skip over mount failures */ 351145916cd2Sjpk (void) umount(path); 351245916cd2Sjpk } 351345916cd2Sjpk } 351445916cd2Sjpk free(zids); 351545916cd2Sjpk 351645916cd2Sjpk /* 351745916cd2Sjpk * Unmount global zone autofs trigger for this zone 351845916cd2Sjpk */ 351945916cd2Sjpk (void) snprintf(path, MAXPATHLEN, "/zone/%s/home", zone_name); 352045916cd2Sjpk /* Skip over mount failures */ 352145916cd2Sjpk (void) umount(path); 352245916cd2Sjpk 352345916cd2Sjpk /* 352445916cd2Sjpk * Next unshare any exported directories from this zone. 352545916cd2Sjpk */ 352645916cd2Sjpk 352745916cd2Sjpk argv[0] = "zoneunshare"; 352845916cd2Sjpk argv[1] = "-z"; 352945916cd2Sjpk argv[2] = zone_name; 353045916cd2Sjpk argv[3] = NULL; 353145916cd2Sjpk 353245916cd2Sjpk (void) forkexec(zlogp, "/usr/lib/zones/zoneunshare", argv); 353345916cd2Sjpk /* Don't check for errors since they don't affect the zone */ 353445916cd2Sjpk 353545916cd2Sjpk /* 353645916cd2Sjpk * Finally, deallocate any devices in the zone. 353745916cd2Sjpk */ 353845916cd2Sjpk 353945916cd2Sjpk argv[0] = "deallocate"; 354045916cd2Sjpk argv[1] = "-Isz"; 354145916cd2Sjpk argv[2] = zone_name; 354245916cd2Sjpk argv[3] = NULL; 354345916cd2Sjpk 354445916cd2Sjpk (void) forkexec(zlogp, "/usr/sbin/deallocate", argv); 354545916cd2Sjpk /* Don't check for errors since they don't affect the zone */ 354645916cd2Sjpk } 354745916cd2Sjpk 354845916cd2Sjpk /* 354945916cd2Sjpk * Fetch the Trusted Extensions label and multi-level ports (MLPs) for 355045916cd2Sjpk * this zone. 355145916cd2Sjpk */ 355245916cd2Sjpk static tsol_zcent_t * 355345916cd2Sjpk get_zone_label(zlog_t *zlogp, priv_set_t *privs) 355445916cd2Sjpk { 355545916cd2Sjpk FILE *fp; 355645916cd2Sjpk tsol_zcent_t *zcent = NULL; 355745916cd2Sjpk char line[MAXTNZLEN]; 355845916cd2Sjpk 355945916cd2Sjpk if ((fp = fopen(TNZONECFG_PATH, "r")) == NULL) { 356045916cd2Sjpk zerror(zlogp, B_TRUE, "%s", TNZONECFG_PATH); 356145916cd2Sjpk return (NULL); 356245916cd2Sjpk } 356345916cd2Sjpk 356445916cd2Sjpk while (fgets(line, sizeof (line), fp) != NULL) { 356545916cd2Sjpk /* 356645916cd2Sjpk * Check for malformed database 356745916cd2Sjpk */ 356845916cd2Sjpk if (strlen(line) == MAXTNZLEN - 1) 356945916cd2Sjpk break; 357045916cd2Sjpk if ((zcent = tsol_sgetzcent(line, NULL, NULL)) == NULL) 357145916cd2Sjpk continue; 357245916cd2Sjpk if (strcmp(zcent->zc_name, zone_name) == 0) 357345916cd2Sjpk break; 357445916cd2Sjpk tsol_freezcent(zcent); 357545916cd2Sjpk zcent = NULL; 357645916cd2Sjpk } 357745916cd2Sjpk (void) fclose(fp); 357845916cd2Sjpk 357945916cd2Sjpk if (zcent == NULL) { 358045916cd2Sjpk zerror(zlogp, B_FALSE, "zone requires a label assignment. " 358145916cd2Sjpk "See tnzonecfg(4)"); 358245916cd2Sjpk } else { 358345916cd2Sjpk if (zlabel == NULL) 358445916cd2Sjpk zlabel = m_label_alloc(MAC_LABEL); 358545916cd2Sjpk /* 358645916cd2Sjpk * Save this zone's privileges for later read-down processing 358745916cd2Sjpk */ 358845916cd2Sjpk if ((zprivs = priv_allocset()) == NULL) { 358945916cd2Sjpk zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 359045916cd2Sjpk return (NULL); 359145916cd2Sjpk } else { 359245916cd2Sjpk priv_copyset(privs, zprivs); 359345916cd2Sjpk } 359445916cd2Sjpk } 359545916cd2Sjpk return (zcent); 359645916cd2Sjpk } 359745916cd2Sjpk 359845916cd2Sjpk /* 359945916cd2Sjpk * Add the Trusted Extensions multi-level ports for this zone. 360045916cd2Sjpk */ 360145916cd2Sjpk static void 360245916cd2Sjpk set_mlps(zlog_t *zlogp, zoneid_t zoneid, tsol_zcent_t *zcent) 360345916cd2Sjpk { 360445916cd2Sjpk tsol_mlp_t *mlp; 360545916cd2Sjpk tsol_mlpent_t tsme; 360645916cd2Sjpk 360745916cd2Sjpk if (!is_system_labeled()) 360845916cd2Sjpk return; 360945916cd2Sjpk 361045916cd2Sjpk tsme.tsme_zoneid = zoneid; 361145916cd2Sjpk tsme.tsme_flags = 0; 361245916cd2Sjpk for (mlp = zcent->zc_private_mlp; !TSOL_MLP_END(mlp); mlp++) { 361345916cd2Sjpk tsme.tsme_mlp = *mlp; 361445916cd2Sjpk if (tnmlp(TNDB_LOAD, &tsme) != 0) { 361545916cd2Sjpk zerror(zlogp, B_TRUE, "cannot set zone-specific MLP " 361645916cd2Sjpk "on %d-%d/%d", mlp->mlp_port, 361745916cd2Sjpk mlp->mlp_port_upper, mlp->mlp_ipp); 361845916cd2Sjpk } 361945916cd2Sjpk } 362045916cd2Sjpk 362145916cd2Sjpk tsme.tsme_flags = TSOL_MEF_SHARED; 362245916cd2Sjpk for (mlp = zcent->zc_shared_mlp; !TSOL_MLP_END(mlp); mlp++) { 362345916cd2Sjpk tsme.tsme_mlp = *mlp; 362445916cd2Sjpk if (tnmlp(TNDB_LOAD, &tsme) != 0) { 362545916cd2Sjpk zerror(zlogp, B_TRUE, "cannot set shared MLP " 362645916cd2Sjpk "on %d-%d/%d", mlp->mlp_port, 362745916cd2Sjpk mlp->mlp_port_upper, mlp->mlp_ipp); 362845916cd2Sjpk } 362945916cd2Sjpk } 363045916cd2Sjpk } 363145916cd2Sjpk 363245916cd2Sjpk static void 363345916cd2Sjpk remove_mlps(zlog_t *zlogp, zoneid_t zoneid) 363445916cd2Sjpk { 363545916cd2Sjpk tsol_mlpent_t tsme; 363645916cd2Sjpk 363745916cd2Sjpk if (!is_system_labeled()) 363845916cd2Sjpk return; 363945916cd2Sjpk 364045916cd2Sjpk (void) memset(&tsme, 0, sizeof (tsme)); 364145916cd2Sjpk tsme.tsme_zoneid = zoneid; 364245916cd2Sjpk if (tnmlp(TNDB_FLUSH, &tsme) != 0) 364345916cd2Sjpk zerror(zlogp, B_TRUE, "cannot flush MLPs"); 364445916cd2Sjpk } 364545916cd2Sjpk 36467c478bd9Sstevel@tonic-gate int 36477c478bd9Sstevel@tonic-gate prtmount(const char *fs, void *x) { 36487c478bd9Sstevel@tonic-gate zerror((zlog_t *)x, B_FALSE, " %s", fs); 36497c478bd9Sstevel@tonic-gate return (0); 36507c478bd9Sstevel@tonic-gate } 36517c478bd9Sstevel@tonic-gate 3652108322fbScarlsonj /* 3653108322fbScarlsonj * Look for zones running on the main system that are using this root (or any 3654108322fbScarlsonj * subdirectory of it). Return B_TRUE and print an error if a conflicting zone 3655108322fbScarlsonj * is found or if we can't tell. 3656108322fbScarlsonj */ 3657108322fbScarlsonj static boolean_t 3658108322fbScarlsonj duplicate_zone_root(zlog_t *zlogp, const char *rootpath) 36597c478bd9Sstevel@tonic-gate { 3660108322fbScarlsonj zoneid_t *zids = NULL; 3661108322fbScarlsonj uint_t nzids = 0; 3662108322fbScarlsonj boolean_t retv; 3663108322fbScarlsonj int rlen, zlen; 3664108322fbScarlsonj char zroot[MAXPATHLEN]; 3665108322fbScarlsonj char zonename[ZONENAME_MAX]; 3666108322fbScarlsonj 3667108322fbScarlsonj for (;;) { 3668108322fbScarlsonj nzids += 10; 3669108322fbScarlsonj zids = malloc(nzids * sizeof (*zids)); 3670108322fbScarlsonj if (zids == NULL) { 36713f2f09c1Sdp zerror(zlogp, B_TRUE, "memory allocation failed"); 3672108322fbScarlsonj return (B_TRUE); 3673108322fbScarlsonj } 3674108322fbScarlsonj if (zone_list(zids, &nzids) == 0) 3675108322fbScarlsonj break; 3676108322fbScarlsonj free(zids); 3677108322fbScarlsonj } 3678108322fbScarlsonj retv = B_FALSE; 3679108322fbScarlsonj rlen = strlen(rootpath); 3680108322fbScarlsonj while (nzids > 0) { 3681108322fbScarlsonj /* 3682108322fbScarlsonj * Ignore errors; they just mean that the zone has disappeared 3683108322fbScarlsonj * while we were busy. 3684108322fbScarlsonj */ 3685108322fbScarlsonj if (zone_getattr(zids[--nzids], ZONE_ATTR_ROOT, zroot, 3686108322fbScarlsonj sizeof (zroot)) == -1) 3687108322fbScarlsonj continue; 3688108322fbScarlsonj zlen = strlen(zroot); 3689108322fbScarlsonj if (zlen > rlen) 3690108322fbScarlsonj zlen = rlen; 3691108322fbScarlsonj if (strncmp(rootpath, zroot, zlen) == 0 && 3692108322fbScarlsonj (zroot[zlen] == '\0' || zroot[zlen] == '/') && 3693108322fbScarlsonj (rootpath[zlen] == '\0' || rootpath[zlen] == '/')) { 3694108322fbScarlsonj if (getzonenamebyid(zids[nzids], zonename, 3695108322fbScarlsonj sizeof (zonename)) == -1) 3696108322fbScarlsonj (void) snprintf(zonename, sizeof (zonename), 3697108322fbScarlsonj "id %d", (int)zids[nzids]); 3698108322fbScarlsonj zerror(zlogp, B_FALSE, 3699108322fbScarlsonj "zone root %s already in use by zone %s", 3700108322fbScarlsonj rootpath, zonename); 3701108322fbScarlsonj retv = B_TRUE; 3702108322fbScarlsonj break; 3703108322fbScarlsonj } 3704108322fbScarlsonj } 3705108322fbScarlsonj free(zids); 3706108322fbScarlsonj return (retv); 3707108322fbScarlsonj } 3708108322fbScarlsonj 3709108322fbScarlsonj /* 3710108322fbScarlsonj * Search for loopback mounts that use this same source node (same device and 3711108322fbScarlsonj * inode). Return B_TRUE if there is one or if we can't tell. 3712108322fbScarlsonj */ 3713108322fbScarlsonj static boolean_t 3714108322fbScarlsonj duplicate_reachable_path(zlog_t *zlogp, const char *rootpath) 3715108322fbScarlsonj { 3716108322fbScarlsonj struct stat64 rst, zst; 3717108322fbScarlsonj struct mnttab *mnp; 3718108322fbScarlsonj 3719108322fbScarlsonj if (stat64(rootpath, &rst) == -1) { 3720108322fbScarlsonj zerror(zlogp, B_TRUE, "can't stat %s", rootpath); 3721108322fbScarlsonj return (B_TRUE); 3722108322fbScarlsonj } 3723108322fbScarlsonj if (resolve_lofs_mnts == NULL && lofs_read_mnttab(zlogp) == -1) 3724108322fbScarlsonj return (B_TRUE); 3725108322fbScarlsonj for (mnp = resolve_lofs_mnts; mnp < resolve_lofs_mnt_max; mnp++) { 3726108322fbScarlsonj if (mnp->mnt_fstype == NULL || 3727108322fbScarlsonj strcmp(MNTTYPE_LOFS, mnp->mnt_fstype) != 0) 3728108322fbScarlsonj continue; 3729108322fbScarlsonj /* We're looking at a loopback mount. Stat it. */ 3730108322fbScarlsonj if (mnp->mnt_special != NULL && 3731108322fbScarlsonj stat64(mnp->mnt_special, &zst) != -1 && 3732108322fbScarlsonj rst.st_dev == zst.st_dev && rst.st_ino == zst.st_ino) { 3733108322fbScarlsonj zerror(zlogp, B_FALSE, 3734108322fbScarlsonj "zone root %s is reachable through %s", 3735108322fbScarlsonj rootpath, mnp->mnt_mountp); 3736108322fbScarlsonj return (B_TRUE); 3737108322fbScarlsonj } 3738108322fbScarlsonj } 3739108322fbScarlsonj return (B_FALSE); 3740108322fbScarlsonj } 3741108322fbScarlsonj 37420209230bSgjelinek /* 37430209230bSgjelinek * Set memory cap and pool info for the zone's resource management 37440209230bSgjelinek * configuration. 37450209230bSgjelinek */ 37460209230bSgjelinek static int 37470209230bSgjelinek setup_zone_rm(zlog_t *zlogp, char *zone_name, zoneid_t zoneid) 37480209230bSgjelinek { 37490209230bSgjelinek int res; 37500209230bSgjelinek uint64_t tmp; 37510209230bSgjelinek struct zone_mcaptab mcap; 37520209230bSgjelinek char sched[MAXNAMELEN]; 37530209230bSgjelinek zone_dochandle_t handle = NULL; 37540209230bSgjelinek char pool_err[128]; 37550209230bSgjelinek 37560209230bSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 37570209230bSgjelinek zerror(zlogp, B_TRUE, "getting zone configuration handle"); 37580209230bSgjelinek return (Z_BAD_HANDLE); 37590209230bSgjelinek } 37600209230bSgjelinek 37610209230bSgjelinek if ((res = zonecfg_get_snapshot_handle(zone_name, handle)) != Z_OK) { 37620209230bSgjelinek zerror(zlogp, B_FALSE, "invalid configuration"); 37630209230bSgjelinek zonecfg_fini_handle(handle); 37640209230bSgjelinek return (res); 37650209230bSgjelinek } 37660209230bSgjelinek 37670209230bSgjelinek /* 37680209230bSgjelinek * If a memory cap is configured, set the cap in the kernel using 37690209230bSgjelinek * zone_setattr() and make sure the rcapd SMF service is enabled. 37700209230bSgjelinek */ 37710209230bSgjelinek if (zonecfg_getmcapent(handle, &mcap) == Z_OK) { 37720209230bSgjelinek uint64_t num; 37730209230bSgjelinek char smf_err[128]; 37740209230bSgjelinek 37750209230bSgjelinek num = (uint64_t)strtoull(mcap.zone_physmem_cap, NULL, 10); 37760209230bSgjelinek if (zone_setattr(zoneid, ZONE_ATTR_PHYS_MCAP, &num, 0) == -1) { 37770209230bSgjelinek zerror(zlogp, B_TRUE, "could not set zone memory cap"); 37780209230bSgjelinek zonecfg_fini_handle(handle); 37790209230bSgjelinek return (Z_INVAL); 37800209230bSgjelinek } 37810209230bSgjelinek 37820209230bSgjelinek if (zonecfg_enable_rcapd(smf_err, sizeof (smf_err)) != Z_OK) { 37830209230bSgjelinek zerror(zlogp, B_FALSE, "enabling system/rcap service " 37840209230bSgjelinek "failed: %s", smf_err); 37850209230bSgjelinek zonecfg_fini_handle(handle); 37860209230bSgjelinek return (Z_INVAL); 37870209230bSgjelinek } 37880209230bSgjelinek } 37890209230bSgjelinek 37900209230bSgjelinek /* Get the scheduling class set in the zone configuration. */ 37910209230bSgjelinek if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 37920209230bSgjelinek strlen(sched) > 0) { 37930209230bSgjelinek if (zone_setattr(zoneid, ZONE_ATTR_SCHED_CLASS, sched, 37940209230bSgjelinek strlen(sched)) == -1) 37950209230bSgjelinek zerror(zlogp, B_TRUE, "WARNING: unable to set the " 37960209230bSgjelinek "default scheduling class"); 37970209230bSgjelinek 37980209230bSgjelinek } else if (zonecfg_get_aliased_rctl(handle, ALIAS_SHARES, &tmp) 37990209230bSgjelinek == Z_OK) { 38000209230bSgjelinek /* 38010209230bSgjelinek * If the zone has the zone.cpu-shares rctl set then we want to 38020209230bSgjelinek * use the Fair Share Scheduler (FSS) for processes in the 38030209230bSgjelinek * zone. Check what scheduling class the zone would be running 38040209230bSgjelinek * in by default so we can print a warning and modify the class 38050209230bSgjelinek * if we wouldn't be using FSS. 38060209230bSgjelinek */ 38070209230bSgjelinek char class_name[PC_CLNMSZ]; 38080209230bSgjelinek 38090209230bSgjelinek if (zonecfg_get_dflt_sched_class(handle, class_name, 38100209230bSgjelinek sizeof (class_name)) != Z_OK) { 38110209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: unable to determine " 38120209230bSgjelinek "the zone's scheduling class"); 38130209230bSgjelinek 38140209230bSgjelinek } else if (strcmp("FSS", class_name) != 0) { 38150209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: The zone.cpu-shares " 38160209230bSgjelinek "rctl is set but\nFSS is not the default " 38170209230bSgjelinek "scheduling class for\nthis zone. FSS will be " 38180209230bSgjelinek "used for processes\nin the zone but to get the " 38190209230bSgjelinek "full benefit of FSS,\nit should be the default " 38200209230bSgjelinek "scheduling class.\nSee dispadmin(1M) for more " 38210209230bSgjelinek "details."); 38220209230bSgjelinek 38230209230bSgjelinek if (zone_setattr(zoneid, ZONE_ATTR_SCHED_CLASS, "FSS", 38240209230bSgjelinek strlen("FSS")) == -1) 38250209230bSgjelinek zerror(zlogp, B_TRUE, "WARNING: unable to set " 38260209230bSgjelinek "zone scheduling class to FSS"); 38270209230bSgjelinek } 38280209230bSgjelinek } 38290209230bSgjelinek 38300209230bSgjelinek /* 38310209230bSgjelinek * The next few blocks of code attempt to set up temporary pools as 38320209230bSgjelinek * well as persistent pools. In all cases we call the functions 38330209230bSgjelinek * unconditionally. Within each funtion the code will check if the 38340209230bSgjelinek * zone is actually configured for a temporary pool or persistent pool 38350209230bSgjelinek * and just return if there is nothing to do. 38360209230bSgjelinek * 38370209230bSgjelinek * If we are rebooting we want to attempt to reuse any temporary pool 38380209230bSgjelinek * that was previously set up. zonecfg_bind_tmp_pool() will do the 38390209230bSgjelinek * right thing in all cases (reuse or create) based on the current 38400209230bSgjelinek * zonecfg. 38410209230bSgjelinek */ 38420209230bSgjelinek if ((res = zonecfg_bind_tmp_pool(handle, zoneid, pool_err, 38430209230bSgjelinek sizeof (pool_err))) != Z_OK) { 38440209230bSgjelinek if (res == Z_POOL || res == Z_POOL_CREATE || res == Z_POOL_BIND) 38450209230bSgjelinek zerror(zlogp, B_FALSE, "%s: %s\ndedicated-cpu setting " 38460209230bSgjelinek "cannot be instantiated", zonecfg_strerror(res), 38470209230bSgjelinek pool_err); 38480209230bSgjelinek else 38490209230bSgjelinek zerror(zlogp, B_FALSE, "could not bind zone to " 38500209230bSgjelinek "temporary pool: %s", zonecfg_strerror(res)); 38510209230bSgjelinek zonecfg_fini_handle(handle); 38520209230bSgjelinek return (Z_POOL_BIND); 38530209230bSgjelinek } 38540209230bSgjelinek 38550209230bSgjelinek /* 38560209230bSgjelinek * Check if we need to warn about poold not being enabled. 38570209230bSgjelinek */ 38580209230bSgjelinek if (zonecfg_warn_poold(handle)) { 38590209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: A range of dedicated-cpus has " 38600209230bSgjelinek "been specified\nbut the dynamic pool service is not " 38610209230bSgjelinek "enabled.\nThe system will not dynamically adjust the\n" 38620209230bSgjelinek "processor allocation within the specified range\n" 38630209230bSgjelinek "until svc:/system/pools/dynamic is enabled.\n" 38640209230bSgjelinek "See poold(1M)."); 38650209230bSgjelinek } 38660209230bSgjelinek 38670209230bSgjelinek /* The following is a warning, not an error. */ 38680209230bSgjelinek if ((res = zonecfg_bind_pool(handle, zoneid, pool_err, 38690209230bSgjelinek sizeof (pool_err))) != Z_OK) { 38700209230bSgjelinek if (res == Z_POOL_BIND) 38710209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: unable to bind to " 38720209230bSgjelinek "pool '%s'; using default pool.", pool_err); 38730209230bSgjelinek else if (res == Z_POOL) 38740209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: %s: %s", 38750209230bSgjelinek zonecfg_strerror(res), pool_err); 38760209230bSgjelinek else 38770209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: %s", 38780209230bSgjelinek zonecfg_strerror(res)); 38790209230bSgjelinek } 38800209230bSgjelinek 38810209230bSgjelinek zonecfg_fini_handle(handle); 38820209230bSgjelinek return (Z_OK); 38830209230bSgjelinek } 38840209230bSgjelinek 38855679c89fSjv227347 /* 38865679c89fSjv227347 * Sets the hostid of the new zone based on its configured value. The zone's 38875679c89fSjv227347 * zone_t structure must already exist in kernel memory. 'zlogp' refers to the 38885679c89fSjv227347 * log used to report errors and warnings and must be non-NULL. 'zone_namep' 38895679c89fSjv227347 * is the name of the new zone and must be non-NULL. 'zoneid' is the numeric 38905679c89fSjv227347 * ID of the new zone. 38915679c89fSjv227347 * 38925679c89fSjv227347 * This function returns zero on success and a nonzero error code on failure. 38935679c89fSjv227347 */ 38945679c89fSjv227347 static int 38955679c89fSjv227347 setup_zone_hostid(zlog_t *zlogp, char *zone_namep, zoneid_t zoneid) 38965679c89fSjv227347 { 38975679c89fSjv227347 int res; 38985679c89fSjv227347 zone_dochandle_t handle; 38995679c89fSjv227347 char hostidp[HW_HOSTID_LEN]; 39005679c89fSjv227347 unsigned int hostid; 39015679c89fSjv227347 39025679c89fSjv227347 if ((handle = zonecfg_init_handle()) == NULL) { 39035679c89fSjv227347 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 39045679c89fSjv227347 return (Z_BAD_HANDLE); 39055679c89fSjv227347 } 39065679c89fSjv227347 if ((res = zonecfg_get_snapshot_handle(zone_namep, handle)) != Z_OK) { 39075679c89fSjv227347 zerror(zlogp, B_FALSE, "invalid configuration"); 39085679c89fSjv227347 zonecfg_fini_handle(handle); 39095679c89fSjv227347 return (res); 39105679c89fSjv227347 } 39115679c89fSjv227347 39125679c89fSjv227347 if ((res = zonecfg_get_hostid(handle, hostidp, sizeof (hostidp))) == 39135679c89fSjv227347 Z_OK) { 39145679c89fSjv227347 if (zonecfg_valid_hostid(hostidp) != Z_OK) { 39155679c89fSjv227347 zerror(zlogp, B_FALSE, 39165679c89fSjv227347 "zone hostid is not valid: %s", hostidp); 39175679c89fSjv227347 zonecfg_fini_handle(handle); 39185679c89fSjv227347 return (Z_HOSTID_FUBAR); 39195679c89fSjv227347 } 39205679c89fSjv227347 hostid = (unsigned int)strtoul(hostidp, NULL, 16); 39215679c89fSjv227347 if (zone_setattr(zoneid, ZONE_ATTR_HOSTID, &hostid, 39225679c89fSjv227347 sizeof (hostid)) != 0) { 39235679c89fSjv227347 zerror(zlogp, B_TRUE, 39245679c89fSjv227347 "zone hostid is not valid: %s", hostidp); 39255679c89fSjv227347 zonecfg_fini_handle(handle); 39265679c89fSjv227347 return (Z_SYSTEM); 39275679c89fSjv227347 } 39285679c89fSjv227347 } else if (res != Z_BAD_PROPERTY) { 39295679c89fSjv227347 /* 39305679c89fSjv227347 * Z_BAD_PROPERTY is an acceptable error value (from 39315679c89fSjv227347 * zonecfg_get_hostid()) because it indicates that the zone 39325679c89fSjv227347 * doesn't have a hostid. 39335679c89fSjv227347 */ 39345679c89fSjv227347 if (res == Z_TOO_BIG) 39355679c89fSjv227347 zerror(zlogp, B_FALSE, "hostid string in zone " 39365679c89fSjv227347 "configuration is too large."); 39375679c89fSjv227347 else 39385679c89fSjv227347 zerror(zlogp, B_TRUE, "fetching zone hostid from " 39395679c89fSjv227347 "configuration"); 39405679c89fSjv227347 zonecfg_fini_handle(handle); 39415679c89fSjv227347 return (res); 39425679c89fSjv227347 } 39435679c89fSjv227347 39445679c89fSjv227347 zonecfg_fini_handle(handle); 39455679c89fSjv227347 return (Z_OK); 39465679c89fSjv227347 } 39475679c89fSjv227347 3948108322fbScarlsonj zoneid_t 39496cfd72c6Sgjelinek vplat_create(zlog_t *zlogp, zone_mnt_t mount_cmd) 3950108322fbScarlsonj { 3951108322fbScarlsonj zoneid_t rval = -1; 39527c478bd9Sstevel@tonic-gate priv_set_t *privs; 39537c478bd9Sstevel@tonic-gate char rootpath[MAXPATHLEN]; 39547c478bd9Sstevel@tonic-gate char *rctlbuf = NULL; 3955108322fbScarlsonj size_t rctlbufsz = 0; 3956fa9e4066Sahrens char *zfsbuf = NULL; 3957fa9e4066Sahrens size_t zfsbufsz = 0; 3958108322fbScarlsonj zoneid_t zoneid = -1; 39597c478bd9Sstevel@tonic-gate int xerr; 3960108322fbScarlsonj char *kzone; 3961108322fbScarlsonj FILE *fp = NULL; 396245916cd2Sjpk tsol_zcent_t *zcent = NULL; 396345916cd2Sjpk int match = 0; 396445916cd2Sjpk int doi = 0; 3965f4b3ec61Sdh155122 int flags; 3966f4b3ec61Sdh155122 zone_iptype_t iptype; 39677c478bd9Sstevel@tonic-gate 39687c478bd9Sstevel@tonic-gate if (zone_get_rootpath(zone_name, rootpath, sizeof (rootpath)) != Z_OK) { 39697c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to determine zone root"); 39707c478bd9Sstevel@tonic-gate return (-1); 39717c478bd9Sstevel@tonic-gate } 3972108322fbScarlsonj if (zonecfg_in_alt_root()) 3973108322fbScarlsonj resolve_lofs(zlogp, rootpath, sizeof (rootpath)); 39747c478bd9Sstevel@tonic-gate 39752b24ab6bSSebastien Roy if (vplat_get_iptype(zlogp, &iptype) < 0) { 3976f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 3977f4b3ec61Sdh155122 return (-1); 3978f4b3ec61Sdh155122 } 3979f4b3ec61Sdh155122 switch (iptype) { 3980f4b3ec61Sdh155122 case ZS_SHARED: 3981f4b3ec61Sdh155122 flags = 0; 3982f4b3ec61Sdh155122 break; 3983f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 3984f4b3ec61Sdh155122 flags = ZCF_NET_EXCL; 3985f4b3ec61Sdh155122 break; 3986f4b3ec61Sdh155122 } 3987f4b3ec61Sdh155122 39887c478bd9Sstevel@tonic-gate if ((privs = priv_allocset()) == NULL) { 39897c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 39907c478bd9Sstevel@tonic-gate return (-1); 39917c478bd9Sstevel@tonic-gate } 39927c478bd9Sstevel@tonic-gate priv_emptyset(privs); 3993ffbafc53Scomay if (get_privset(zlogp, privs, mount_cmd) != 0) 39947c478bd9Sstevel@tonic-gate goto error; 3995ffbafc53Scomay 39966cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT && 39976cfd72c6Sgjelinek get_rctls(zlogp, &rctlbuf, &rctlbufsz) != 0) { 39987c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "Unable to get list of rctls"); 39997c478bd9Sstevel@tonic-gate goto error; 40007c478bd9Sstevel@tonic-gate } 4001ffbafc53Scomay 4002fa9e4066Sahrens if (get_datasets(zlogp, &zfsbuf, &zfsbufsz) != 0) { 4003fa9e4066Sahrens zerror(zlogp, B_FALSE, "Unable to get list of ZFS datasets"); 4004fa9e4066Sahrens goto error; 4005fa9e4066Sahrens } 40067c478bd9Sstevel@tonic-gate 40076cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT && is_system_labeled()) { 400845916cd2Sjpk zcent = get_zone_label(zlogp, privs); 400948451833Scarlsonj if (zcent != NULL) { 401045916cd2Sjpk match = zcent->zc_match; 401145916cd2Sjpk doi = zcent->zc_doi; 401245916cd2Sjpk *zlabel = zcent->zc_label; 401345916cd2Sjpk } else { 401445916cd2Sjpk goto error; 401545916cd2Sjpk } 401645916cd2Sjpk } 401745916cd2Sjpk 4018108322fbScarlsonj kzone = zone_name; 4019108322fbScarlsonj 4020108322fbScarlsonj /* 4021108322fbScarlsonj * We must do this scan twice. First, we look for zones running on the 4022108322fbScarlsonj * main system that are using this root (or any subdirectory of it). 4023108322fbScarlsonj * Next, we reduce to the shortest path and search for loopback mounts 4024108322fbScarlsonj * that use this same source node (same device and inode). 4025108322fbScarlsonj */ 4026108322fbScarlsonj if (duplicate_zone_root(zlogp, rootpath)) 4027108322fbScarlsonj goto error; 4028108322fbScarlsonj if (duplicate_reachable_path(zlogp, rootpath)) 4029108322fbScarlsonj goto error; 4030108322fbScarlsonj 40316cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd)) { 4032108322fbScarlsonj root_to_lu(zlogp, rootpath, sizeof (rootpath), B_TRUE); 4033108322fbScarlsonj 4034108322fbScarlsonj /* 4035108322fbScarlsonj * Forge up a special root for this zone. When a zone is 4036108322fbScarlsonj * mounted, we can't let the zone have its own root because the 4037108322fbScarlsonj * tools that will be used in this "scratch zone" need access 4038108322fbScarlsonj * to both the zone's resources and the running machine's 4039108322fbScarlsonj * executables. 4040108322fbScarlsonj * 4041108322fbScarlsonj * Note that the mkdir here also catches read-only filesystems. 4042108322fbScarlsonj */ 4043108322fbScarlsonj if (mkdir(rootpath, 0755) != 0 && errno != EEXIST) { 4044108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", rootpath); 4045108322fbScarlsonj goto error; 4046108322fbScarlsonj } 4047108322fbScarlsonj if (domount(zlogp, "tmpfs", "", "swap", rootpath) != 0) 4048108322fbScarlsonj goto error; 4049108322fbScarlsonj } 4050108322fbScarlsonj 4051108322fbScarlsonj if (zonecfg_in_alt_root()) { 4052108322fbScarlsonj /* 4053108322fbScarlsonj * If we are mounting up a zone in an alternate root partition, 4054108322fbScarlsonj * then we have some additional work to do before starting the 4055108322fbScarlsonj * zone. First, resolve the root path down so that we're not 4056108322fbScarlsonj * fooled by duplicates. Then forge up an internal name for 4057108322fbScarlsonj * the zone. 4058108322fbScarlsonj */ 4059108322fbScarlsonj if ((fp = zonecfg_open_scratch("", B_TRUE)) == NULL) { 4060108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot open mapfile"); 4061108322fbScarlsonj goto error; 4062108322fbScarlsonj } 4063108322fbScarlsonj if (zonecfg_lock_scratch(fp) != 0) { 4064108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot lock mapfile"); 4065108322fbScarlsonj goto error; 4066108322fbScarlsonj } 4067108322fbScarlsonj if (zonecfg_find_scratch(fp, zone_name, zonecfg_get_root(), 4068108322fbScarlsonj NULL, 0) == 0) { 4069108322fbScarlsonj zerror(zlogp, B_FALSE, "scratch zone already running"); 4070108322fbScarlsonj goto error; 4071108322fbScarlsonj } 4072108322fbScarlsonj /* This is the preferred name */ 4073108322fbScarlsonj (void) snprintf(kernzone, sizeof (kernzone), "SUNWlu-%s", 4074108322fbScarlsonj zone_name); 4075108322fbScarlsonj srandom(getpid()); 4076108322fbScarlsonj while (zonecfg_reverse_scratch(fp, kernzone, NULL, 0, NULL, 4077108322fbScarlsonj 0) == 0) { 4078108322fbScarlsonj /* This is just an arbitrary name; note "." usage */ 4079108322fbScarlsonj (void) snprintf(kernzone, sizeof (kernzone), 4080108322fbScarlsonj "SUNWlu.%08lX%08lX", random(), random()); 4081108322fbScarlsonj } 4082108322fbScarlsonj kzone = kernzone; 4083108322fbScarlsonj } 4084108322fbScarlsonj 40857c478bd9Sstevel@tonic-gate xerr = 0; 4086108322fbScarlsonj if ((zoneid = zone_create(kzone, rootpath, privs, rctlbuf, 4087f4b3ec61Sdh155122 rctlbufsz, zfsbuf, zfsbufsz, &xerr, match, doi, zlabel, 4088f4b3ec61Sdh155122 flags)) == -1) { 40897c478bd9Sstevel@tonic-gate if (xerr == ZE_AREMOUNTS) { 40907c478bd9Sstevel@tonic-gate if (zonecfg_find_mounts(rootpath, NULL, NULL) < 1) { 40917c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 40927c478bd9Sstevel@tonic-gate "An unknown file-system is mounted on " 40937c478bd9Sstevel@tonic-gate "a subdirectory of %s", rootpath); 40947c478bd9Sstevel@tonic-gate } else { 40957c478bd9Sstevel@tonic-gate 40967c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 40977c478bd9Sstevel@tonic-gate "These file-systems are mounted on " 40987c478bd9Sstevel@tonic-gate "subdirectories of %s:", rootpath); 40997c478bd9Sstevel@tonic-gate (void) zonecfg_find_mounts(rootpath, 41007c478bd9Sstevel@tonic-gate prtmount, zlogp); 41017c478bd9Sstevel@tonic-gate } 41027c478bd9Sstevel@tonic-gate } else if (xerr == ZE_CHROOTED) { 41037c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s: " 41047c478bd9Sstevel@tonic-gate "cannot create a zone from a chrooted " 41057c478bd9Sstevel@tonic-gate "environment", "zone_create"); 41068c55461bSton } else if (xerr == ZE_LABELINUSE) { 41078c55461bSton char zonename[ZONENAME_MAX]; 41088c55461bSton (void) getzonenamebyid(getzoneidbylabel(zlabel), 41098c55461bSton zonename, ZONENAME_MAX); 41108c55461bSton zerror(zlogp, B_FALSE, "The zone label is already " 41118c55461bSton "used by the zone '%s'.", zonename); 41127c478bd9Sstevel@tonic-gate } else { 41137c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "zone_create"); 41147c478bd9Sstevel@tonic-gate } 41157c478bd9Sstevel@tonic-gate goto error; 41167c478bd9Sstevel@tonic-gate } 4117108322fbScarlsonj 4118108322fbScarlsonj if (zonecfg_in_alt_root() && 4119108322fbScarlsonj zonecfg_add_scratch(fp, zone_name, kernzone, 4120108322fbScarlsonj zonecfg_get_root()) == -1) { 4121108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot add mapfile entry"); 4122108322fbScarlsonj goto error; 4123108322fbScarlsonj } 4124108322fbScarlsonj 41250679f794S /* 41260679f794S * The following actions are not performed when merely mounting a zone 41270679f794S * for administrative use. 41280679f794S */ 41290679f794S if (mount_cmd == Z_MNT_BOOT) { 41300679f794S brand_handle_t bh; 41310679f794S struct brand_attr attr; 41320679f794S char modname[MAXPATHLEN]; 41330679f794S 41345679c89fSjv227347 if (setup_zone_hostid(zlogp, zone_name, zoneid) != Z_OK) 41355679c89fSjv227347 goto error; 41365679c89fSjv227347 413762868012SSteve Lawrence if ((bh = brand_open(brand_name)) == NULL) { 41380679f794S zerror(zlogp, B_FALSE, 41390679f794S "unable to determine brand name"); 41405679c89fSjv227347 goto error; 41419acbbeafSnn35248 } 41429acbbeafSnn35248 41439a5d73e0SRic Aleshire if (!is_system_labeled() && 414462868012SSteve Lawrence (strcmp(brand_name, LABELED_BRAND_NAME) == 0)) { 41459a5d73e0SRic Aleshire brand_close(bh); 41469a5d73e0SRic Aleshire zerror(zlogp, B_FALSE, 41479a5d73e0SRic Aleshire "cannot boot labeled zone on unlabeled system"); 41489a5d73e0SRic Aleshire goto error; 41499a5d73e0SRic Aleshire } 41509a5d73e0SRic Aleshire 41519acbbeafSnn35248 /* 41529acbbeafSnn35248 * If this brand requires any kernel support, now is the time to 41539acbbeafSnn35248 * get it loaded and initialized. 41549acbbeafSnn35248 */ 4155123807fbSedp if (brand_get_modname(bh, modname, MAXPATHLEN) < 0) { 4156e767a340Sgjelinek brand_close(bh); 41570679f794S zerror(zlogp, B_FALSE, 41580679f794S "unable to determine brand kernel module"); 41595679c89fSjv227347 goto error; 41609acbbeafSnn35248 } 4161e767a340Sgjelinek brand_close(bh); 41629acbbeafSnn35248 41639acbbeafSnn35248 if (strlen(modname) > 0) { 416462868012SSteve Lawrence (void) strlcpy(attr.ba_brandname, brand_name, 416562868012SSteve Lawrence sizeof (attr.ba_brandname)); 416662868012SSteve Lawrence (void) strlcpy(attr.ba_modname, modname, 416762868012SSteve Lawrence sizeof (attr.ba_modname)); 41689acbbeafSnn35248 if (zone_setattr(zoneid, ZONE_ATTR_BRAND, &attr, 41699acbbeafSnn35248 sizeof (attr) != 0)) { 41700679f794S zerror(zlogp, B_TRUE, 41710679f794S "could not set zone brand attribute."); 41729acbbeafSnn35248 goto error; 41739acbbeafSnn35248 } 41749acbbeafSnn35248 } 41759acbbeafSnn35248 41765679c89fSjv227347 if (setup_zone_rm(zlogp, zone_name, zoneid) != Z_OK) 41770209230bSgjelinek goto error; 41780209230bSgjelinek 417945916cd2Sjpk set_mlps(zlogp, zoneid, zcent); 41800209230bSgjelinek } 41810209230bSgjelinek 4182108322fbScarlsonj rval = zoneid; 4183108322fbScarlsonj zoneid = -1; 4184108322fbScarlsonj 41857c478bd9Sstevel@tonic-gate error: 41865679c89fSjv227347 if (zoneid != -1) { 41875679c89fSjv227347 (void) zone_shutdown(zoneid); 4188108322fbScarlsonj (void) zone_destroy(zoneid); 41895679c89fSjv227347 } 41907c478bd9Sstevel@tonic-gate if (rctlbuf != NULL) 41917c478bd9Sstevel@tonic-gate free(rctlbuf); 41927c478bd9Sstevel@tonic-gate priv_freeset(privs); 4193108322fbScarlsonj if (fp != NULL) 4194108322fbScarlsonj zonecfg_close_scratch(fp); 4195108322fbScarlsonj lofs_discard_mnttab(); 419645916cd2Sjpk if (zcent != NULL) 419745916cd2Sjpk tsol_freezcent(zcent); 41987c478bd9Sstevel@tonic-gate return (rval); 41997c478bd9Sstevel@tonic-gate } 42007c478bd9Sstevel@tonic-gate 4201555afedfScarlsonj /* 4202555afedfScarlsonj * Enter the zone and write a /etc/zones/index file there. This allows 4203555afedfScarlsonj * libzonecfg (and thus zoneadm) to report the UUID and potentially other zone 4204555afedfScarlsonj * details from inside the zone. 4205555afedfScarlsonj */ 4206555afedfScarlsonj static void 4207555afedfScarlsonj write_index_file(zoneid_t zoneid) 4208555afedfScarlsonj { 4209555afedfScarlsonj FILE *zef; 4210555afedfScarlsonj FILE *zet; 4211555afedfScarlsonj struct zoneent *zep; 4212555afedfScarlsonj pid_t child; 4213555afedfScarlsonj int tmpl_fd; 4214555afedfScarlsonj ctid_t ct; 4215555afedfScarlsonj int fd; 4216555afedfScarlsonj char uuidstr[UUID_PRINTABLE_STRING_LENGTH]; 4217555afedfScarlsonj 4218555afedfScarlsonj /* Locate the zone entry in the global zone's index file */ 4219555afedfScarlsonj if ((zef = setzoneent()) == NULL) 4220555afedfScarlsonj return; 4221555afedfScarlsonj while ((zep = getzoneent_private(zef)) != NULL) { 4222555afedfScarlsonj if (strcmp(zep->zone_name, zone_name) == 0) 4223555afedfScarlsonj break; 4224555afedfScarlsonj free(zep); 4225555afedfScarlsonj } 4226555afedfScarlsonj endzoneent(zef); 4227555afedfScarlsonj if (zep == NULL) 4228555afedfScarlsonj return; 4229555afedfScarlsonj 4230555afedfScarlsonj if ((tmpl_fd = init_template()) == -1) { 4231555afedfScarlsonj free(zep); 4232555afedfScarlsonj return; 4233555afedfScarlsonj } 4234555afedfScarlsonj 4235555afedfScarlsonj if ((child = fork()) == -1) { 4236555afedfScarlsonj (void) ct_tmpl_clear(tmpl_fd); 4237555afedfScarlsonj (void) close(tmpl_fd); 4238555afedfScarlsonj free(zep); 4239555afedfScarlsonj return; 4240555afedfScarlsonj } 4241555afedfScarlsonj 4242555afedfScarlsonj /* parent waits for child to finish */ 4243555afedfScarlsonj if (child != 0) { 4244555afedfScarlsonj free(zep); 4245555afedfScarlsonj if (contract_latest(&ct) == -1) 4246555afedfScarlsonj ct = -1; 4247555afedfScarlsonj (void) ct_tmpl_clear(tmpl_fd); 4248555afedfScarlsonj (void) close(tmpl_fd); 4249555afedfScarlsonj (void) waitpid(child, NULL, 0); 4250555afedfScarlsonj (void) contract_abandon_id(ct); 4251555afedfScarlsonj return; 4252555afedfScarlsonj } 4253555afedfScarlsonj 4254555afedfScarlsonj /* child enters zone and sets up index file */ 4255555afedfScarlsonj (void) ct_tmpl_clear(tmpl_fd); 4256555afedfScarlsonj if (zone_enter(zoneid) != -1) { 4257555afedfScarlsonj (void) mkdir(ZONE_CONFIG_ROOT, ZONE_CONFIG_MODE); 4258555afedfScarlsonj (void) chown(ZONE_CONFIG_ROOT, ZONE_CONFIG_UID, 4259555afedfScarlsonj ZONE_CONFIG_GID); 4260555afedfScarlsonj fd = open(ZONE_INDEX_FILE, O_WRONLY|O_CREAT|O_TRUNC, 4261555afedfScarlsonj ZONE_INDEX_MODE); 4262555afedfScarlsonj if (fd != -1 && (zet = fdopen(fd, "w")) != NULL) { 4263555afedfScarlsonj (void) fchown(fd, ZONE_INDEX_UID, ZONE_INDEX_GID); 4264555afedfScarlsonj if (uuid_is_null(zep->zone_uuid)) 4265555afedfScarlsonj uuidstr[0] = '\0'; 4266555afedfScarlsonj else 4267555afedfScarlsonj uuid_unparse(zep->zone_uuid, uuidstr); 4268555afedfScarlsonj (void) fprintf(zet, "%s:%s:/:%s\n", zep->zone_name, 4269555afedfScarlsonj zone_state_str(zep->zone_state), 4270555afedfScarlsonj uuidstr); 4271555afedfScarlsonj (void) fclose(zet); 4272555afedfScarlsonj } 4273555afedfScarlsonj } 4274555afedfScarlsonj _exit(0); 4275555afedfScarlsonj } 4276555afedfScarlsonj 42777c478bd9Sstevel@tonic-gate int 42786cfd72c6Sgjelinek vplat_bringup(zlog_t *zlogp, zone_mnt_t mount_cmd, zoneid_t zoneid) 42797c478bd9Sstevel@tonic-gate { 42809acbbeafSnn35248 char zonepath[MAXPATHLEN]; 42815749802bSdp 42826cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT && validate_datasets(zlogp) != 0) { 4283fa9e4066Sahrens lofs_discard_mnttab(); 4284fa9e4066Sahrens return (-1); 4285fa9e4066Sahrens } 4286fa9e4066Sahrens 42879acbbeafSnn35248 /* 42889acbbeafSnn35248 * Before we try to mount filesystems we need to create the 42899acbbeafSnn35248 * attribute backing store for /dev 42909acbbeafSnn35248 */ 42919acbbeafSnn35248 if (zone_get_zonepath(zone_name, zonepath, sizeof (zonepath)) != Z_OK) { 42929acbbeafSnn35248 lofs_discard_mnttab(); 42939acbbeafSnn35248 return (-1); 42949acbbeafSnn35248 } 429516bca938Svp157776 resolve_lofs(zlogp, zonepath, sizeof (zonepath)); 429627e6fb21Sdp 429727e6fb21Sdp /* Make /dev directory owned by root, grouped sys */ 429827e6fb21Sdp if (make_one_dir(zlogp, zonepath, "/dev", DEFAULT_DIR_MODE, 429927e6fb21Sdp 0, 3) != 0) { 4300108322fbScarlsonj lofs_discard_mnttab(); 43017c478bd9Sstevel@tonic-gate return (-1); 4302108322fbScarlsonj } 4303facf4a8dSllai1 43049acbbeafSnn35248 if (mount_filesystems(zlogp, mount_cmd) != 0) { 4305facf4a8dSllai1 lofs_discard_mnttab(); 4306facf4a8dSllai1 return (-1); 4307facf4a8dSllai1 } 4308facf4a8dSllai1 43096cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT) { 4310f4b3ec61Sdh155122 zone_iptype_t iptype; 4311f4b3ec61Sdh155122 43122b24ab6bSSebastien Roy if (vplat_get_iptype(zlogp, &iptype) < 0) { 4313f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 4314108322fbScarlsonj lofs_discard_mnttab(); 43157c478bd9Sstevel@tonic-gate return (-1); 4316108322fbScarlsonj } 4317555afedfScarlsonj 4318f4b3ec61Sdh155122 switch (iptype) { 4319f4b3ec61Sdh155122 case ZS_SHARED: 4320f4b3ec61Sdh155122 /* Always do this to make lo0 get configured */ 4321f4b3ec61Sdh155122 if (configure_shared_network_interfaces(zlogp) != 0) { 4322f4b3ec61Sdh155122 lofs_discard_mnttab(); 4323f4b3ec61Sdh155122 return (-1); 4324f4b3ec61Sdh155122 } 4325f4b3ec61Sdh155122 break; 4326f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 4327f4b3ec61Sdh155122 if (configure_exclusive_network_interfaces(zlogp) != 4328f4b3ec61Sdh155122 0) { 4329f4b3ec61Sdh155122 lofs_discard_mnttab(); 4330f4b3ec61Sdh155122 return (-1); 4331f4b3ec61Sdh155122 } 4332f4b3ec61Sdh155122 break; 4333f4b3ec61Sdh155122 } 4334f4b3ec61Sdh155122 } 4335f4b3ec61Sdh155122 4336555afedfScarlsonj write_index_file(zoneid); 4337555afedfScarlsonj 4338108322fbScarlsonj lofs_discard_mnttab(); 43397c478bd9Sstevel@tonic-gate return (0); 43407c478bd9Sstevel@tonic-gate } 43417c478bd9Sstevel@tonic-gate 4342108322fbScarlsonj static int 4343108322fbScarlsonj lu_root_teardown(zlog_t *zlogp) 43447c478bd9Sstevel@tonic-gate { 4345108322fbScarlsonj char zroot[MAXPATHLEN]; 4346108322fbScarlsonj 4347108322fbScarlsonj if (zone_get_rootpath(zone_name, zroot, sizeof (zroot)) != Z_OK) { 4348108322fbScarlsonj zerror(zlogp, B_FALSE, "unable to determine zone root"); 4349108322fbScarlsonj return (-1); 4350108322fbScarlsonj } 4351108322fbScarlsonj root_to_lu(zlogp, zroot, sizeof (zroot), B_FALSE); 4352108322fbScarlsonj 4353108322fbScarlsonj /* 4354108322fbScarlsonj * At this point, the processes are gone, the filesystems (save the 4355108322fbScarlsonj * root) are unmounted, and the zone is on death row. But there may 4356108322fbScarlsonj * still be creds floating about in the system that reference the 4357108322fbScarlsonj * zone_t, and which pin down zone_rootvp causing this call to fail 4358108322fbScarlsonj * with EBUSY. Thus, we try for a little while before just giving up. 4359108322fbScarlsonj * (How I wish this were not true, and umount2 just did the right 4360108322fbScarlsonj * thing, or tmpfs supported MS_FORCE This is a gross hack.) 4361108322fbScarlsonj */ 4362108322fbScarlsonj if (umount2(zroot, MS_FORCE) != 0) { 4363108322fbScarlsonj if (errno == ENOTSUP && umount2(zroot, 0) == 0) 4364108322fbScarlsonj goto unmounted; 4365108322fbScarlsonj if (errno == EBUSY) { 4366108322fbScarlsonj int tries = 10; 4367108322fbScarlsonj 4368108322fbScarlsonj while (--tries >= 0) { 4369108322fbScarlsonj (void) sleep(1); 4370108322fbScarlsonj if (umount2(zroot, 0) == 0) 4371108322fbScarlsonj goto unmounted; 4372108322fbScarlsonj if (errno != EBUSY) 4373108322fbScarlsonj break; 4374108322fbScarlsonj } 4375108322fbScarlsonj } 4376108322fbScarlsonj zerror(zlogp, B_TRUE, "unable to unmount '%s'", zroot); 4377108322fbScarlsonj return (-1); 4378108322fbScarlsonj } 4379108322fbScarlsonj unmounted: 4380108322fbScarlsonj 4381108322fbScarlsonj /* 4382108322fbScarlsonj * Only zones in an alternate root environment have scratch zone 4383108322fbScarlsonj * entries. 4384108322fbScarlsonj */ 4385108322fbScarlsonj if (zonecfg_in_alt_root()) { 4386108322fbScarlsonj FILE *fp; 4387108322fbScarlsonj int retv; 4388108322fbScarlsonj 4389108322fbScarlsonj if ((fp = zonecfg_open_scratch("", B_FALSE)) == NULL) { 4390108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot open mapfile"); 4391108322fbScarlsonj return (-1); 4392108322fbScarlsonj } 4393108322fbScarlsonj retv = -1; 4394108322fbScarlsonj if (zonecfg_lock_scratch(fp) != 0) 4395108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot lock mapfile"); 4396108322fbScarlsonj else if (zonecfg_delete_scratch(fp, kernzone) != 0) 4397108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot delete map entry"); 4398108322fbScarlsonj else 4399108322fbScarlsonj retv = 0; 4400108322fbScarlsonj zonecfg_close_scratch(fp); 4401108322fbScarlsonj return (retv); 4402108322fbScarlsonj } else { 4403108322fbScarlsonj return (0); 4404108322fbScarlsonj } 4405108322fbScarlsonj } 4406108322fbScarlsonj 4407108322fbScarlsonj int 44080209230bSgjelinek vplat_teardown(zlog_t *zlogp, boolean_t unmount_cmd, boolean_t rebooting) 4409108322fbScarlsonj { 4410108322fbScarlsonj char *kzone; 44117c478bd9Sstevel@tonic-gate zoneid_t zoneid; 44120209230bSgjelinek int res; 44130209230bSgjelinek char pool_err[128]; 4414ff17c8bfSgjelinek char zpath[MAXPATHLEN]; 44159acbbeafSnn35248 char cmdbuf[MAXPATHLEN]; 4416123807fbSedp brand_handle_t bh = NULL; 44172b24ab6bSSebastien Roy dladm_status_t status; 44182b24ab6bSSebastien Roy char errmsg[DLADM_STRSIZE]; 4419f4b3ec61Sdh155122 ushort_t flags; 44207c478bd9Sstevel@tonic-gate 4421108322fbScarlsonj kzone = zone_name; 4422108322fbScarlsonj if (zonecfg_in_alt_root()) { 4423108322fbScarlsonj FILE *fp; 4424108322fbScarlsonj 4425108322fbScarlsonj if ((fp = zonecfg_open_scratch("", B_FALSE)) == NULL) { 4426108322fbScarlsonj zerror(zlogp, B_TRUE, "unable to open map file"); 4427108322fbScarlsonj goto error; 4428108322fbScarlsonj } 4429108322fbScarlsonj if (zonecfg_find_scratch(fp, zone_name, zonecfg_get_root(), 4430108322fbScarlsonj kernzone, sizeof (kernzone)) != 0) { 4431108322fbScarlsonj zerror(zlogp, B_FALSE, "unable to find scratch zone"); 4432108322fbScarlsonj zonecfg_close_scratch(fp); 4433108322fbScarlsonj goto error; 4434108322fbScarlsonj } 4435108322fbScarlsonj zonecfg_close_scratch(fp); 4436108322fbScarlsonj kzone = kernzone; 4437108322fbScarlsonj } 4438108322fbScarlsonj 4439108322fbScarlsonj if ((zoneid = getzoneidbyname(kzone)) == ZONE_ID_UNDEFINED) { 44407c478bd9Sstevel@tonic-gate if (!bringup_failure_recovery) 44417c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to get zoneid"); 4442108322fbScarlsonj if (unmount_cmd) 4443108322fbScarlsonj (void) lu_root_teardown(zlogp); 44447c478bd9Sstevel@tonic-gate goto error; 44457c478bd9Sstevel@tonic-gate } 44467c478bd9Sstevel@tonic-gate 44477c478bd9Sstevel@tonic-gate if (zone_shutdown(zoneid) != 0) { 44487c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to shutdown zone"); 44497c478bd9Sstevel@tonic-gate goto error; 44507c478bd9Sstevel@tonic-gate } 44517c478bd9Sstevel@tonic-gate 4452ff17c8bfSgjelinek /* Get the zonepath of this zone */ 4453ff17c8bfSgjelinek if (zone_get_zonepath(zone_name, zpath, sizeof (zpath)) != Z_OK) { 4454ff17c8bfSgjelinek zerror(zlogp, B_FALSE, "unable to determine zone path"); 44559acbbeafSnn35248 goto error; 44569acbbeafSnn35248 } 44579acbbeafSnn35248 44589acbbeafSnn35248 /* Get a handle to the brand info for this zone */ 445962868012SSteve Lawrence if ((bh = brand_open(brand_name)) == NULL) { 44609acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 44619acbbeafSnn35248 return (-1); 44629acbbeafSnn35248 } 44639acbbeafSnn35248 /* 44649acbbeafSnn35248 * If there is a brand 'halt' callback, execute it now to give the 44659acbbeafSnn35248 * brand a chance to cleanup any custom configuration. 44669acbbeafSnn35248 */ 44679acbbeafSnn35248 (void) strcpy(cmdbuf, EXEC_PREFIX); 4468ff17c8bfSgjelinek if (brand_get_halt(bh, zone_name, zpath, cmdbuf + EXEC_LEN, 4469ff17c8bfSgjelinek sizeof (cmdbuf) - EXEC_LEN) < 0) { 4470123807fbSedp brand_close(bh); 44719acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to determine branded zone's " 44729acbbeafSnn35248 "halt callback."); 44739acbbeafSnn35248 goto error; 44749acbbeafSnn35248 } 4475123807fbSedp brand_close(bh); 44769acbbeafSnn35248 44779acbbeafSnn35248 if ((strlen(cmdbuf) > EXEC_LEN) && 4478c5cd6260S (do_subproc(zlogp, cmdbuf, NULL) != Z_OK)) { 44799acbbeafSnn35248 zerror(zlogp, B_FALSE, "%s failed", cmdbuf); 44809acbbeafSnn35248 goto error; 44819acbbeafSnn35248 } 44829acbbeafSnn35248 4483f4b3ec61Sdh155122 if (!unmount_cmd) { 4484f4b3ec61Sdh155122 zone_iptype_t iptype; 4485f4b3ec61Sdh155122 4486f4b3ec61Sdh155122 if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &flags, 4487f4b3ec61Sdh155122 sizeof (flags)) < 0) { 44882b24ab6bSSebastien Roy if (vplat_get_iptype(zlogp, &iptype) < 0) { 4489f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to determine " 4490f4b3ec61Sdh155122 "ip-type"); 44917c478bd9Sstevel@tonic-gate goto error; 44927c478bd9Sstevel@tonic-gate } 4493f4b3ec61Sdh155122 } else { 4494f4b3ec61Sdh155122 if (flags & ZF_NET_EXCL) 4495f4b3ec61Sdh155122 iptype = ZS_EXCLUSIVE; 4496f4b3ec61Sdh155122 else 4497f4b3ec61Sdh155122 iptype = ZS_SHARED; 4498f4b3ec61Sdh155122 } 4499f4b3ec61Sdh155122 4500f4b3ec61Sdh155122 switch (iptype) { 4501f4b3ec61Sdh155122 case ZS_SHARED: 4502f4b3ec61Sdh155122 if (unconfigure_shared_network_interfaces(zlogp, 4503f4b3ec61Sdh155122 zoneid) != 0) { 4504f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "unable to unconfigure " 4505f4b3ec61Sdh155122 "network interfaces in zone"); 4506f4b3ec61Sdh155122 goto error; 4507f4b3ec61Sdh155122 } 4508f4b3ec61Sdh155122 break; 4509f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 4510f4b3ec61Sdh155122 if (unconfigure_exclusive_network_interfaces(zlogp, 4511f4b3ec61Sdh155122 zoneid) != 0) { 4512f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "unable to unconfigure " 4513f4b3ec61Sdh155122 "network interfaces in zone"); 4514f4b3ec61Sdh155122 goto error; 4515f4b3ec61Sdh155122 } 45162b24ab6bSSebastien Roy status = dladm_zone_halt(dld_handle, zoneid); 45172b24ab6bSSebastien Roy if (status != DLADM_STATUS_OK) { 45182b24ab6bSSebastien Roy zerror(zlogp, B_FALSE, "unable to notify " 45192b24ab6bSSebastien Roy "dlmgmtd of zone halt: %s", 45202b24ab6bSSebastien Roy dladm_status2str(status, errmsg)); 45212b24ab6bSSebastien Roy } 4522f4b3ec61Sdh155122 break; 4523f4b3ec61Sdh155122 } 4524f4b3ec61Sdh155122 } 45257c478bd9Sstevel@tonic-gate 4526108322fbScarlsonj if (!unmount_cmd && tcp_abort_connections(zlogp, zoneid) != 0) { 45277c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to abort TCP connections"); 45287c478bd9Sstevel@tonic-gate goto error; 45297c478bd9Sstevel@tonic-gate } 45307c478bd9Sstevel@tonic-gate 4531108322fbScarlsonj if (unmount_filesystems(zlogp, zoneid, unmount_cmd) != 0) { 45327c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 45337c478bd9Sstevel@tonic-gate "unable to unmount file systems in zone"); 45347c478bd9Sstevel@tonic-gate goto error; 45357c478bd9Sstevel@tonic-gate } 45367c478bd9Sstevel@tonic-gate 45370209230bSgjelinek /* 4538cf6b13d2Sgjelinek * If we are rebooting then we normally don't want to destroy an 4539cf6b13d2Sgjelinek * existing temporary pool at this point so that we can just reuse it 4540cf6b13d2Sgjelinek * when the zone boots back up. However, it is also possible we were 4541cf6b13d2Sgjelinek * running with a temporary pool and the zone configuration has been 4542cf6b13d2Sgjelinek * modified to no longer use a temporary pool. In that case we need 4543cf6b13d2Sgjelinek * to destroy the temporary pool now. This case looks like the case 4544cf6b13d2Sgjelinek * where we never had a temporary pool configured but 4545cf6b13d2Sgjelinek * zonecfg_destroy_tmp_pool will do the right thing either way. 45460209230bSgjelinek */ 4547cf6b13d2Sgjelinek if (!unmount_cmd) { 4548cf6b13d2Sgjelinek boolean_t destroy_tmp_pool = B_TRUE; 4549cf6b13d2Sgjelinek 4550cf6b13d2Sgjelinek if (rebooting) { 4551cf6b13d2Sgjelinek struct zone_psettab pset_tab; 4552cf6b13d2Sgjelinek zone_dochandle_t handle; 4553cf6b13d2Sgjelinek 4554cf6b13d2Sgjelinek if ((handle = zonecfg_init_handle()) != NULL && 4555cf6b13d2Sgjelinek zonecfg_get_handle(zone_name, handle) == Z_OK && 4556cf6b13d2Sgjelinek zonecfg_lookup_pset(handle, &pset_tab) == Z_OK) 4557cf6b13d2Sgjelinek destroy_tmp_pool = B_FALSE; 4558e767a340Sgjelinek 4559e767a340Sgjelinek zonecfg_fini_handle(handle); 4560cf6b13d2Sgjelinek } 4561cf6b13d2Sgjelinek 4562cf6b13d2Sgjelinek if (destroy_tmp_pool) { 45630209230bSgjelinek if ((res = zonecfg_destroy_tmp_pool(zone_name, pool_err, 45640209230bSgjelinek sizeof (pool_err))) != Z_OK) { 45650209230bSgjelinek if (res == Z_POOL) 45660209230bSgjelinek zerror(zlogp, B_FALSE, pool_err); 45670209230bSgjelinek } 45680209230bSgjelinek } 4569cf6b13d2Sgjelinek } 45700209230bSgjelinek 457145916cd2Sjpk remove_mlps(zlogp, zoneid); 457245916cd2Sjpk 45737c478bd9Sstevel@tonic-gate if (zone_destroy(zoneid) != 0) { 45747c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to destroy zone"); 45757c478bd9Sstevel@tonic-gate goto error; 45767c478bd9Sstevel@tonic-gate } 4577108322fbScarlsonj 4578108322fbScarlsonj /* 4579108322fbScarlsonj * Special teardown for alternate boot environments: remove the tmpfs 4580108322fbScarlsonj * root for the zone and then remove it from the map file. 4581108322fbScarlsonj */ 4582108322fbScarlsonj if (unmount_cmd && lu_root_teardown(zlogp) != 0) 4583108322fbScarlsonj goto error; 4584108322fbScarlsonj 4585108322fbScarlsonj lofs_discard_mnttab(); 45867c478bd9Sstevel@tonic-gate return (0); 45877c478bd9Sstevel@tonic-gate 45887c478bd9Sstevel@tonic-gate error: 4589108322fbScarlsonj lofs_discard_mnttab(); 45907c478bd9Sstevel@tonic-gate return (-1); 45917c478bd9Sstevel@tonic-gate } 4592